Finding a Direction

I hope the Holidays are going well for everyone!

As I mentioned in my previous post, Eric and I are working on our first game. We, like many other beginners, set out with a vague and nebulous concept of the feeling of the game we wanted to make.

So, I went off and worked on creating artwork with some very general design specifications:

  • 2D side perspective
  • 32×32 pixel character sprites
  • 16×16 pixel tiles (orthogonal)
  • Variable length traps (divisible by 16px)
  • 16 color EGA palette (CGA backwards compatibility)
  • Medieval/Fantasy Theme

Eric went away and started working on the programming:

  • Basic keyboard movement (left, right, jump)
  • Basic enemy movement (chase the player when in range)
  • A simple scenario where a specific enemy type (Torch wielding peasant) triggered an flammable barrel that exploded a bridge tile when he got near it
  • A water obstacle that enemies and the player fell through

The astute reader will pick up on the obvious item we missed: designing the game. What wasn’t immediately apparent to us was that we weren’t really building a game because we hadn’t defined what the game was – not even the basic object (i.e. how you win or lose) let alone the rules and mechanics…We were diving into polish (animations, effects etc.) before we even agreed on the scope of a working prototype!

###

Why this happened…

It’s a common mistake for beginners like us to go into too much elaboration too quickly because it feels good to see a result that resembles a finished (read: polished) product. What we were doing wasn’t play testing because there wasn’t a game to play – instead, we were simply validating pieces of code.

The fact is, a game doesn’t need fancy graphics, particle effects, sound effects and background music to be a game (e.g. Pong).

What we did next…

At this point, I halted work and called for a meeting with Eric to hammer out the game mechanics, then create a working prototype.

Eric comes from a creative writing background and isn’t troubled by ambiguity; he never questioned why or how the exploding barrel would get to the bridge, and what tactical or strategic purpose destroy a bridge would serve in the context of the game. Instead, the novelty of this scenario was self-evident to him and required no explanation.

When I asked him to describe the game to me, and what I got, while interesting from a story/scenario perspective, was conspicuously lacking a clear definition of what the game was.

So I took stab at it instead:

Beaster’s Dungeon (my working title for the game) is a 2D platforming game where the player must stop oncoming hordes of peasants and heroes from reaching your treasure by collecting resources and plans needed to create and place deadly traps and obstructions in their path.

That’s a pitch – it tells you everything you need to know about how the game fundamentally works, and Eric agreed. From that pitch, we can distill this into a basic objective:

The player “wins” by destroying all enemies before they reach the treasure, and advances to the next level. The player “loses” by either dying (taking too much enemy or environmental damage) or one enemy reaches the treasure.

So, from that would derive several essential components:

  • Obj_Beaster: We needed an object to control the player character on screen. The object must be able to navigate in a 2D environment (move left, right, jump, collide with other objects).
  • Obj_[EnemyName]: We needed at least one test enemy that followed a set path to the treasure, stopping only to attack obstructions that got in it’s way. For pacing reasons, enemies would need to give the player a 90 second head-start to collect resources and place obstructions/traps.
  • Obj_Wall_Destructible: This was an afterthought, but seemed like a good way to allow the player to control the pace of the enemy horde(s) to give traps more time to kill them. The wall would take x# of hits before crumbling and allowing the enemy to continue on it’s path.
  • Obj_[TrapName]: We needed at least one trap that damaged an enemy that collided with it. The player would be able to place traps when he had collected both the trap’s “plan” (recipe) and a sufficient number of resources to build said trap.
  • Obj_[ResourcesName]: We need at least one resource object that, when collected, adds +1 to a resource counter. When a trap that utilizes that resource is placed, it adds -1 to the counter.
  • Obj_[PlanName]: In order to create a specific type of trap, the player must first possess the “plan” for that trap.  This object would update the player’s inventory to establish whether or not the player is able to place said trap.
  • Rm_TestLevel1: GameMaker studio utilizes “Rooms” to create environments where objects, backgrounds and tiles exist. You can think of these as the “level” where all of action is taking place. The level would need to have a clear path from point A (the origin of the enemies) to point B (the treasure) with enough room for the player to set up his gauntlet. It would need at least 1 trap plan, and be populated with sufficient resources to construct enough traps to kill all incoming enemies.

