Our final project is due at the end of this week, which means it’s time for debugging. Looking back through old scripts I wrote in March and April reaffirms how much I’ve learned in the past several weeks.

Not only do I have a much better command of C# syntax, but my logic has improved noticeably, meaning I can manage multiple functions and instances simultaneously without too much of a headache. Less guessing, more purposeful planning.

As of today, we have 22 bugs on our bug list, 13 of which are ranked high priority. And that’s not including all the ones we haven’t yet found. So here’s to the last few late nights of crunching and debugging. May they go as smoothly and be as pain-free as possible.

Here are some of the things on my to-do list for the next week and a half:

- implement particle effects (explosions, movement trails, player notifications, etc.)

- polish animations

- create a new set of background pieces

- script some movement for midground pieces (airplanes, clouds, etc.)

- ensure that the scoring system works properly for successive plays

- debug character movement, environmental assets, and front end menus

It’s hard to believe that the deadline is so close. Time to kick things into high gear!

Lately, I feel like I’ve been working through a logic puzzle, only in script. At first, implementing Chip’s animations seemed easy. We only had five animations: walk, jump, throw a ball, hang by his chin, and die. Sounds easy enough, right?

That’s what I thought too. Very quickly, I realized that these animations weren’t mutually exclusive. Chip might jump and throw at the same time, making for a very twitchy looking Chip.

Back at the animation boards, we knew we had to separate out Chip’s body parts in order to run simultaneous animations. But which body parts? And from which animations?

Here comes the logic puzzle. Regardless of what Chip’s doing (walking, jumping, etc.), if he throws a ball, the throw animation should play. So first and foremost, his arm needed to be a separate piece.

Next came the more nitty gritty. When Chip is jumping, even though he’s also moving forward, he’s no longer walking. Similarly, when chin hanging, even with forward inputs, Chip should not be walking. And above all, if Chip is dying, he shouldn’t be doing anything else.

After a few days piecing it all together, Chip has come alive and is now quite animated!

If you’ve ever played a game and striven to attain any of its achievements (think Angry Birds), the game designers have hooked you in with psychology. Achievements, like visual feedback, audio, and various missions and challenges, play a huge part in the perceived fun and replayability of a game by motivating players.

To learn more, take a look at this article on how to design effective game achievements: The Cake Is Not a Lie: How to Design Effective Achievements

There are entire forums out there dedicated to dealing with various programming error messages. And as a novice programmer, this scared the heck out of me. How was I supposed to know what was wrong without seeing what my code did?

However, after weeks of braving the sea of error messages, I’m happy to say that I find them quite helpful. Most of the time. In fact, I even have a few favorites:

1. Error CS8025: Parsing error

This is hands-down my favorite. Easiest to fix, yet one of the most annoying. This error usually refers to a misplaced curly brace. Spend a few seconds visually pairing up all the curly braces, and this error is soon out of your hair.

2. Error CS1525: Unexpected symbol ‘{‘

This one is another fun syntax error, usually thrown out as a result of not pairing all the parentheses in conditionals. In programming, most things need partners.

3. Error CS0029: Cannot implicitly convert type ‘int’ to ‘bool’

There are several variations on this error, which usually results from syntax error in the conditional. Most of the time, I get this error when I forget to include double equal signs in my conditionals (e.g., ‘if (iLevel = 1)’ rather than ‘if (iLevel ==1)’), so the statement tries to set values rather than compare them.

From here, the errors start to get more complicated, ranging from null reference exceptions to invalid argument errors. And those are just the ones Unity can detect. Often, the most difficult errors to fix are those that result from faulty logic. It does exactly what you told it to, but unfortunately, your directions were off.

So what have I learned from the countless error messages Unity has thrown my way? Even the best programmers make mistakes that lead to error messages. But figuring out how to successfully deal with those error messages is what separates the good from the great.

To say I’ve learned a lot about scripting over the past several weeks is an understatement. I’ve gone from struggling to create basic character movement to creating functions that can “think” on their own. But most of all, I’ve learned that programming is not just about working hard, but more importantly, about working smart.

One of my recent tasks has been to design and implement a level select map. After plotting the levels on the map, my first instinct was to script the individual events for each level.

So, for example, if level 3 was just completed, the spotlight for the next level would need to go on the level 4 marker. If Chip is on the raft between levels 3 and 4, he can go to the right for level 4, get back on the raft and go left for the bonus level, or get on the raft and go up to get back to level 3. But he would not be able to go past level 4.

As you can imagine, the list of conditionals and events needed for each spot quickly grew quite lengthy. The solution? Work smart.

I stepped back and analyzed the commonalities amongst the different stopping points on the map. Chip would need to stop at level markers, but also rafts and corners as well. But he would only be able to launch into a level while currently standing on a level marker.

As the patterns started to emerge, I was able to formulate functions and algorithms so the code would work for me, rather than the other way around. It didn’t come without tough moments and tricky spots, but in the end, the code is much cleaner and ready for additional functionality as needed.

So even though working smart may be riskier in the short run and you may spend more time feeling stumped, ultimately, the payoff can be well worth it.

Logos have long been one of my favorite parts of graphic design. A logo needs to be simple and straightforward while simultaneously communicating layers of meaning.

When designing a logo, I first think long and hard about what I want the image to communicate, filling the pages of my sketchbook with words and doodles. Color choice, typography, style, and spacing all play important roles and can drastically change the look and feel of a logo.

In designing the logo for our current game Blokhead, I wanted to create a bright and strong logo that would communicate the main mechanic of throwing and deflecting balls. I wanted the logo to communicate both action and fun.

The result is a logo comprised of primary colors and thick blocky letters that incorporate the L and O of Blokhead into an image of a bouncing ball. Simple, functional, memorable.

Aim Assist Ball

In the process of designing ball powerups for our game, we decided to add an aim assist ball that would show players the trajectory of the ball, as well as the first deflection, allowing players to line up their shots more accurately for long shots. The task of programming this nifty little powerup fell to me.

Ball Physics

To start, I looked at the ball physics of classics like Pong and Arkanoid, analyzing the angles of deflection and trying to figure out the patterns. Soon, it was time to get out the graph paper and start plotting points.

In order to show the trajectory, I would need to know the initial angle the ball was aimed. In order to figure out the angle of deflection, I would need to figure out the orientation of the surface the ball would hit, as well as the angle of the collision.

After plugging and chugging several sets of numbers and angles, I finally realized the common thread. So for those of you still hoping to create a Pong game of your own, here’s the anatomy of ball deflection.

Hit Normal

First and foremost, we need to figure out the orientation of the surface the ball hits. Is the surface vertical, horizontal, or diagonal? Luckily, the hit.normal provides this information. The normal of the hit point provides the direction that’s perpendicular to the surface that was hit.

Deflection Point

To figure out the point of deflection, just reflect your initial point (the ball origin) over the normal. Double the distance between the normal and your origin, and plop down your deflection point.

For vertical surfaces, the x-coordinate of the deflection and origin will be the same, while the y-coordinate will change, and vice versa for horizontal surfaces.

Diagonal Surfaces

This is all fine and dandy for horizontal and vertical surfaces, but things start getting tricky with diagonal surfaces. Fortunately, we can turn to the dot product of points A and B. The dot product gives us the distance between the hit point and the midpoint of line segment AB. Double this to figure out the distance between A and B, then reflect over the normal as before. Simple, right?

Here’s a sneak peak of the aim assist ball in action:

]]> http://dickersondesigns.com/wp/2011/03/ready-aim-math/feed/ 0 http://dickersondesigns.com/wp/2011/03/creating-2d-levels-with-unitile/ http://dickersondesigns.com/wp/2011/03/creating-2d-levels-with-unitile/#comments Wed, 23 Mar 2011 01:12:04 +0000 Annie http://dickersondesigns.com/wp/?p=1751 Continue reading →]]>

