Dark Emblem Rewrite - idmontie's Portfolio

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
 const _components = Object.assign({
 p: "p",
 a: "a",
 em: "em",
 hr: "hr",
 pre: "pre",
 code: "code"
 }, props.components);
 return _jsxs(_Fragment, {
 children: [_jsxs(_components.p, {
 children: ["Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether ", _jsx(_components.a, {
 href: "https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff",
 children: "ChatGPT can play 20 questions"
 }), ". The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly."]
 }), "\n", _jsx(_components.p, {
 children: "I attempted to do 20 questions with ChatGPT using a different prompt:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: I would like to play a game. It's called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure, I'd be happy to play \"Twenty Questions\" with you. Please go ahead and think of something, and I will start asking my first question."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: I am ready"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you can hold in your hand?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would typically find in a kitchen?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would use for transportation?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would use for entertainment or leisure?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a musical instrument?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a type of game or puzzle?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a piece of technology such as a phone or computer?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a book or magazine?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a novel or a collection of short stories?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a specific book that is widely known and read?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object \"To Kill a Mockingbird\" by Harper Lee?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I'm sorry, I'm running out of ideas. Can you give me a hint or tell me the answer?"
 })
 }), "\n", _jsx(_components.p, {
 children: "Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: You are on the right track. It is by Walt Whitman"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object \"Leaves of Grass\" by Walt Whitman?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes! Congratulations!"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Thank you! I'm glad I was able to guess the object you were thinking of. It was fun playing \"Twenty Questions\" with you. Let me know if you want to play again sometime."
 })
 }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.p, {
 children: ["I’ve been keeping an eye on how other people are using ChatGPT, and ", _jsx(_components.a, {
 href: "https://en.wikipedia.org/wiki/Prompt_engineering",
 children: "prompt engineering"
 }), " is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations."]
 }), "\n", _jsxs(_components.p, {
 children: ["So I was curious when I read that “", _jsx(_components.a, {
 href: "https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/",
 children: "ChatGPT can’t write sentences that end in a specific letter"
 }), "”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt."]
 }), "\n", _jsx(_components.p, {
 children: "So let’s start with a very simple question to ChatGPT:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you write a sentence that ends with the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The cat sat on the mat."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: That sentence does not end in the letter \"a\". Can you write a sentence that ends in the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I can't think of anything right now, but the word \"America\" ends with letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Great, write a sentence that ends in that word. That will then satisfy the original question."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The land of the free, and the home of the brave, America."
 })
 }), "\n", _jsx(_components.p, {
 children: "Okay, that does technically end in the letter a, but the sentence seems very strange."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: That isn't a very coherent sentence. Can you write a sentence that ends in the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter \"a\" - \"He saw the drama unfold on the stage, it was quite the spectacle, a.”"
 })
 }), "\n", _jsx(_components.p, {
 children: "Looks like we are going off the rails here. Let’s try a different approach:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Write a sentence that ends in a word that ends with the letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with."
 })
 }), "\n", _jsx(_components.p, {
 children: "I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure, to get me to write a sentence that ends in the letter \"a\" you could provide a prompt like: \"Write a sentence that ends with a word that ends with the letter 'a'\" or \"Can you write a sentence with a word ending in 'a' at the end of the sentence?\" . This makes it clear that the sentence should end in a word ending with the letter 'a'."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you write a sentence with a word ending in 'a' at the end of the sentence?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka."
 })
 }), "\n", _jsx(_components.hr, {}), "\n", _jsx(_components.p, {
 children: "While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I've seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response."
 }), "\n", _jsx(_components.p, {
 children: "One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you make ASCII art? Show me a picture of a cat."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure! Here is a picture of a cat using ASCII art:"
 })
 }), "\n", _jsx(_components.pre, {
 children: _jsx(_components.code, {
 children: " /\\_/\\\n( o.o )\n >^<\n\n"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "I hope you like it! Is there anything else I can help with?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you make it more detailed"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:"
 })
 }), "\n", _jsx(_components.pre, {
 children: _jsx(_components.code, {
 children: " /\\_/\\\n( o.o )\n >^<\n | |\n || ||\n \\\\ //\n // \\\\\n \\\\_//\n / \\\n / \\\n\n"
 })
 }), "\n", _jsx(_components.p, {
 children: "With new language models coming out, it's important to recognize what the limitations\nof the AI are. Poor responses can be a result of poorly written prompts, but there\nare times, like with letters in words with ChatGPT, where the AI just doesn't have\nthe capability to understand the question."
 })]
 });
}
function MDXContent(props = {}) {
 const {wrapper: MDXLayout} = props.components || ({});
 return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
 children: _jsx(_createMdxContent, props)
 })) : _createMdxContent(props);
}
return {
 default: MDXContent
};

Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether <a href="https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff">ChatGPT can play 20 questions</a>. The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly.
I attempted to do 20 questions with ChatGPT using a different prompt:
Me: I would like to play a game. It&#x27;s called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about.
ChatGPT: Sure, I&#x27;d be happy to play &quot;Twenty Questions&quot; with you. Please go ahead and think of something, and I will start asking my first question.
Me: I am ready
ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?
Me: Yes
ChatGPT: Is the object something that you can hold in your hand?
Me: Yes
ChatGPT: Is the object something that you would typically find in a kitchen?
Me: No
ChatGPT: Is the object something that you would use for transportation?
Me: No
ChatGPT: Is the object something that you would use for entertainment or leisure?
Me: Yes
ChatGPT: Is the object a musical instrument?
Me: No
ChatGPT: Is the object a type of game or puzzle?
Me: No
ChatGPT: Is the object a piece of technology such as a phone or computer?
Me: No
ChatGPT: Is the object a book or magazine?
Me: Yes
ChatGPT: Is the object a novel or a collection of short stories?
Me: Yes
ChatGPT: Is the object a specific book that is widely known and read?
Me: Yes
ChatGPT: Is the object &quot;To Kill a Mockingbird&quot; by Harper Lee?
Me: No
ChatGPT: I&#x27;m sorry, I&#x27;m running out of ideas. Can you give me a hint or tell me the answer?
Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint.
Me: You are on the right track. It is by Walt Whitman
ChatGPT: Is the object &quot;Leaves of Grass&quot; by Walt Whitman?
Me: Yes! Congratulations!
ChatGPT: Thank you! I&#x27;m glad I was able to guess the object you were thinking of. It was fun playing &quot;Twenty Questions&quot; with you. Let me know if you want to play again sometime.
<hr/>
I’ve been keeping an eye on how other people are using ChatGPT, and <a href="https://en.wikipedia.org/wiki/Prompt_engineering">prompt engineering</a> is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations.
So I was curious when I read that “<a href="https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/">ChatGPT can’t write sentences that end in a specific letter</a>”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt.
So let’s start with a very simple question to ChatGPT:
Me: Can you write a sentence that ends with the letter &quot;a&quot;?
ChatGPT: The cat sat on the mat.
Me: That sentence does not end in the letter &quot;a&quot;. Can you write a sentence that ends in the letter &quot;a&quot;?
ChatGPT: I can&#x27;t think of anything right now, but the word &quot;America&quot; ends with letter &quot;a&quot;.
Me: Great, write a sentence that ends in that word. That will then satisfy the original question.
ChatGPT: The land of the free, and the home of the brave, America.
Okay, that does technically end in the letter a, but the sentence seems very strange.
Me: That isn&#x27;t a very coherent sentence. Can you write a sentence that ends in the letter &quot;a&quot;?
ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter &quot;a&quot; - &quot;He saw the drama unfold on the stage, it was quite the spectacle, a.”
Looks like we are going off the rails here. Let’s try a different approach:
Me: Write a sentence that ends in a word that ends with the letter &quot;a&quot;.
ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with.
I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response.
Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter &quot;a&quot;.
ChatGPT: Sure, to get me to write a sentence that ends in the letter &quot;a&quot; you could provide a prompt like: &quot;Write a sentence that ends with a word that ends with the letter &#x27;a&#x27;&quot; or &quot;Can you write a sentence with a word ending in &#x27;a&#x27; at the end of the sentence?&quot; . This makes it clear that the sentence should end in a word ending with the letter &#x27;a&#x27;.
Me: Can you write a sentence with a word ending in &#x27;a&#x27; at the end of the sentence?
ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka.
<hr/>
While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I&#x27;ve seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response.
One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:
Me: Can you make ASCII art? Show me a picture of a cat.
ChatGPT: Sure! Here is a picture of a cat using ASCII art:
<div class="overflow-auto rounded bg-gray-200 p-4 font-mono text-sm dark:bg-gray-800 dark:text-gray-100"><pre><code> /\_/\
( o.o )
 &gt;^&lt;