Once these components were present and behaving as described, we would have a prototype to test the basic functionality of the game.

Notes, Influences, Theories and Rationale

Looking at the game above, what we have described is essentially a “Metroidvania”, Lemmings in Reverse tower defense game. Sound extraneous? Perhaps, but that’s what the Prototype is intended to test. Let’s break that down into phases and game play:

Metroidvania refers to 2D platform exploration. This is where resources and plans come into play; they are placed in such a way as to encourage the player to get off the beaten path and explore to sprawling dungeon. Since the game happens in real-time (not turn-based), the player has to manage the tasks of collecting resources and placing traps while the enemy is slowly advancing toward the treasure.

Note: The game has gravity (i.e. not a top down 2D game, such as Legend of Zelda) so the player falls when moving off of a platform.

To keep the player from getting into an unwinnable/unloseable game, the enemies would have to follow a set path while allowing the player freedom of movement the enemy doesn’t have. To that effect, the player and move left, right, jump up onto platforms to get to areas above the enemy, and drop down from specific platforms to those below the enemy (think Contra).

Lemmings in Reverse is the notion that it was more fun to deliberately kill the Lemmings than steer them to safety, and is key to bridging the gap between a classic 2D platformer and a pure tower defense game.

If the enemies were left to freely roam the dungeon looking for the player or the treasure, it becomes possible for them to wander into a place they can’t get out of, rendering the level unwinnable (and unloseable).

Tower Defense is the most ubiquitous description for the idea of using “traps” or turrets to destroy oncoming enemies. We felt that this genre had been done to death, and wanted to introduce the exploration component as a way to add challenge and depth to an otherwise dull experience.

###

Predictions? Too early to tell, but once we have a working prototype, we can determine how pacing will work. From early “play tests” we’ve done, I can already tell that we will have to have some kind of mini-map or other visual indicators to let the player know that the enemy is attacking and where. It’s too easy to get lost in the labyrinth of the resource floors (i.e. platforms outside of the enemy path) and not know where the enemy is and if you are in danger of losing the level.

There’s got to be balance between the exploration and trap setup portions so that the player has to do both and will be rewarded for good time/space management.

Hello World…Again: A Fresh Start

V-Toad Lives!

After a long hiatus, we’re finally back with a long post, TL;DR be damned, dammit!

I say ‘we’ rather than ‘me’ because I’m now working with an old and dear friend of mine, Eric. I’ve since moved my old posts from veritastoad.wordpress.com to my own web server, and custom URL.

Eric and I have been friends for nearly two decades, and had collaborated on several projects dating back to my first attempts at video game development some 14 years ago. Dissatisfied, over-educated and unemployed, both of us were looking for a way out of grind. Never has there been a better time for indie game developers to jump in and make great games – we are hoping to follow in the footsteps of the likes of Derek YuScott Cawthon, and Locomalito.

###

Division of Labor

As I’ve lamented previously, I am simply not a “triple threat”, which is to say that I while I am a mediocre artist and a decent composer, I am not a programmer. That’s where Eric comes in – with a degree in Electronic Engineering, Eric has had a lot of exposure to programming (or at least more than I have), and volunteered to try.

We still needed a game engine, and since GameSalad dropped it’s free-to-use model, we sought out other alternatives, eventually settling on GameMaker Studio.

###

 

False Starts, New and Colorful Beginnings

We had a brief false start around June of 2016. Creating graphics confounded me for reasons I couldn’t explain at the time, but now better understand (more on that later). My first attempts at pixel art were terrible, and I simply didn’t know how to go about creating a sprite sheet. While looking for free-to-use artwork to help me get started, I stumbled upon Locomalito’s sprite sheet for l’Abbaye des Morts on OpenGameArt.org, and through that, the game itself.