As we’re starting to create levels in Unity, we’re discovering that making 2D levels in a 3D environment is no walk in the park. Luckily, we’ve discovered UniTile, an easy to use yet powerful tile-based 2D map editor for Unity.

If you’re interested, you should definitely check out the UniTile demonstration video to glimpse some of its capabilities. UniTile allows us to “paint” levels into Unity, then immediately jump into them to test them out, decreasing our level building time by several hours.

If you’ve decided that UniTile is appropriate for your project, here are a few simple steps for setting up and getting started.

Installing UniTile

UniTile comes as a Unity package, so you can just import the package into any existing project. Once you’ve saved the package on your computer, open your Unity project, then go to Assets > Import Package and browse to find the UniTile package.

Creating Textures

Before setting up UniTile in a new scene, you’ll need a texture that holds the pieces you want to use in your level. I create my textures in Adobe Illustrator, then export them as PNGs.

Importing Textures

You can then import the texture into your project. To do this, right-click in the Project window and go to Import New Asset, then find your texture. After importing, I modify the following settings for my textures:

Filter Mode: Trilinear

Texture Type: Advanced

Generate Mip Maps: Disable

Creating Materials

After importing the texture, create a new material. To do this, right-click in the Project window and go to Create > Material. Drag your texture onto the material and adjust the material settings. For my materials, I set the shader to Particles/Alpha Blended.

Setting up UniTile

After importing the UniTile package and creating your texture and material, create a new scene in Unity. Then, find the UniTileManager prefab in the UniTile package and drag it into the Hierarchy.

Click on Add New Layer to create the layer on which you’ll make your level.

With the new layer selected, drag the material you made into the Material slot in the Inspector window. You should see your material underneath. Adjust the layer properties, then click Apply.

Linking Prefabs/Colliders

To link prefabs and colliders to the pieces in your level, double-click on a tile to bring up the TileEditorWindow. Modify the settings as needed.

To start creating your level, first click on the hand tool in the top left corner. With the layer selected, left-click to highlight the tiles you want to place in your level. Then, just place the tiles where you want in the Scene view.

After placing all your objects, click Create Objects to connect all the prefabs and colliders. Voila! You’re ready to jump in and play.

Test Level

Here’s a test level I threw together in just a few minutes:

With UniTile, our level design process has become a lot simpler, enabling us to more quickly build and test new levels. Hopefully you’ll enjoy UniTile as much as we are. Enjoy!

I am by no means a character designer. Throughout my patchy art and design background, I’ve always shied away from designing characters. Landscapes, fanciful illustrations, and fonts – those I can do. Characters? Nuh-uh.

To me, designing characters is the hardest type of design. Breathing life into a being created through imagination takes both skill and courage.

That’s why when it came time to design the main character for our game, I tried to pass the task off to anyone and everyone. I didn’t want to shoulder the responsibility because I didn’t think I was capable of creating a likable, memorable, and functional character.

What followed were weeks of ups and downs. Frustration, excitement, spurts of creativity, anxiety, and lots of iteration.

When designing Chip, we prioritized three things: cuteness, functionality, and memorability. First and foremost, he had to have a blocky head which could pivot to deflect balls. To speak to the intuitiveness and simplicity of our mechanics and gameplay, we also designed Chip using basic shapes and primary colors.

No character is perfect, but I think we’re finally at a point where we’re all satisfied with Chip’s design. Chip’s colors are warm and approachable, and his form communicates function. And thus, we’re finally ready to unveil the making of Chip: