Today's world depends more and more on computing devices.
Learning to program will give you
opportunities that you may not otherwise have. Programming is essentially
giving a computer (or computing device) a set of instructions. These
instructions are written in a language that the computer
speaks and understands. However, the language that the computer speaks
is in 0s and 1s which are difficult for humans to understand.
To simplify this, programming languages that are easier for humans to read
and write have been developed. Examples of such languages include C, C++,
Java, Python, etc.
While programming languages can be quite powerful, they can be
difficult to learn. GameChangineer
converts natural language , such as English, to code, so that you can more easily see
the logic and ideas behind programming and computational
concepts in the process.
Every language has its own grammatical rules and syntax (vocabulary that it
uses). Although
each sentence/statement in a program is simple in itself, collectively they can tell a great
story. For example, consider a video game, the goal might be to eliminate all
the enemies or rescue a target character. The process through which this
is achieved can be told as a game plan.
When using natural language to describe such a game program, it is important
to write the game plan as specifically as possible. We call such
game plans unambiguous. To help you achieve this more easily, we advise
that your game plan contains two parts: Setting
and Plot. The Setting describes the What
and the Plot describes the How.
Setting
Plot
Describes the characters and how many of them
Describes how the player's character is controlled
Describes which character the player controls
Describes how non-player characters move
Describes the characters' initial positions
Describes how two characters interact
Even after dividing the game plan into Setting and Plot, there may still be
places in your test that are ambiguous or unclear to the computer.
For example, "The rabbit flees." is clear to a human because we infer
that the rabbit is running away from some predator, such as a fox. But a
computer does not know that, so you must describe from whom the rabbit is
fleeing. In this example, the
sentence "The rabbit flees from the fox." is unambiguous, as it clearly describes whom the rabbit is fleeing.
More tips on writing a clear game plan:
Don't use ambiguous wording
Words such as "get" should be
avoided as an action verb, since it can have many different meanings. For
example, instead of "When the fox gets the rabbit, ...", use
"When the fox catches (or touches) the rabbit, ..." to make your meaning clear to
the computer. Whenever the meaning is unclear, an error message will be given
that describes the error as well as provide examples that can correct the
error.
Keep sentences simple.
Whenever possible, keep one sentence to just one idea to increase precision and decrease ambiguity. Consider the sentence
"The rabbits wander around eating carrots."
This sentence is unclear whether the rabbits have to touch carrots in order to eat them. Thus, a better way to describe such a scenario is as follows:
The rabbits wander around.
When a rabbit sees a carrot, it moves toward the carrot.
When a rabbit touches a carrot, it eats the carrot.
In addition, avoid run-on sentences or sentences that attempt to do too many things at once.
When you practice writing in such a manner, it helps you to learn to give instructions clearly, precisely, and unambigously!
Focus on just a single frame (an instant of time)
The actions in each frame will follow the same set of instructions, even though the positions of the characters might have changed
slightly. For more information, read Programming Concepts below.
In terms of computational thinking, the four core areas are emphasized in
GameChangineer:
Abstraction: Focus on the relevant and discard irrelevant details in the design process. For example, "the fox chases the rabbit" ignores
the low-level details of determining the trajectory and step-wise movements. The user can also describe at the lower-level of details with the position,
direction, and other variables of the character if the user chooses.
Decomposition: Break the problem down to smaller pieces.
GameChangineer emphasizes breaking the problem down to actions and interactions between
characters. Each interaction is a smaller problem to the large problem of the entire game.
Pattern Recognition: Many sub-problems may share similarities, and some may be similar to other situations in other games, thereby reducing
the effort to compose entirely different ways to realize the result for each sub-problem. For example, how two characters respond to being touched
by another character may be similar.
Algorithm Design: Unambiguously compose the sequence of steps to realize each component, with English.
GameChangineer also guides the user with any mistakes made in the process.
Finally, the focus of GameChangineer is on writing clear instructions for a video game. Thus, much of the low-level details
can be skipped. For example, the math behind how to make an object flee another object is automatically synthesized for you behind the scenes.
This allows you to focus on the big picture without bothering to compute the trajectories, etc.
Because the focus is on the high-level instructions, low-level mathematical manipulations should not
be in your sentences; writing sentences that attempt to describe low-level mathematical processes is not the intent of this platform.
The rest of the tutorial will go into the details of writing video games
using Game Changineer: what things to avoid and the best practices to follow.
We invite you to explore, innovate, and create fun games!
Programming Concepts (optional material):
Video games are a great way to learn programming concepts!
They can be viewed as a series of actions, divided into frames,
as in a movie or cartoon. The computer re-draws the characters over and over
again to give the illusion that the characters are moving.
Let's say there are 50 frames in a second. The characters only shift slightly
from one frame to the next, but as we move quickly through all the frames,
the characters look like they are moving. Whether a character is chasing,
fleeing, or falling, it follows the same set of action-rules in every frame.
Likewise, your program/game-plan only needs to describe the actions for
each character for a single frame.