This lead to us trying out our hands at an unofficial sequel of l’Abbaye des Morts nominally entitled, Monk’s Revenge.Within about 2 weeks, we had a complete design document created, a few level iterations using the original sprites and some modified graphics.

The objective wasn’t to make money but to practice and learn.

Unfortunately, this project was interrupted by my relocation back to the US, and between that and Eric’s workload for his Master’s degree classwork, our progress was mired. When we picked things back up about a month ago, our mutual interest in creating Monk’s Revenge had since diminished in favor creating an original title. We’d learned all we needed to from it, and it didn’t seem worthwhile to move ahead knowing that it would always be shackled by licensing requirements as derivative work.

Instead, we hashed out a new game idea and Eric got to work on the new design document while I delved further into the alchemy of pixel art.

I studied tiles from my favorite 8-bit games growing up, and read up on old graphics modes for IBM Compatible PC’s (what I grew up with) and their limitations. One of Pyxel Edit’s built-in palette sets is “EGA 16” (which is actually the color set used for CGA backwards compatibility):

EGA 16-color palette

Having a limited set of options forced me to think about how the colors fit together, giving the art a genuine “retro” aesthetic. I started with a simple 16×16 pixel block (enlarged to 64×64 to show detail):

From there, I tried different color combinations and variations:

16-color tileset

The building blocks of the world(s) we will go on to create were starting to take shape, and my confident in my ability to create pixel art was starting to grow.

Just as important to our new game’s visuals would be the game’s sound and background music. Using only 4 channels and the original NES pulses, noise, triangle and PCM voices, I could some great sounding 8-bit accompaniment for the action:

 

So there you have it!

So what’s next? Expect more updates as we wrestle with new challenges creating our first game, Beaster’s Dungeon!

TANSTAFS: There Ain’t No Such Thing as a Free Salad!

Update – August 11, 2015: I received an email from GameSalad asking if I’d consider the Basic version for a $4 discount ($15/month). While I don’t take issue with  paying for a tool, I don’t think a subscription model is a good fit for the Basic version. I would rather pay a flat, one-time fee, and pay again for upgrades, if I wanted them.