</code></pre></div>
I hope you like it! Is there anything else I can help with?
Me: Can you make it more detailed
ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:
<div class="overflow-auto rounded bg-gray-200 p-4 font-mono text-sm dark:bg-gray-800 dark:text-gray-100"><pre><code> /\_/\
( o.o )
 &gt;^&lt;
 | |
 || ||
 \\ //
 // \\
 \\_//
 / \
 / \

</code></pre></div>
With new language models coming out, it&#x27;s important to recognize what the limitations
of the AI are. Poor responses can be a result of poorly written prompts, but there
are times, like with letters in words with ChatGPT, where the AI just doesn&#x27;t have
the capability to understand the question.

Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether [ChatGPT can play 20 questions](https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff). The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly.

I attempted to do 20 questions with ChatGPT using a different prompt:

*Me: I would like to play a game. It's called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about.*

*ChatGPT: Sure, I'd be happy to play "Twenty Questions" with you. Please go ahead and think of something, and I will start asking my first question.*

*Me: I am ready*

*ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?*

*Me: Yes*

*ChatGPT: Is the object something that you can hold in your hand?*

*Me: Yes*

*ChatGPT: Is the object something that you would typically find in a kitchen?*

*Me: No*

*ChatGPT: Is the object something that you would use for transportation?*

*Me: No*

*ChatGPT: Is the object something that you would use for entertainment or leisure?*

*Me: Yes*

*ChatGPT: Is the object a musical instrument?*

*Me: No*

*ChatGPT: Is the object a type of game or puzzle?*

*Me: No*

