The History of Platformers!
The video game I have designed and programmed is a 2D scrolling platformer; a platformer is a subgenre of an action video game. It involves the player moving and jumping the avatar across suspended platforms and obstacles while journeying through an environment. Platformer video games began in the early 1980’s, one of the earliest example and most popular was Donkey Kong, an arcade game created by Nintendo and made available in 1981. Donkey Kong was a static platformer, shortly after its release Jump Bug, by Alpha Denshi, became available in arcades. Jump Bug pushed the genre a little further with the addition of a scrolling background and improved the genres dynamics; however, while home consoles existed at the time, precise scrolling platformers were limited to arcades.
During the first half of the 1980’s, the majority of available home consoles were not powerful enough to support smooth scrolling backgrounds and precise jumping. It was not until 1985, when Super Mario Bros. became available with the Nintendo Entertainment System (NES) console, that the scrolling platformer video game genre exploded and Super Mario Bros. became the model for many platformer video games to come. While home consoles evolved from 2D to 3D graphics, scrolling platformers evolved from home consoles into portable devices by the late 1980s. Scrolling platformer’s popularity continued with portable devices and the hand held devices became the epicenter for 8bit, 2D scrolling platformers and their evolution, particularly in the hands of a new generation of 90’s gamers. It was not until the arrival of 16 bit graphics to home consoles that scrolling platformers saw another profound evolutionary change. In 1990 Super NES was release along with Super Mario World and the scrolling platformer was the most popular genre in home consoles.
Many 16 bit platformers evolved throughout the 1990’s and continued in popularity through their transition into 32 bit graphics and, despite their quirky transition, from 2D graphics to 3D graphics. Today, while not as groundbreaking and popular a genre, scrolling 2D platformers and 3D platformers are still enjoyed by many generations of gamers. Because of the 2D platformer’s influential history in the evolution of video games, I decided to design and program my own in an effort to learn from the game mechanics implemented. My implementation of a 2D scrolling platformer is complete and is a fine illustration of a rich set of programmed interactions, graphics, and audio for an intermediate level, student video game completely created by me.
The Story of Slimeventure
Welcome to Slimeventure! A world of peaceful slimes to explore and make new friends! At least, that's what it used to be. Invasive species have taken over several regions of the peaceful world, and the slimes are struggling to survive! It is up to YOU to take on the journey of driving off the invasive species back to their habitat and restore the world to how it was before! But you don't know how you'll be able to achieve that, so you initially reject the idea. But as a terrifying event occurs in your life, your perspective suddenly switches, and you begin on your grand adventure! Throughout the journey, you will meet friend and foe alike, and you'll learn new skills that you'll need to explore the continuing worlds ahead. Are you up for the challenge? Obstacles, puzzles, boss fights, Slimeventure has it all! But beware, sometimes, things may not be as easy as they seem. Help your species from extinction, be the hero that they need!
Visuals
During the process of designing and building my game, I learned 2D graphic design and illustration using Adobe Illustrator and earned the Adobe Certified Associate, Industry Certification Exam. The Graphic Design and Illustration Using Adobe Illustrator exam validates entry-level skills in graphic design and illustration corresponding to Adobe’s Illustrator software. In addition, I used Illustrator as a vehicle to learn vector art, while reinforcing my visual art skills using the elements of art and principles of design. Our main goal of the game was to create a fun family game for every age to play. We created the art in a cartoony and silly style to fit these criteria. We created many different environmental assets to give the level more depth. Each level has a background, middle ground, and foreground. Many different objects in the game are also animated to give life to the creatures and other assets that can be found throughout our game. We also created a uniform UI for the player to travel around the different levels and scenes in our game.
Programming
To make my video game I learned Object Oriented Programming (OOP) in C# and scripted my code using the Integrated Development Environment (IDE), MonoDevelop. I also learned to operate Unity Professional to compile my video game; Unity Professional is a global leader in game and simulation development. The following are some of the theories I learned and applied during the process of designing, writing, testing, debugging, and maintaining my code: I learned how to ask good computer programming questions to solve problems using code hosting services, this included how to pseudo code and testing. Testing and asking good questions makes a better programmer. While programming, I learned to script classes, variables, methods and functions, strings, and how to use important syntax; symbols such as parenthesis for parameters, curly braces for blocks of code, quotations for strings, and semi-colons to end my lines of code. I learned to create and customize game objects and scenes, to use conditional statements (if/then/else) and script them using the Unity Application Programming Interface (API). My game shows proof that I have learned to expand my conditional statements for precision. Having good scripting style is critical to becoming a computer programmer and software engineer; therefore, we learned to refactor our code to simplify its structure and improve readability.
Finally, I learned to compile, listen to errors and warnings, and debug strengthening my iterative design skills. To create our player, we used Unity’s physics system. We used a component known as the RigidBody and controlled the velocity and gravity using this component. We controlled collisions in our game using box and circle colliders. These are useful to make objects collide with each other instead of passing through. In each level, the player gains a new physics ability. In level 1, the player has the basic controls such as the movement and the jumping. Once the player reaches level 2, he gains the ability to double jump. Once the player reaches level 3, he can slide under thin surfaces. To create these physics, I used my own functions by taking advantage of Unity’s variable type called BOOLS.
Bools allow a programmer to check whether something is true or false and create a statement. If the player has jumped once, he can jump one more time. If the player has not jumped once, then he can jump twice, and so forth. Bools are very useful to create new physics and especially in IF statements. I also learned about other types of variables such as the floats and the integers. The difference between floats and integers is very simple. It relates to the mathematical number systems. An integer is a whole number, either positive or negative, but it MUST be a whole number. A float on the other hand, can be considered a rational number, but ONLY a decimal. Long story short, floats can contain decimal points or no decimal points, while integers can only be whole numbers.
Another useful technique I learned while making my game is the transform.position utility. This helpful piece of code allows me to change the position of objects to my desired position in the game. An example of this is the camera object. I created a script to make the camera follow the player around the level. I placed this code in the Update function to ensure that the position will change every frame to allow for smooth movement.
The last thing I would like to mention are the functions I created for UI accessibility. I created custom functions to enable UI buttons to do certain actions such as restarting the game, resuming the game, or going back to the main menu. Since I want these functions on button objects, I can use unity’s button onClick option to call my custom functions from there.
My game went through several design processes, testing, and debugging, this process is also known as iterative design. The final iteration of a design is called ready to market (RTM). I was challenged with the decisions of choosing the best gameplay options and visual aesthetics based on my target audience. It was a long and laborious project that went through a lot of trial and error. My partner and I heavily depended on each other to work as a team and to create this game and assist each other to fix any mistakes or errors. The most challenging part of programming our game were the boss fights.
The boss fights had many different aspects we needed to have at once, such as a timer, boss health, boss attack moves, spawners, and many more. It became very difficult to keep track of everything. It also became frustrating at times because the code would not work how we wanted, so we had to spend a lot of time re-writing the same code until it finally worked how we wanted it. The point of boss fights in our game was to challenge the player. Challenging the player is a high priority in creating a video game, otherwise, the player will become bored and lose interest. By adding difficulty such as complex pathing, vicious enemies, and key objectives, the player is more likely to become immersed and therefore connected to the game.
The player may feel frustrated, and they may get a little stress, but the user will still feel determined to beat the game. In addition to producing an immersive game, I applied a Risk to Reward ratio. For every risk the player took, there was a reward. The game took 4 months to build and program. It was a long progress but throughout it I learned many different coding abilities and acquired needed skills to create a product.
Comments