I could even advocate paying a subscription for service (online publishing) and support, but if all I can do is publish to the GameSalad arcade, it’s just not worth it :(…

When I began using GameSalad, I had three major aversions to buying the ‘Pro’ version for Windows ($300/year):

  1. Stability
  2. Features (on the Windows version)
  3. Learning Curve

The Windows version was the bastard step-child of the Mac one, always several versions behind, plagued with bugs, lacking the same features as it’s Mac counterpart. While there is a robust community of developers, the vast majority are Mac users, and so due to the great disparity between the Mac and Windows versions of the application, many of the tutorials were using the Mac version, which simply wouldn’t work the same way (if at all) on the Windows one.

So what did GameSalad do?

Well, in my last post, Windows had finally caught up to the Mac edition with the implication that they’d stay synced. Even so, the Windows version was prone to crashes on startup, but a couple of updates later and that seems to have been tackled.

As to the learning curve, the new startup screen features a link to official tutorial videos!

Unfortunately, There Ain’t No Such Thing as a Free Salad…well, not anymore…

###

When I booted up GameSalad for the first time since patching, I was greeted with a 15 days remaining on my new ‘trial’ edition. No in-app explanation. Nothing in the ‘Help > About’. Zip. Zilch. Null…

Did I get a free trial of the ‘Pro’ version? What gives? Well, come to find out, their old CEO stepped down and the new one decided to start charging for the ‘Basic’ version ($19/mo).

So what did I do?

I uninstalled GameSalad. I know it’ll take me a hell of a lot longer than 15 days to learn how to use GameSalad. It’s initial appeal was that I could take my time and learn the tool at my own pace, and when I was ready, and had proven to myself that I was able to make (what I felt) was a product worth selling, I wouldn’t mind paying for the privilege of publishing it.

This is a good opportunity to change gears and maybe delve into Unity or Unreal…

GameSalad, Pyxels and New Beginnings

GameSalad Tosses It’s Salad

One of my biggest complaints about GameSalad in the past is that the Windows version seemed to be the bastard stepchild of MacOS one, and lacked much of the functionality, and the features it did share with it’s Mac counterpart sometimes behaved differently, making online guides hard to follow. Their latest update, announced a couple of weeks ago,  jumped from 10.5 to 13.14, which [I believe] finally brings the Windows version up to par with the MacOS one! This was exciting news for me, so I decided to download and install it over the weekend. As soon as i fired it up, a window popped up prompting me to login, followed immediately by a crash.

I couldn’t even log in because the application had already halted. Nothing in the event log to give me any clues as to what happened, no specific error message to chase down, it just had a heart attack and collapsed on my desktop… So, after uninstalling/reinstalling, and several reboots later, I decided to check the application to see if there was some kind of log, but alas, the only other thing of use in there was the updater, so I decided to give that a try.

Amazingly, after checking for updates and finding none (I was already on the latest release), it worked! Unfortunately, by then I’d lost interest in the messing with it and decided to move on to something else… Lessons learned? Break down and buy a used Mac? :|… nah. The only Apple devices (an iPad and AppleTV) I’ve ever owned were gifts, one of which I ended up giving away (the AppleTV), and other I use to play a time-killer games, watch videos and occasionally surf the web… Before I was ready to tackle GameSalad again, I decided to turn my attention to asset creation, which is something I needed practice with anyhow. So what’s next?

###

Pixel Art

There’s something beautiful about well-done pixel art that many people can’t appreciate. It’s more than just a retro look and feel, there’s a real elegance to cramming  lots of detail into a tiny 16×16 or 32×32 pixel space. Most people don’t realize just how small that is! But what I didn’t expect to find was that there were highly specialized tools for creating pixel art repeatable tiles you could use to create game assets. One such program I found while watching video tutorials was Pyxel Edit. It was a paid program, but $9 USD isn’t much to me, so I decided to fork over the cash (good deal for free lifetime updates). It seemed fairly easy to learn, and had a built-in animation tool.

There’s a learning curve, that’s sure, as the application itself doesn’t come with a lot of documentation. The help file is a list of keyboard shortcuts, and the buttons all have right-click tooltips, but that’s about it.  Nevertheless, there are great videos on YouTube (e.g. Achebit) which discuss a great many ideas such as color palettes, shading, design and so forth. As such, I figure it would be good practice to make a few tiles sets, experiment a little and see what I can come up with rather than trying painstakingly hand draw platforms. There are several advantages to this:

  1. Tiles can serve as [reusable] building blocks, which can be used to rapidly create levels
  2. I can create characters, enemies and objects using the same tool
  3. I can save time by adding variety via palette shifts and minor modification

Well, I’ve got some things to work on, but still need to go back to square one (no pun intended) and think about fun and simplicity…

The Skill Gap

I received a survey from GameSalad recently, which prompted me to give some thought to why I hadn’t touched it in a while, probably a month and a half or so. While it’s true that I’ve been busy with other things, I feel that I’d hit a roadblock. In my last GameSalad-related post, I discussed creating a simple turn-based strategy, so I started thinking about the mechanics of it, and what sequence of behaviors would need to occur to make that possible:

  1. Select the character you wish to move (on touch)
  2. Spawn ‘movement’ tiles which display where a character can move to
  3. Upon touching a movement tile, moving the character to that tile and destroying the other tiles

Sounds simple, right? Well, there are issues:

  • Controlling what happens when you click the character more than once (keep spawning movement tiles?)
  • What if you only want to be able to move each character once per ‘turn’?
  • How do you keep track of ‘turns’? Global attributes you toggle on and off?

As you can see, it can get very complicated very quickly, and without any kind of guidance or best practices (e.g. templates), I often find myself getting stuck.

Try something simpler? A platformer maybe?

Well even that gets quite tricky and requires a lot of advanced behavior manipulation. There are hours of video tutorials that cover this, but essentially what I’d end up with is a monkey copy of someone else’s platform game with my own front-end, and by then, I may as well just buy a template and reskin it. So I decided to set that all aside for a moment and focus on what I could do, asset creation (artwork, sound effects, music). As I pointed out a couple of months ago, aimless make-it-up-as-you-go-along level design isn’t going to get me a cohesive  world. Perspective is also an issue, being that I was designing top-down perspective maps using 2D image manipulation tools, faking it by skewing and distorting 2D rectangular ‘wall’ vectors and and manual shading to create the illusion of ‘depth’. This seemed like a sloppy way to go about it, and that there were already lots of 3D engines available which could do a much better job. So what is all this leading to?

Simply put: I’m not a triple threat. Many years ago, I became familiar with this term through drama classes I took, and for those unfamiliar, it means the ability to Act, Sing and Dance. An actor who could do all three of these things well was considered to be highly desirable,  and a threat to other actors competing for the same part. Game development can be illustrated in the same way, being comprised essentially of:

  • Programming (scripting, coding, regular expressions, the ‘mechanics’ of the game)
  • Design (2D/3D artwork, animation, texturing etc.)
  • Sound (music, sound effects)

These three components are integral, and in a well-made game, they all fit together. So which of these things can I do?

  • Design
  • Writing and Story
  • 2D Artwork (texturing in particular)
  • Sound effects
  • Music

What do I not do well (or at all)?

  • Any kind of programming/scripting
  • 3D artwork (save for basic level design, but experience limited to 3D Game Studio)
  • Animation

It’s clear that GameSalad won’t bridge that gap, nor would I expect it to. I’m just going to have to accept that I won’t be a one-man development studio, and recruit help.

Nothing is Trivial

When I take a walk through the internet, I never know where I’ll end up. What started as a search for book reviews of a particular novel I was reading ended with a memorial dedicated to the gone, but not forgotten Cronan Thompson. I’d never heard of him nor would I have been likely to, given that our interests didn’t align. To paraphrase Freddy Mercury,MiST was never my scene and I don’t like Star Trek.”

Despite having little in common, I couldn’t help but find myself chuckling over some of his writings. He was whimsical, even brilliant beyond his years. I began to envy those who had the opportunity to match wits with him, and pity those who couldn’t appreciate his sense of humor. The more I read, the more I began to feel a deep sense of regret. The same crushing twinge I recall feeling the first time I heard Ferris Bueller’s  casual observation, “Life moves pretty fast, if you don’t stop and look around once in a while, you could miss it!”

Well, I had missed it. I will only ever know this person vicariously through what remains of his writings and the second-hand experiences of others. All I have left is the heartbreaking realization that you can never go back – the world will never be what it was, then and there. For better or worse, all we have is now. If there’s one lesson Cronan has taught me, it would be this: Indulge your passions, no matter how trivial they may be to others – for nothing is trivial.

Side-Scrolling Nightmare!

So I decided to start work on assets for a somewhat realistic looking side-scroller. I’ve been chipping away at it for close to 5 days now. Here’s a peak:

woods_preview
This preview is only a small part zoomed out to 6.25% of the original size. The real image is about 20480 x 3072, or about 20×3 standard screens at 1024×768 resolution (iPad). I wanted there to be plenty of room to jump (or fall).

I’m not even halfway through one level. The problem isn’t the artwork – good art takes time, and what I have so far looks promising. The problem is spending almost a week building a level, by hand, without a design document or anything beyond a vague idea of where I want to go.

One suggestion many game designers have made was to make a game I’d enjoy playing. One game I recall playing with a friend on a snowy day, maybe 14 or 15 years ago was Gemfire. This was an old NES title, and a hell of a turn-based strategy game split between managing your lands and fighting on the battlefield. My friend and I would take turns as he was good at managing at the lands and I was his war chief. I came up with an unbeatable strategy that would allow us to take on enemies with superior firepower using hit and run tactics and taking advantage of the flank and rear attack mechanics (which did more damage).

Another great one, if only because it was so unique was Castilian (or Tower Toppler or Nebulus depending on which one you played). What made it so amazing was that it was the first game I’d ever played which gave you the illusion that you were move around a 3-dimensional object (the tower) as it the view rotated as you climbed. This was pretty amazing to see on the NES (the first system I recall playing it on, though I may have seen it in an arcade prior to that).

So back the drawing board. I’m going to need to work on putting some ideas down on paper and use that as a starting point.

Getting Closer!

I downloaded several of the GameSalad example projects to try to glean some insight into best practices, and how those could be applied to my project to resolve outstanding bugs. Here’s a recap of the issues I was struggling with, and how I resolved them.

The solution was simple enough; instead of trying to include the collision animation, the correct way to do it was to destroy the actor in play, then spawn a new actor whose behavior was to perform the destruction animation. Add a timer set to the duration of the animation, then add another destroy and….IT WORKS!

Here’s a sample of what I’ve got so far – keep in mind that this was just an exercise to learn what was possible and not a complete game, so don’t judge too harshly 🙂 :

Next steps?

1. I need to make the player take damage and capture this in a health bar
2. I need to tweak enemy behavior and physics (they should turn to face the player instead of moving in the same direction) and shouldn’t bounce off the walls wildly when they hit them.
3. Game over screen (only applicable once I have a working game)

The Learning Curve

I’ve been able to create a very basic game. It has a room, and walls that constrain the main character to that room. The main character is movable using the Arrow keys (though I may change it to WASD) and he even turns to face the direction he’s going using the “Rotate to” behavior. His movement is animated.

This character shoots animated fireballs when the space bar is depressed in whatever direction he’s facing and stop when they hit a wall or another character, and play a sound effect when this happens. Upon collision with a wall or monster, they “explode”, displaying a different animation (more on that later) and playing a different sound.

I created monsters for the character do battle with that spawn every 2-7 seconds, and move to wherever the player is at that moment. They are destroyed when hit by a fireball.

I also added ambient background music (once I’d figured out that it had to be .m4a format).

Sounds nifty, doesn’t it?

Well, there are problems…

  • I wanted to fireball to have separate initial, traveling and collision animations. The traveling animation looks right, but the initial and collision animations are buggy. Behaviors like “change scene” and “destroy character” are full-stops; they trump anything that comes before them as soon as they’re executed, no matter what! I wanted the fireball to explode on impact of whatever it struck (and had a specific set of sprites for this animation). After the explosion completed, the fireball actor should be destroyed to remove it from the game field. What’s happening instead is that it’s disappearing immediately after collision. I tried adding a timer, but this is buggy as it continues to display the travel animation on top of the exploding animation, causing the fireball to “hang” for a few seconds before exploding.
  • Because of the issue above, I can’t get death animations to work right either. As soon as the monster is struck by a fireball, it disappears immediately.  Again, timers don’t seem to help here.

So where does that leave me? Well, I’ll try bringing it up on the forums, but I suspect that this has to do with the fact that I’m using the PC version…I’m not about to go out and buy a Mac just for this one application, nor am I prepared to shell out the $300 GameSalad wants for the Pro version until I’m proficient enough with it to create a working game I’m proud of.

That said, my next step is the forums…

More Concept Art – Dungeon Scene

Here’s a scene I created in Photoshop. The idea was to create a dungeon scene using texture manipulation and layer transformation. The result is a 3D-like killing chamber I could use as a background texture. I might employ some lighting effects, maybe add a visible light source like window openings toward the edges of the screen.

3D-like dungeon background
3D-like Dungeon Background

After creating the first image, I decided to try creating an adjoining room. Here’s what I came up with:

3D-like background extended.
This is an extended version of the first one I created. Added another room to give the level more depth.

I also decided to experiment with lighting, and added a hit of a grate shining down from above.