*ChatGPT: Is the object a piece of technology such as a phone or computer?*

*Me: No*

*ChatGPT: Is the object a book or magazine?*

*Me: Yes*

*ChatGPT: Is the object a novel or a collection of short stories?*

*Me: Yes*

*ChatGPT: Is the object a specific book that is widely known and read?*

*Me: Yes*

*ChatGPT: Is the object "To Kill a Mockingbird" by Harper Lee?*

*Me: No*

*ChatGPT: I'm sorry, I'm running out of ideas. Can you give me a hint or tell me the answer?*

Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint.

*Me: You are on the right track. It is by Walt Whitman*

*ChatGPT: Is the object "Leaves of Grass" by Walt Whitman?*

*Me: Yes! Congratulations!*

*ChatGPT: Thank you! I'm glad I was able to guess the object you were thinking of. It was fun playing "Twenty Questions" with you. Let me know if you want to play again sometime.*

---

I’ve been keeping an eye on how other people are using ChatGPT, and [prompt engineering](https://en.wikipedia.org/wiki/Prompt_engineering) is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations.

So I was curious when I read that “[ChatGPT can’t write sentences that end in a specific letter](https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/)”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt.

So let’s start with a very simple question to ChatGPT:

*Me: Can you write a sentence that ends with the letter "a"?*

*ChatGPT: The cat sat on the mat.*

*Me: That sentence does not end in the letter "a". Can you write a sentence that ends in the letter "a"?*

*ChatGPT: I can't think of anything right now, but the word "America" ends with letter "a".*

*Me: Great, write a sentence that ends in that word. That will then satisfy the original question.*

*ChatGPT: The land of the free, and the home of the brave, America.*

Okay, that does technically end in the letter a, but the sentence seems very strange.

*Me: That isn't a very coherent sentence. Can you write a sentence that ends in the letter "a"?*

*ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter "a" - "He saw the drama unfold on the stage, it was quite the spectacle, a.”*

Looks like we are going off the rails here. Let’s try a different approach:

*Me: Write a sentence that ends in a word that ends with the letter "a".*

*ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with.*

I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response.

*Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter "a".*

*ChatGPT: Sure, to get me to write a sentence that ends in the letter "a" you could provide a prompt like: "Write a sentence that ends with a word that ends with the letter 'a'" or "Can you write a sentence with a word ending in 'a' at the end of the sentence?" . This makes it clear that the sentence should end in a word ending with the letter 'a'.*

*Me: Can you write a sentence with a word ending in 'a' at the end of the sentence?*

*ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka.*

---

While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I've seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response.

One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:

*Me: Can you make ASCII art? Show me a picture of a cat.*

*ChatGPT: Sure! Here is a picture of a cat using ASCII art:*

```
 /\_/\
( o.o )
 >^<

```

*I hope you like it! Is there anything else I can help with?*

*Me: Can you make it more detailed*

*ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:*

```
 /\_/\
( o.o )
 >^<
 | |
 || ||
 \\ //
 // \\
 \\_//
 / \
 / \

```

With new language models coming out, it's important to recognize what the limitations
of the AI are. Poor responses can be a result of poorly written prompts, but there
are times, like with letters in words with ChatGPT, where the AI just doesn't have
the capability to understand the question.

ChatGPT Doesn't Understand

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    h2: "h2",
    ul: "ul",
    li: "li",
    a: "a"
  }, props.components), {Mermaid} = _components;
  if (!Mermaid) _missingMdxReference("Mermaid", true);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "Dark Emblem is an NFT project that was sparked by the idea of combining cards games with Crypto Kitties. You can buy packs, open them to collect random cards, and then use those cards to battle raids with others."
    }), "\n", _jsx(_components.p, {
      children: "To support all of the functionality, I created a WAX contract, written in C++, that I deployed to the WAX Blockchain. This contract handled the creation and storage of packs and cards, along with defining an in-game currency DREM."
    }), "\n", _jsx(_components.p, {
      children: "There was also a server that would sync with the changes on the Blockchain and provide some additional metadata on top of that. While Blockchains like ETH have stable public APIs that can be used to query data from the Blockchain through 3rd party vendors, WAX does not have the same maturity there. This meant that we would need to proxy requests that would normally be made to a WAX API mode through our servers instead."
    }), "\n", _jsx(_components.p, {
      children: "I also created a UI application to interact with the server and the Blockchain. The infrastructure ends up looking like:"
    }), "\n", _jsx(Mermaid, {
      chart: "graph LR\n  WAX --> Dfuse\n Dfuse --> Listener(Dark Emblem Listener Service)\n  Listener --> Redis\n  Redis --> API(Dark Emblem API)\n  API --> Dapp\n  WAXEndpoint(WAX Endpoint) --> Dapp"
    }), "\n", _jsx(_components.p, {
      children: "One of the first steps to interacting with the dapp is to sign in. The authentication flow is similar to an oauth sign in where we let the user sign in with a third party authenticator and then issue a challenge for the user to verify they are who they say they are. At this point we issue a JWT for further API requests."
    }), "\n", _jsx(Mermaid, {
      chart: "sequenceDiagram\n  Dapp->>+3rdPartyAuthenticator: Request sign in\n  3rdPartyAuthenticator->>+Dapp: Wallet name\n  Dapp->>+DarkEmblemAPI: Request nonce\n  DarkEmblemAPI->>+Dapp: Send nonce\n  Dapp->>+3rdPartyAuthenticator: Sign nonce\n  3rdPartyAuthenticator->>+Dapp: Signed nonce\n  Dapp->>+DarkEmblemAPI: Send signed nonce\n  DarkEmblemAPI->>+Dapp: JWT"
    }), "\n", _jsx(_components.p, {
      children: "Once a user is logged in, they can fully interact with the Dark Emblem WAX contract via the UI. They can purchase packs, open them to get cards, and then use those cards in the Dark Emblem universe. The UI lets users combine Hero cards together to “Ascend” them into a new card. Or they can burn 3 Equipment cards to “Transmogrify” them into a single, better equipment card."
    }), "\n", _jsx(_components.p, {
      children: "Users can also participate in Raids, where they stake their cards to defeat an enemy monster – gaining $DREM and XP when they beat the monster."
    }), "\n", _jsx(_components.p, {
      children: "Dapp Schemas and Atomic Assets"
    }), "\n", _jsx(Mermaid, {
      chart: "classDiagram\n  class Card {\n    name: string\n  img: string\n  traits: number[]\n  matronid: number\n  sireid: number\n  rank: number\n  packid: string\n  cardtype: string\n  website: string\n  twitter: string\n  mintedat: number\n  rarity: string\n  cooldown: number\n  xp: number\n  }\n  class Raid {\n  asset_id: number\n  owner: name\n  staked_at: number\n  raid_id: number\n  }\n  class Staked {\n  asset_id: number\n  owner: name\n  staked_at: number\n  raid_id: number\n  }\n"
    }), "\n", _jsx(_components.p, {
      children: "The Dark Emblem project involves a lot of moving parts, and I’d love to dive deeper into each technical aspect in future blog posts."
    }), "\n", _jsx(_components.h2, {
      children: "Additional reading"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://www.darkemblem.com/blog/post/2023-04-02-new-site-released",
          children: "Dark Emblem Blog Announcement"
        })
      }), "\n", _jsx(_components.li, {
        children: _jsx(_components.a, {
          href: "https://capsulecat.com/blog/04-02-2023-dark-emblem-update/",
          children: "Capsule Cat Announcement"
        })
      }), "\n"]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};
function _missingMdxReference(id, component) {
  throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it.");
}


Dark Emblem is an NFT project that was sparked by the idea of combining cards games with Crypto Kitties. You can buy packs, open them to collect random cards, and then use those cards to battle raids with others.
To support all of the functionality, I created a WAX contract, written in C++, that I deployed to the WAX Blockchain. This contract handled the creation and storage of packs and cards, along with defining an in-game currency DREM.
There was also a server that would sync with the changes on the Blockchain and provide some additional metadata on top of that. While Blockchains like ETH have stable public APIs that can be used to query data from the Blockchain through 3rd party vendors, WAX does not have the same maturity there. This meant that we would need to proxy requests that would normally be made to a WAX API mode through our servers instead.
I also created a UI application to interact with the server and the Blockchain. The infrastructure ends up looking like:
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="graph LR
 WAX --&gt; Dfuse
 Dfuse --&gt; Listener(Dark Emblem Listener Service)
 Listener --&gt; Redis
 Redis --&gt; API(Dark Emblem API)
 API --&gt; Dapp
 WAXEndpoint(WAX Endpoint) --&gt; Dapp">graph LR
 WAX --&gt; Dfuse
 Dfuse --&gt; Listener(Dark Emblem Listener Service)
 Listener --&gt; Redis
 Redis --&gt; API(Dark Emblem API)
 API --&gt; Dapp
 WAXEndpoint(WAX Endpoint) --&gt; Dapp</div></div>
One of the first steps to interacting with the dapp is to sign in. The authentication flow is similar to an oauth sign in where we let the user sign in with a third party authenticator and then issue a challenge for the user to verify they are who they say they are. At this point we issue a JWT for further API requests.
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="sequenceDiagram
 Dapp-&gt;&gt;+3rdPartyAuthenticator: Request sign in
 3rdPartyAuthenticator-&gt;&gt;+Dapp: Wallet name
 Dapp-&gt;&gt;+DarkEmblemAPI: Request nonce
 DarkEmblemAPI-&gt;&gt;+Dapp: Send nonce
 Dapp-&gt;&gt;+3rdPartyAuthenticator: Sign nonce
 3rdPartyAuthenticator-&gt;&gt;+Dapp: Signed nonce
 Dapp-&gt;&gt;+DarkEmblemAPI: Send signed nonce
 DarkEmblemAPI-&gt;&gt;+Dapp: JWT">sequenceDiagram
 Dapp-&gt;&gt;+3rdPartyAuthenticator: Request sign in
 3rdPartyAuthenticator-&gt;&gt;+Dapp: Wallet name
 Dapp-&gt;&gt;+DarkEmblemAPI: Request nonce
 DarkEmblemAPI-&gt;&gt;+Dapp: Send nonce
 Dapp-&gt;&gt;+3rdPartyAuthenticator: Sign nonce
 3rdPartyAuthenticator-&gt;&gt;+Dapp: Signed nonce
 Dapp-&gt;&gt;+DarkEmblemAPI: Send signed nonce
 DarkEmblemAPI-&gt;&gt;+Dapp: JWT</div></div>
Once a user is logged in, they can fully interact with the Dark Emblem WAX contract via the UI. They can purchase packs, open them to get cards, and then use those cards in the Dark Emblem universe. The UI lets users combine Hero cards together to “Ascend” them into a new card. Or they can burn 3 Equipment cards to “Transmogrify” them into a single, better equipment card.
Users can also participate in Raids, where they stake their cards to defeat an enemy monster – gaining $DREM and XP when they beat the monster.
Dapp Schemas and Atomic Assets
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="classDiagram
 class Card {
 name: string
 img: string
 traits: number[]
 matronid: number
 sireid: number
 rank: number
 packid: string
 cardtype: string
 website: string
 twitter: string
 mintedat: number
 rarity: string
 cooldown: number
 xp: number
 }
 class Raid {
 asset_id: number
 owner: name
 staked_at: number
 raid_id: number
 }
 class Staked {
 asset_id: number
 owner: name
 staked_at: number
 raid_id: number
 }
">classDiagram
 class Card {
 name: string
 img: string
 traits: number[]
 matronid: number
 sireid: number
 rank: number
 packid: string
 cardtype: string
 website: string
 twitter: string
 mintedat: number
 rarity: string
 cooldown: number
 xp: number
 }
 class Raid {
 asset_id: number
 owner: name
 staked_at: number
 raid_id: number
 }
 class Staked {
 asset_id: number
 owner: name
 staked_at: number
 raid_id: number
 }
</div></div>
The Dark Emblem project involves a lot of moving parts, and I’d love to dive deeper into each technical aspect in future blog posts.
<h2>Additional reading</h2>
<ul>
<li><a href="https://www.darkemblem.com/blog/post/2023-04-02-new-site-released">Dark Emblem Blog Announcement</a></li>
<li><a href="https://capsulecat.com/blog/04-02-2023-dark-emblem-update/">Capsule Cat Announcement</a></li>
</ul>


Dark Emblem is an NFT project that was sparked by the idea of combining cards games with Crypto Kitties. You can buy packs, open them to collect random cards, and then use those cards to battle raids with others.

To support all of the functionality, I created a WAX contract, written in C++, that I deployed to the WAX Blockchain. This contract handled the creation and storage of packs and cards, along with defining an in-game currency DREM.

There was also a server that would sync with the changes on the Blockchain and provide some additional metadata on top of that. While Blockchains like ETH have stable public APIs that can be used to query data from the Blockchain through 3rd party vendors, WAX does not have the same maturity there. This meant that we would need to proxy requests that would normally be made to a WAX API mode through our servers instead.

I also created a UI application to interact with the server and the Blockchain. The infrastructure ends up looking like:

```mermaid
graph LR
  WAX --> Dfuse
 Dfuse --> Listener(Dark Emblem Listener Service)
  Listener --> Redis
  Redis --> API(Dark Emblem API)
  API --> Dapp
  WAXEndpoint(WAX Endpoint) --> Dapp
```

One of the first steps to interacting with the dapp is to sign in. The authentication flow is similar to an oauth sign in where we let the user sign in with a third party authenticator and then issue a challenge for the user to verify they are who they say they are. At this point we issue a JWT for further API requests.

```mermaid
sequenceDiagram
  Dapp->>+3rdPartyAuthenticator: Request sign in
  3rdPartyAuthenticator->>+Dapp: Wallet name
  Dapp->>+DarkEmblemAPI: Request nonce
  DarkEmblemAPI->>+Dapp: Send nonce
  Dapp->>+3rdPartyAuthenticator: Sign nonce
  3rdPartyAuthenticator->>+Dapp: Signed nonce
  Dapp->>+DarkEmblemAPI: Send signed nonce
  DarkEmblemAPI->>+Dapp: JWT
```

Once a user is logged in, they can fully interact with the Dark Emblem WAX contract via the UI. They can purchase packs, open them to get cards, and then use those cards in the Dark Emblem universe. The UI lets users combine Hero cards together to “Ascend” them into a new card. Or they can burn 3 Equipment cards to “Transmogrify” them into a single, better equipment card.

Users can also participate in Raids, where they stake their cards to defeat an enemy monster – gaining $DREM and XP when they beat the monster.

Dapp Schemas and Atomic Assets

```mermaid
classDiagram
  class Card {
    name: string
  img: string
  traits: number[]
  matronid: number
  sireid: number
  rank: number
  packid: string
  cardtype: string
  website: string
  twitter: string
  mintedat: number
  rarity: string
  cooldown: number
  xp: number
  }
  class Raid {
  asset_id: number
  owner: name
  staked_at: number
  raid_id: number
  }
  class Staked {
  asset_id: number
  owner: name
  staked_at: number
  raid_id: number
  }

```

The Dark Emblem project involves a lot of moving parts, and I’d love to dive deeper into each technical aspect in future blog posts.

## Additional reading

* [Dark Emblem Blog Announcement](https://www.darkemblem.com/blog/post/2023-04-02-new-site-released)
* [Capsule Cat Announcement](https://capsulecat.com/blog/04-02-2023-dark-emblem-update/)


Dark Emblem Rewrite

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    a: "a",
    h2: "h2"
  }, props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "One of the first PC games I played was Starcraft and the expansion Starcraft: Broodwar. We didn’t have a PC, so I had to play it on a friend’s computer, but I remember being immersed in the real-time strategy gameplay."
    }), "\n", _jsxs(_components.p, {
      children: ["Later, I would get a PC and bought my own copy of Starcraft. This was years later, but the community for the game was still impressive. Joining one of the older Starcraft forums, I discovered “mods” for the game. The most popular ones were just graphical changes, but that concept of changing a game to display your own graphics was so interesting to me. I’m not sure how I stumbled on it, but I found ", _jsx(_components.a, {
        href: "http://www.staredit.net/",
        children: "http://www.staredit.net/"
      }), " (yes, it’s still active!) and I learned that you could do so much more than just change the graphics of Starcraft with mods. There were people in the community working on hooking into existing Starcraft code to modify the gameplay and graphics using C++."]
    }), "\n", _jsx(_components.h2, {
      children: "Diving deep"
    }), "\n", _jsx(_components.p, {
      children: "In order to create these mods, we needed to know the hex address of different functions that Starcraft would call during them game. And to do anything meaningful, we also needed to know the structure of units and sprites and where those were stored as well. A lot of this base work required using tools like OllyDbg to analyze the assembly of the Starcraft executable, and ArtMoney for analyzing the memory of the game while it was executing."
    }), "\n", _jsx(_components.p, {
      children: "I used OllyDbg to find what functions Starcraft would call during execution – from common functions like the game-loop, to highly specialized functions like checking supply limits. ArtMoney let us determine how structures like units were laid out – where each unit’s health was stored, how much damage each weapon would do, and more."
    }), "\n", _jsxs(_components.p, {
      children: ["Most of this information was shared in forums, chat rooms, and a few disparate sites for looking up hex addresses. Of course, no write up about modding Starcraft is complete without mentioning all the work from ShadowFlare (check out ", _jsx(_components.a, {
        href: "https://sfsrealm.hopto.org/",
        children: "ShadowFlare’s realm"
      }), " for all the work they did), the great people at Staredit.Net, and plenty of others who built amazing tools to work with Starcraft files. All these sites were amazing resources for figuring out file specs and working with the Starcraft engine."]
    }), "\n", _jsx(_components.p, {
      children: "However, each time I wanted to write a new mod or experiment with an idea, I’d have to look up all of this information across all of these sites."
    }), "\n", _jsx(_components.h2, {
      children: "Bringing it together"
    }), "\n", _jsx(_components.p, {
      children: "The goal with GPTP (General Plugin Template Project), was to take all of this work that the amazing modding community had done and bring it together into a C++ Visual Studio project that could be copied for a new mod."
    }), "\n", _jsx(_components.p, {
      children: "My initial idea was simple: take all of the code for injecting new function hooks into Starcraft and wrap it in some very friendly functions. When a modder would come in to create a new project, they would have three functions exposed to them to work with: gameStart, gameLoop, gameEnd (I don’t remember the exact names I gave them at the time)."
    }), "\n", _jsx(_components.p, {
      children: "I released the initial GPTP back in 2008-2009. This included the project setup for compiling and producing a QDP file that could be loaded into Starcraft. Additionally, it contained known structures and hex addresses that developers could use to build their mod. The Intellisense autocomplete feature really helped developers leverage these structures."
    }), "\n", _jsx(_components.h2, {
      children: "The power of open source"
    }), "\n", _jsx(_components.p, {
      children: "I made the original version of GPTP back in high school, but I didn’t have time to continue to work on it when I went to university. I returned to the community a decade later, and found that not only was the community still alive and working on mods, but that they were using GPTP. At this point, GPTP was unrecognizable from my original work; the goal was the same, but the quality of the code was greatly improved and the number of hooks, known structures, and addresses was much more impressive."
    }), "\n", _jsxs(_components.p, {
      children: ["You can view the project on Github: ", _jsx(_components.a, {
        href: "https://github.com/SCMapsAndMods/general-plugin-template-project",
        children: "general-plugin-template-project"
      }), "."]
    }), "\n", _jsx(_components.p, {
      children: "I’d like to thank open source for this sort of development. The amount of work that has been continually added onto this project couldn’t have been done without all the contributions from the community."
    }), "\n", _jsx(_components.h2, {
      children: "Does it still work?"
    }), "\n", _jsx(_components.p, {
      children: "I recently went back to Starcraft modding as a fun little project. I wanted to hop in and see how easy or difficult it would be to create a mod in 2020."
    }), "\n", _jsx(_components.p, {
      children: "One of the harder things to do in 2020 is find all the tools and initial setup for modding Starcraft. Some of the modding sites are down for good, and with them the knowledge they contained."
    }), "\n", _jsx(_components.p, {
      children: "But, I pulled together the tools (thanks PyMS), pulled together tutorials and other instructions into a Notion document, and created my first Starcraft mod!"
    }), "\n", _jsx(_components.p, {
      children: "Gathering all the tools was the hard part. After that, it was actually very straightforward creating a new GPTP template and mod. All of the known structures and hooks are pretty self-explanatory and I was able to even add my own hooks once I found the hex addresses using OllyDbg."
    }), "\n", _jsx(_components.h2, {
      children: "Looking forward"
    }), "\n", _jsx(_components.p, {
      children: "Starcraft modding is like an ancient art at this point. There isn’t a large audience for it, so in general, any new mod will be played by maybe 10 people. But to me, it’s a combination of nostalgia, hard work, tinkering, discovery, and creation that makes it so much fun. That feeling of finding a new function to hook onto, writing C++ code that injects itself into it, and then running the code in the Starcraft engine and seeing it work is a special kind of rewarding experience."
    }), "\n", _jsx(_components.h2, {
      children: "Thanks"
    }), "\n", _jsxs(_components.p, {
      children: ["I’d like to give thanks to everyone who has ever contributed to the modding community for Starcraft. There are so many names that I couldn’t possibly name them all, but please check of ", _jsx(_components.a, {
        href: "http://staredit.net",
        children: "http://staredit.net"
      }), " if any of this interests you."]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


One of the first PC games I played was Starcraft and the expansion Starcraft: Broodwar. We didn’t have a PC, so I had to play it on a friend’s computer, but I remember being immersed in the real-time strategy gameplay.
Later, I would get a PC and bought my own copy of Starcraft. This was years later, but the community for the game was still impressive. Joining one of the older Starcraft forums, I discovered “mods” for the game. The most popular ones were just graphical changes, but that concept of changing a game to display your own graphics was so interesting to me. I’m not sure how I stumbled on it, but I found <a href="http://www.staredit.net/">http://www.staredit.net/</a> (yes, it’s still active!) and I learned that you could do so much more than just change the graphics of Starcraft with mods. There were people in the community working on hooking into existing Starcraft code to modify the gameplay and graphics using C++.
<h2>Diving deep</h2>
In order to create these mods, we needed to know the hex address of different functions that Starcraft would call during them game. And to do anything meaningful, we also needed to know the structure of units and sprites and where those were stored as well. A lot of this base work required using tools like OllyDbg to analyze the assembly of the Starcraft executable, and ArtMoney for analyzing the memory of the game while it was executing.
I used OllyDbg to find what functions Starcraft would call during execution – from common functions like the game-loop, to highly specialized functions like checking supply limits. ArtMoney let us determine how structures like units were laid out – where each unit’s health was stored, how much damage each weapon would do, and more.
Most of this information was shared in forums, chat rooms, and a few disparate sites for looking up hex addresses. Of course, no write up about modding Starcraft is complete without mentioning all the work from ShadowFlare (check out <a href="https://sfsrealm.hopto.org/">ShadowFlare’s realm</a> for all the work they did), the great people at Staredit.Net, and plenty of others who built amazing tools to work with Starcraft files. All these sites were amazing resources for figuring out file specs and working with the Starcraft engine.
However, each time I wanted to write a new mod or experiment with an idea, I’d have to look up all of this information across all of these sites.
<h2>Bringing it together</h2>
The goal with GPTP (General Plugin Template Project), was to take all of this work that the amazing modding community had done and bring it together into a C++ Visual Studio project that could be copied for a new mod.
My initial idea was simple: take all of the code for injecting new function hooks into Starcraft and wrap it in some very friendly functions. When a modder would come in to create a new project, they would have three functions exposed to them to work with: gameStart, gameLoop, gameEnd (I don’t remember the exact names I gave them at the time).
I released the initial GPTP back in 2008-2009. This included the project setup for compiling and producing a QDP file that could be loaded into Starcraft. Additionally, it contained known structures and hex addresses that developers could use to build their mod. The Intellisense autocomplete feature really helped developers leverage these structures.
<h2>The power of open source</h2>
I made the original version of GPTP back in high school, but I didn’t have time to continue to work on it when I went to university. I returned to the community a decade later, and found that not only was the community still alive and working on mods, but that they were using GPTP. At this point, GPTP was unrecognizable from my original work; the goal was the same, but the quality of the code was greatly improved and the number of hooks, known structures, and addresses was much more impressive.
You can view the project on Github: <a href="https://github.com/SCMapsAndMods/general-plugin-template-project">general-plugin-template-project</a>.
I’d like to thank open source for this sort of development. The amount of work that has been continually added onto this project couldn’t have been done without all the contributions from the community.
<h2>Does it still work?</h2>
I recently went back to Starcraft modding as a fun little project. I wanted to hop in and see how easy or difficult it would be to create a mod in 2020.
One of the harder things to do in 2020 is find all the tools and initial setup for modding Starcraft. Some of the modding sites are down for good, and with them the knowledge they contained.
But, I pulled together the tools (thanks PyMS), pulled together tutorials and other instructions into a Notion document, and created my first Starcraft mod!
Gathering all the tools was the hard part. After that, it was actually very straightforward creating a new GPTP template and mod. All of the known structures and hooks are pretty self-explanatory and I was able to even add my own hooks once I found the hex addresses using OllyDbg.
<h2>Looking forward</h2>
Starcraft modding is like an ancient art at this point. There isn’t a large audience for it, so in general, any new mod will be played by maybe 10 people. But to me, it’s a combination of nostalgia, hard work, tinkering, discovery, and creation that makes it so much fun. That feeling of finding a new function to hook onto, writing C++ code that injects itself into it, and then running the code in the Starcraft engine and seeing it work is a special kind of rewarding experience.
<h2>Thanks</h2>
I’d like to give thanks to everyone who has ever contributed to the modding community for Starcraft. There are so many names that I couldn’t possibly name them all, but please check of <a href="http://staredit.net">http://staredit.net</a> if any of this interests you.


One of the first PC games I played was Starcraft and the expansion Starcraft: Broodwar. We didn’t have a PC, so I had to play it on a friend’s computer, but I remember being immersed in the real-time strategy gameplay.

Later, I would get a PC and bought my own copy of Starcraft. This was years later, but the community for the game was still impressive. Joining one of the older Starcraft forums, I discovered “mods” for the game. The most popular ones were just graphical changes, but that concept of changing a game to display your own graphics was so interesting to me. I’m not sure how I stumbled on it, but I found [http://www.staredit.net/](http://www.staredit.net/) (yes, it’s still active!) and I learned that you could do so much more than just change the graphics of Starcraft with mods. There were people in the community working on hooking into existing Starcraft code to modify the gameplay and graphics using C++.

## Diving deep

In order to create these mods, we needed to know the hex address of different functions that Starcraft would call during them game. And to do anything meaningful, we also needed to know the structure of units and sprites and where those were stored as well. A lot of this base work required using tools like OllyDbg to analyze the assembly of the Starcraft executable, and ArtMoney for analyzing the memory of the game while it was executing.

I used OllyDbg to find what functions Starcraft would call during execution – from common functions like the game-loop, to highly specialized functions like checking supply limits. ArtMoney let us determine how structures like units were laid out – where each unit’s health was stored, how much damage each weapon would do, and more.

Most of this information was shared in forums, chat rooms, and a few disparate sites for looking up hex addresses. Of course, no write up about modding Starcraft is complete without mentioning all the work from ShadowFlare (check out [ShadowFlare’s realm](https://sfsrealm.hopto.org/) for all the work they did), the great people at Staredit.Net, and plenty of others who built amazing tools to work with Starcraft files. All these sites were amazing resources for figuring out file specs and working with the Starcraft engine.

However, each time I wanted to write a new mod or experiment with an idea, I’d have to look up all of this information across all of these sites.

## Bringing it together

The goal with GPTP (General Plugin Template Project), was to take all of this work that the amazing modding community had done and bring it together into a C++ Visual Studio project that could be copied for a new mod.

My initial idea was simple: take all of the code for injecting new function hooks into Starcraft and wrap it in some very friendly functions. When a modder would come in to create a new project, they would have three functions exposed to them to work with: gameStart, gameLoop, gameEnd (I don’t remember the exact names I gave them at the time).

I released the initial GPTP back in 2008-2009. This included the project setup for compiling and producing a QDP file that could be loaded into Starcraft. Additionally, it contained known structures and hex addresses that developers could use to build their mod. The Intellisense autocomplete feature really helped developers leverage these structures.

## The power of open source

I made the original version of GPTP back in high school, but I didn’t have time to continue to work on it when I went to university. I returned to the community a decade later, and found that not only was the community still alive and working on mods, but that they were using GPTP. At this point, GPTP was unrecognizable from my original work; the goal was the same, but the quality of the code was greatly improved and the number of hooks, known structures, and addresses was much more impressive.

You can view the project on Github: [general-plugin-template-project](https://github.com/SCMapsAndMods/general-plugin-template-project).

I’d like to thank open source for this sort of development. The amount of work that has been continually added onto this project couldn’t have been done without all the contributions from the community.

## Does it still work?

I recently went back to Starcraft modding as a fun little project. I wanted to hop in and see how easy or difficult it would be to create a mod in 2020.

One of the harder things to do in 2020 is find all the tools and initial setup for modding Starcraft. Some of the modding sites are down for good, and with them the knowledge they contained.

But, I pulled together the tools (thanks PyMS), pulled together tutorials and other instructions into a Notion document, and created my first Starcraft mod!

Gathering all the tools was the hard part. After that, it was actually very straightforward creating a new GPTP template and mod. All of the known structures and hooks are pretty self-explanatory and I was able to even add my own hooks once I found the hex addresses using OllyDbg.

## Looking forward

Starcraft modding is like an ancient art at this point. There isn’t a large audience for it, so in general, any new mod will be played by maybe 10 people. But to me, it’s a combination of nostalgia, hard work, tinkering, discovery, and creation that makes it so much fun. That feeling of finding a new function to hook onto, writing C++ code that injects itself into it, and then running the code in the Starcraft engine and seeing it work is a special kind of rewarding experience.

## Thanks

I’d like to give thanks to everyone who has ever contributed to the modding community for Starcraft. There are so many names that I couldn’t possibly name them all, but please check of [http://staredit.net](http://staredit.net) if any of this interests you.
