Beyond the Veil

What type of magic does it take to make your own video game?

[niarlat]

Motion Capture: Horror Movie Monsters Doing Yoga

Pictures from an old project in my Motion Capture Animation class. For this project we used Autodesk MotionBuilder and VICON Blade. My movements were driving the character with the jacket and camo pants. The character in the suit was being driven by my friend John’s movements. Movie monsters especially need to stay limber and in shape to chase people around all day!

[niarlat]

Virtual Modeling: 3D Scanning a Dragon

Here I used AutoDesk 123D Catch (http://www.123dapp.com/catch) to make a 3D scan of one of my favorite Dungeons and Dragons miniatures.

After walking a full circle around your subject and taking photos of it, 123D Catch constructs a model that you can touch up and repair in other programs until you have it looking the way you want.

You’ll notice his right wing has a couple of holes and his left wing is very wrinkly compared to his original, but he still looks pretty good!

The only downside is that the model produced by the scan was incredibly complex, consisting of 480,260 vertices and 927,263 polygons. This means it is not suited to use for something like a real-time animation or a video game, but I’ve heard interesting things about the Australian company Euclideon and their work to make an Unlimited Detail Engine specialized to scan in 3D objects as point clouds rather than a mesh of vertices and polygons in order to solve this exact problem.

[niarlat]

Virtual Modeling: Sugar Bowl

Just as with many other forms of art, it helps a great deal to have a visual reference when creating a virtual model.

In this case, I took some photographs of a sugar bowl I had made with a potter’s wheel long ago. (Some of you may remember a similar sugar bowl from Disney’s The Sword in the Stone!)

I used a combination of Autodesk Maya and Autodesk Mudbox to make a virtual version based on the photographs and added arms and a crack to the side of the bowl.

[niarlat]

By popular demand, screenshots of some of my old procedural animation projects with links to their videos on youtube.

Procedural Nyarlathotep:

https://youtu.be/INXdG7AWgNQ

Procedural Armor:

https://youtu.be/nI6Jj8fbTbI

These were both made with Houdini. Contrary to some public perceptions, an incredible amount of math and algorithmic thinking goes into making these because the geometry, properties, movements and changes in the model are all described numerically and altered programmatically.

[niarlat]

Unit Conversion and Change of Coordinate Systems: A 2D Example

Last time, we learned how to use image differencing as a simple way to detect motion in a video feed. Now that we can identify which pixels in the picture contain motion, there is one more step we have to take in order to translate the locations of those pixels into the spatial coordinates of the game world.

Just like when we convert temperatures from Farenheit to Celsius, we have to establish a relationship between the two coordinate systems that allows us to convert from one to the other with a simple calculation. The tricky part with coordinate systems is that now we're dealing with multidimensional coordinates instead of just a single numeric value.

Let's say we have an image that is 160 pixels wide and 90 pixels high. In most representations as a data structure, the image is represented as a 2D array of pixels, so we can use the 2D indices of the pixels as if they were x and y coordinates. (If you are not familiar with 2D coordinate systems, think of it like the grid system in the board game Battleship: x tells us which column we're in and y tells us which row.) We'll say the lower-leftmost pixel is (0, 0) and the upper-rightmost pixel is (159, 89).

We'd like to map these pixel coordinates into the world of our video game. I mentioned in my last post that when dealing with 3D games we can employ some fundamental rendering concepts to get from a pixel on our screen to a spot in the 3D world, but for now let's stick to a simpler and more general example and say we're dealing with a 2D game with a camera that doesn't move and can always see the full span of the game world. Let's also say that out of a desire to help the game world fit to a widescreen image, the game world was made to be 160 units wide and 90 units high. Unlike the image's coordinate system, however the game world coordinates have (0,0) as the center of the world, with the lower-leftmost point being (-80, -45) and the upper-rightmost point being (80, 45).

As with any problem, there are multiple ways to conceptualize and approach it, but I like to think of this method as expressing the coordinates in terms of their magnitude of difference from the lower left most spot as an in-between to go from one system to the other.

In order to do this, the first thing we must take into account is the range of each coordinate system. This feels somewhat strange, because even though the pixel image has a width of 160 pixels, its range in coordinates is really only 159, because the difference in location from the leftmost coordinate to the rightmost coordinate is 159 – 0, or just 159 units. Similarly, the Y coordinate range is 89 – 0, or just 89.

For the game world coordinate system, the x range is 80- (-80) = 160, and the y range is 45 - (-45) = 90.

Now we have everything we need for the conversion. Let's do the x coordinates first. If we have a pixel in the image with the coordinates (pixelX, pixelY) then its corresponding coordinates in the game world should be (gameX, gameY) calculated as follows:

gameX =  ((pixelX – pixelXMin) / pixelXRange) * gameXRange + gameXMin

The first step, subtracting the minimum x value from the pixel X value tells us the difference in distance in that coordinate system between our pixel's position on the x axis and the minimum possible x position it could have. Dividing that difference by the pixel x range expresses that distance as a percentage of the entire pixel x coordinate range. Multiplying by the game x coordinate range changes it from a percentage into a distance expressed in the game x coordinate system,  and adding the game's minimum x coordinate value compensates for any minimum value offset.

The caluclations for gameY are similar:

gameY =  ((pixelY – pixelYMin) / pixelYRange) * gameYRange + gameYMin

Let's try it out with the easy points: the lower left pixel (0, 0) would be:

((0 – 0)/ 159) * 160 + (-80) = -80 for gameX

and

((0 – 0)/ 89) * 90 + (-45) = -45 for gameY

so the lower left corner appears to convert properly from (0, 0) in the pixel coordinates to (-80, -45) in the game coordinates.

What about the upper right corner at the pixel coordinates of (159, 89)? For these I'll do them in multiple steps:

gameX = ((159 – 0)/ 159) * 160 + (-80)

= 159/159 *160 +(-80)

= 1*160 + (-80)

= 160 + (-80)

= 80

and

gameY = ((89– 0)/ 89) * 90 + (-45)

= 89/89 * 90 + (-45)

= 1 * 90 + (-45)

= 90 + (-45)

=  45

and it looks like the upper right corner appears to convert correctly from (159, 89) to (80, 45) as well.

But we wrote the conversion equations using these point correspondences, so it's not surprising that they'd work. It's best to test other points in the middle, so let's do one more conversion in the center of the image. This would be (79.5, 44.5) in the pixel coordinate system. So, to figure out where that is in the game world's coordinates, we put it through our equations:

gameX = ((79.5 – 0) / 159) * 160 + (-80)

= (79.5 / 159) * 160 + (-80)

= 0.5 * 160 + (-80)

= 80 + (-80)

= 0

and

gameY = ((44.5 – 0) / 89) * 90 + (-45)

= (44.5/89) * 90 + (-45)

= 0.5 * 90 + (-45)

= 45 + (-45)

= 0

Thus, the middle coordinate of the pixel coordinate system (79.5, 44.5) converts precisely to (0, 0) in the game coordinate system the exact center.

In this way, we can convert the location of any pixel in our coordinate system into a location in the 2D space of our game. We can make our motion detection interactive by saying something like “There is motion detected in pixel (30, 50), so we should deal damage to the helicopter enemy at the corresponding location (-49.811, 5.562) in the game world.”

You may notice that there is some work that needs to be done with rounding. The pixel indices are all discrete integer values, but the game coordinates are continuous rational numbers. In order to account for the gap of space between pixels, we can't check to see if there are any interactable objects exactly at (-49.811, 5.562). What if the helicopter is at the game world coordinates (-50, 6) instead? We need to have a range of flexibility for the activity to fall into in order to trigger an interaction. Fortunately, that is part of collision checking and hit detection in general, which I will get into another time.

[niarlat]

Image Differencing, Part 2: Matrix Subtraction

In my last Image Differencing post, I went over what a pixel was and how every digital image no matter how smooth and natural it looks is actually an orderly and discrete grid of pixels.

I ended with the remark that since each pixel holds a numeric value, we can also think of pixel images as matrices of numbers with which we can do all kinds of mathematical operations.

I gave the example of the green screen technique used by newscasters and movie stars to cut themselves out of a video and place their performance on top of a new background, but in fact you don’t need to be in front of a solid green screen to do that: you can achieve the same effect with Background Subtraction.

Consider this: imagine that you have a picture of yourself that you want to use in an art project. You’d like to edit that picture and make it look like you’re standing on the moon next to Neil Armstrong. The first thing you have to do is cut out your image from the rest of the room surrounding you, and that usually means a ton of zooming in and carefully erasing around yourself in an image editing program.

However, you also happen to have a picture of the exact same room, from the exact same angle, but without you in the shot.

Consider what the pixels look like in those images: remember that each pixel has a numeric value representing its color. That bookshelf on the left is the same in both pictures, and the bookshelf hasn’t moved or changed color, so that part of the image should have the exact same values for its pixels. This also holds true for the walls, furniture, everything in the room that didn’t move.

Remember also that the mathematical way to measure difference between two quantities is subtraction. (How far away is 10 feet from 3 feet? 10-3 = 7, so it is 7 feet away.)

Therefore, if we just wanted to take two pictures and ask “what is different between them?” all we have to do is a matrix subtraction with the two images. Like so:

The upper left image is a picture of the room without me in it. (The background in this case.) The upper middle image is a picture of me giving the peace sign in the same, unchanged room. The upper right image is the result of the matrix subtraction: the difference between the two pictures.

Anything that didn’t change ends up with a value of 0 (solid black) because any number minus itself is zero (that’s the Additive Inverse.)

Any pixels that did change between the two pictures are left with nonzero values and show up in the black and white difference as shades of gray.

Notice that the only things in the difference image are myself and the chair, because I wasn’t in the picture of the background, and the chair moved a little from me sitting in it. Everything else (the bookshelves, the ceiling, the lights) is all gone. We’re left with a pretty neat cutout of just me. That’s a very specific type of Image Differencing called Background Subtraction.

In the lower left, I’ve taken the difference image and made it into a binary image (either something did change and the corresponding pixel is solid white, or the pixel value was the same between pictures and it is solid black to indicate no change.) The lower right is that binary image cleaned up a little with an Open operation to fill in any holes. Don’t worry about those two for now: we’ll get into them later.

You can also use this same image differencing technique as a simple way to detect motion.

In this set, we’ve got a picture of me giving the peace sign, and another picture of me a second later having slightly moved my hand and kept still otherwise. You can see in the difference image that now the only pixels that changed were the pixels around the edges of my hand and a little bit of my shoulders. Therefore, since those parts of the image changed, you can say that movement took place in those pixels of the image! Neat, huh?

In this set of pictures, I started to open my hand from a peace sign into an open palm. You can see in the difference image that my thumb, my ring finger and my pinky finger moved a lot, but the other fingers and the rest of me moved only a little.

In this last set, I’ve shifted my entire body slightly to the left. Notice how the movement is more easily detected on the right side of my hair because it stands out against the more varied background of the bookshelf, while the movement of the left side of my hair wasn’t noticed because it’s almost the same color as shadows of the room behind it. Image differencing isn’t a perfect method to detect motion: you have to be well lit without shining any lights into the camera itself and you also have to stand out from your background for it to work, but it’s a shockingly simple application of matrix arithmetic that lets you do some really neat things!

So now we have an understanding of what makes up digital images, and how we can use the awesome power of math to calculate differences between two images. Nothing fancy going on here so far, but wait! Even if we know what’s moving in the picture, how do we apply that to what’s going on in a video game environment?

The answer to that is also shockingly simple, and is no different than figuring out how many feet are in a yard, or how hot a Fahrenheit temperature is in Celsius.

The pixels in an image have their own two-dimensional coordinate system, like a battleship grid. We can say that the lower-leftmost pixel in the image is (0,0), and the pixel to the right of it is (1,0), and the pixel above the lower-leftmost is (0,1), and so on.

The game world has its own coordinate system too. If you’ve done any work with rendering 3D models you may already be familiar with this, but all 3D games have their own system for taking coordinates of game objects in 3D space and figuring out where they’ll show up on the flat plane of pixels that is your computer screen. That, in essence, is the process of rendering!

We’re just going to need to reverse the normal rendering calculations and instead of going from 3D space coordinates to the flat pixel coordinates of your screen, we’ll be going from the flat pixel coordinates of our difference image to the 3D space coordinates of the game. That will be our topic for next time: the glamorous world of Unit Conversion and Change of Coordinate Systems!

[niarlat]

Kaij-You! demo is now available on Game Jolt!

http://gamejolt.com/games/kaij-you/176669

Check Kaij-You! out for yourself, and please support the Kickstarter if you can!

Years ago, when a friend told me about some interesting pixellated indie horror games and directed me to get them from Game Jolt, the thought never occurred to me that some day I might be joining the ranks of those developers.

The first Game Jolt game I played was Calm Time, and when I played it I tried to put together the story behind the game. My friend asked me, “wasn’t it disturbing?” and I replied with my own interpretation of the story: *SPOILERS!* it seems to me that the main character is a very frustrated and most likely incredibly drunk pet butler monkey. He’s upset that he has to care for all of the guests trashing his mistress’s house in the wake of her tragic passing, which explains why he has an inner monologue and can understand the guests, but can’t actually speak to them (and why the guests don’t find it odd that he doesn’t talk back.) After trying to relax with one too many stiff drinks, he suddenly snaps in his grief and chases after the now terrified guests. Since he is but a tiny monkey in a fancy yet restrictive suit, all of the guests, even the children, can outrun him with their vastly longer strides. Lastly, the poor monkey misses his departed mistress, and is wracked with pain every time the alcohol makes him see a memory of her in the house as a ghostly image.

My friend did not see it that way, but afterward, I saw Markiplier’s Let’s Play of Calm Time and when he similarly interpreted the game in a humorous light as The Crazed Butt Stabber I cracked up.

I owe these fond memories to Game Jolt for providing a place in which we can share games like this, and I’m proud to finally contribute a game of my own to that community.

[niarlat]

Image Differencing, Part 1: Pixels

The basic technique that Kaij-You! uses to detect motion with the webcam is called “image differencing”.

You all know what a pixel is, right? If you zoom in far enough on a digital image, you’ll notice that the image starts to look blocky. Those little blocks of color are called “pixels”, and every digital image is made of a bunch of those little guys arranged in a neat grid.

In older video games the presence of pixels was much more obvious because the images for the game were made of fewer pixels, so you could still see the blocky edges. For example:

These days, digital images are composed of a much much greater number of smaller pixels, so that they achieve the illusion of being smooth, but deep down they are still just grids of pixels arranged in orderly rows and columns!

Each individual pixel in an image holds a numeric value representing what color that specific pixel is. The simplest type are pixels in a grayscale (or black and white) image: they have a value between 0 and 255 (inclusive) representing how bright they are. 0 is solid black and 255 is solid white, with the values in between representing different shades of gray.

Pixels can also hold color information, with a popular format being RGB. In this format, each pixel holds THREE numbers, each representing how much Red, Green and Blue color is in that pixel. For example, the solid red pixels which make up Mario’s hat in the image above would have RGB values of (255, 0, 0). Similarly, solid green pixels would be (0, 255, 0) and solid blue pixels would be (0, 0, 255). Black pixels in this format are (0, 0, 0) with no color at all, and white pixels are (255, 255, 255) with each color value maxed out.

Mixing the RGB values to make new colors is not like the color wheel used by ink and paint artists, but is a slightly different spatial representation. That’s because these pixels aren’t pigments: they’re lights, so they use the additive representation. This means that if you mix solid red and solid blue with (255, 0, 255), you won’t get purple, you’ll get magenta! Fortunately, there are plenty of tools that help you visually look through this color space for something you like.

So, now we know that deep down, every digital image is really nothing more than a grid of square pixels trying to look natural and cool. Each pixel in the grid holds its own numeric values representing what color it is. In the case of a black-and-white image, each pixel only has one numeric value representing its brightness.

In this sense, we can also think of images as a grid of numbers exactly like a matrix from math class. This means we can do mathematical operations on images! Why is that important?

Well, you may already know about the film and television trick of using a green screen (formerly blue screen before people decided that green seemed to work better). With this technique, an actor or newsperson stands in front of a solid green screen while they are being filmed on camera. Since each frame in that video is really just a grid of pixels, a computer can easily go through the video and identify which pixels have the RGB value of (0, 255, 0) for green and remove only those pixels, leaving behind a nice cutout of only the actor or newsperson with no background behind them. This cutout can be placed on top of another background to make it look like the person in the video is flying through the sky like superman, or standing in front an animated weather map, or really anything! As long as the actor isn’t wearing green, it’s an easy thing to separate them from their background with math!

But simple comparisons like this aren’t the only thing we can do with images using this numeric representation: we’ll get into how to detect motion in video in part 2!

[niarlat]

This is a screenshot of the camera setup menu in Kaij-You! I’ll go into more detail about what these terms mean in my next post, but the upper left shows live video from a webcam, the upper right shows the image difference between the current video frame and the last frame, the lower left shows the Motion History Image from the camera video, and the lower right shows the image difference after it has been opened to fill gaps in the moving regions.

[niarlat]

Kaij-You! Kickstarter is live!

Hello all,

It’s been quite some time since my last post due to the fact that I’ve been working on some big things. Specifically, I created a playable demo as part of the just-now launched Kickstarter campaign for my upcoming game: Kaij-You!

https://www.kickstarter.com/projects/1159635693/kaij-you

This is a project I’ve been wanting to do for a long time. It’s a motion-controlled game you play with your webcam! If you’ve ever wanted to stomp around a city like Godzilla smashing buildings and fighting enemies then you should love this game! Please take the time to check out the project page and support it if you can!

[niarlat]

Ugh, the pink sky in my other photos was a result of the program misreading the image files. We were told to use PPM images (saved as plain text) and the format wasn’t totally clear. Apparently the PPM file starts out with “P3″ then the height and width, then the number 255 (telling us what the maximum value for any entry is,) and THEN it starts listing off RGB values for each of the pixels.

I had to reverse engineer it by making an image that was exactly 2 pixels by 2 pixels and making each one Red, Green, Black and Blue, respectively. Then I was able to inspect the text image and notice that there was an extra 255 in there that was throwing off the other values.

In any case, now the last mystery is why the reflections are upside down...

[niarlat]

Missed a few pics in my initial upload. For those who wish to use some of these models yourself, the bunny and Chinese dragon were obtained from the PLY image set available at Georgia Tech’s website.  Note that they don’t have information in them about the vertex normals (little information that indicates which way is “up” at different parts of the model) so they won’t respond properly to lighting unless you also download the PLY tool set which inlcudes a C program to read a PLY file and spit out a new copy of it WITH the normals included. As for the European dragon he is actually a 3D scan I made like a year or so ago as part of my Virtual Modeling class. He is Icingdeath from Wizards of the Coast’s official Dungeons and Dragons Miniatures set. The program I used to scan him in was the AutoDesk 123D Catch app on my android phone and it is a very awesome program but the models it generated always had a TON of vertices and often needed to be repaired or patched up in another program like Maya or Mudbox.

[niarlat]

Writing shaders in Visual Studio so far has been a massive pain, and I mean “wow!”. There are so many hidden levers and secret incantations you have to know to make things work at a very basic level. I was hoping to have this done earlier so I could somehow integrate my own shaders into my final project but I just finished this shader lab THIS MORNING. Last day of classes was Wednesday X(. Hopefully there are better ways to do this stuff than my experience so far with Visual C++ and OpenGL.

[niarlat]

Opportunity Cost in Development

Since the completion of my last project (The Jellyfish Game, Kurage, which I did as part of a group,) my posts have all been on the general development process rather than specific details of my current project. That is because of the fact that the end-of-semester crunch has forced me to focus on time management, prioritization, and triage.

I addressed in an earlier post the positive and negative aspects of the so-called “walking simulator” genre, referencing one of Jim Sterling’s videos on the subject in which he emphasized that if you do decide to leave out any one aspect of a game experience, you have to step up the quality of the experience in every other aspect to compensate. (Ie. if you have no enemies, then you need not know how to program AI or animate enemy characters, but you had better have a DANG good exploratory experience.)

When you consider that principle alongside what I discussed last time in my post about the pertinence of deadlines and development plans in Exploratory Development, one thing becomes apparent: when you impose a resource restriction on an exploratory project, you impose a restriction on the total magnitude of what can be achieved overall.

Think of it this way: the resource restriction, usually in the form of a time limit or deadline, is like a chain tying you to a stake in the ground: no matter which direction you choose to run, you can only get so far before the chain stops your progress. Then, the overall scope of the project looks something like this:

(Note this graph is just a rough picture of the idea: Sound and Art are NOT opposed to each other nor are Mechanics and Story.)

Under this restriction, any time you spend working on gameplay or mechanics is also time that you didn’t spend on sound design, art, story, or any of the other aspects of the game and vice versa. In Economics, we refer to this principle as opportunity cost - the idea that part of the cost of making a choice under limited resources is the loss of everything else you could have done instead.

My instructor mentioned one case in which deadlines are inevitable: if you are making a game based on an upcoming movie, it is very desirable to release the game before the movie comes out, so that the subject matter will be at the height of its popularity and thus the game can be expected to get the best reception possible. However, this is probably one of the many reasons why movie games are almost never experimental: if you know you will be under an absolute deadline, you would be taking a huge risk to try to innovate rather than going with a safe bet and pursuing something that you have done before and therefore is more likely to be achievable within the time limit.

Consider it from another angle: when you have a free evening and plenty of time, you can grab fresh food from the grocery store and cook yourself a nice meal. When you have to be somewhere in 20 minutes, you eat whatever you can grab and hork down as you run out the door (or more often these days, skip the meal entirely.) Which of the two options would you pick if you had a choice? Which of the two options is better for your cooking skills? For your health?

This is the essence of why I prefer indie development over AAA development: the team is free to prioritize making the best game that they possibly can and take as long as they need to release it (albeit sometimes at the risk of upsetting the less patient among their Kickstarter backers.)

Pixel took two years to make the first version of Cave Story, and the developer of Dwarf Fortress asks no fee to play his game but gets by on Paypal and Patreon donations. Yes, these approaches lack the security of a steady paycheck from a giant corporation that is already sitting on a pile of capital, but without the limits of a deadline the developers can work on the game until it is artistically complete rather than just shoveling out whatever they can to meet the deadline.

It is in this spirit that I have decided to forego sound completely for my final game. With only one day left to finish it, there is nowhere near enough time to make quality sound design. I could do what I did initially for Kurage, insert a simple electrical *bzzzt* sound that plays whenever the player picks up an item, but we ended up removing that in favor of a more subdued sound because after about 100 items or so (*bzzzt* *bzzzt* *bzzzt* *bzzzt* *bzzzt* *bzzzt* *bzzzt*!) IT GOT REALLY GRATING and actually worsened the gameplay experience as opposed to simply having no sound at all.

As the saying goes, “anything worth doing is worth doing well,” and as per our chain metaphor above, I simply don’t have time to do an array of sounds for every possible action and reaction in the game in order to give full justice to sound design. I’m going to focus entirely on seeing the mechanics through as far as I can.

[niarlat]

Exploratory Development

As November comes to a close and the weather begins to turn chill, the next topic I want to talk about is exploratory development.

As I have mentioned before, my focus is mainly on exploratory endeavors and a constant need for growth, learning and the pursuit of answers. While meticulous planning, regular presentations and development meetings have their place in a business environment, they are first and foremost inventions of workflow management and accounting for paid labor time. This makes sense from a managerial standpoint: when you and your team are working in the dark, dust-filled depths of a museum-quality piece of software made up of billions of lines of legacy code written over multiple decades, you can’t simply take your subordinate’s word that “oh yeah I’m totally working on some obscure part of the code over here and they probably won’t be very noticeable changes though it has to be done for maintenance purposes.” Rather, if you lay out in a meeting exactly what needs to be done and how much time will be spent on it, then at least it will be a little harder for him to get away with getting paid to zone out in his cube and check his Facebook page most of the week.

However, in a scientific context, these tools are almost inapplicable: someone who has never written a shader before has absolutely no idea how long it will take them to write a shader. Someone who has never done any procedural modeling can only wildly guess at what subtasks that work entails.

Furthermore, science and exploration necessitate iterative development. When new information comes to light, it invalidates old assumptions. It requires us to start fresh rather than stubbornly trying to push an old creation forward with reluctant nips and tucks.

As the saying goes, “failure is the mother of success.” Airplanes have round windows because we noticed that the square ones had this odd tendency to crack and break at the corners, and eventually the designers realized “oh, it’s because square windows don’t distribute the stress and forces evenly and more of it ends up in the corners! Let’s try round windows instead!” Alternatively, engineers of the past could have just said “well, okay, so square windows are bad for planes, but we’ve already spent the money and time building them with square windows. Can’t we just reinforce the corners or make the passengers sign a waiver or something?” But to do so would have been a rejection of the opportunity to learn and grow: the chance to aspire to something which is greater than the original idea and therefore must lie outside the scope of the original plan. The goal of exploration is discovery, and discovery merits change: it requires us to enthusiastically give chase to the unknown rather than sulking in place and trying to make due with what we already have.

Case in point: I have been working on a mechanic in my game project that allows the character to grab objects in the environment, pick them up, store them away in an inventory and then throw them later. Designing an algorithm to procedurally animate the object pickup was difficult, but I was successful. However, one off the first problems that became apparent was that if the character tried to pick up a very large or oblong object (such as a stone pillar or a lamppost) he would inadvertently whack himself with it in the process, causing himself to  go flying backward.

I was able to solve this by disabling the object’s collider once the character began to pick it up, but then another problem came up: with the collider disabled on the item, when the player throws it the projectile will just pass through everything. Obviously, I needed to re-enable the collider once it was thrown, but now we have the converse of the first problem: when throwing a particularly large or oblong object, the item will either hit the player as it appears or even worse, the item will clip through the ground or the structures around the player when it appears and get stuck in them.

I now know that I need to add some kind of functionality to calculate the dimensions of each object that is picked up and adjust its position and orientation accordingly once it is thrown from the player’s inventory. Encountering this problem myself has also made me realize that this issue is the reason why most throwable pickups in similar games tend to be regular in size.

Sure, if I had known this in advance, I would have been able to build a better algorithm from the start, but how could I possibly have known without having tried before in order to make that discovery in the first place? Encountering this amusing problem represents a setback in terms of meeting the project deadline, but it’s also an important step in my growth as a developer.

[niarlat]

Art Before Marketing

We read a presentation from GDC in class by one Richard Lemarchand of Naughty Dog. It was called “Attention, Not Immersion” and while I will not recapitulate my essay response here on my blog, I do want to bring up a point that this paper finally convinced me I needed to discuss: the relationship between art and business.

When trying to make a living by producing art, there is of course a need to perform some degree of social interaction with other people so that they will be introduced to your art in the first place.

Note that this does not necessarily mean aggressive marketing or advertising or sales pitches or setting up a kiosk and pointing at random passersby and shouting “YES, YOU THERE! YOU LOOK LIKE YOU WOULD ENJOY THIS GAME I’VE GOT RIGHT HERE AND THE DEMO IS FREE!” Human beings are very social creatures, and when we find something we enjoy, we naturally want to share it with other people in our lives. As the saying goes, “Joy shared is twice joy”. That happiness and sense of wonder we feel on discovering something we like is increased even further when we share it. For example: “Guys! Guillermo Del Toro made an american movie about mechs fighting giant godzilla-style monsters and it’s totally awesome and he actually uses the word ‘kaiju’ in it!” or “Guys! There is this awesome fruit called a Miracle Fruit and when you eat it some of the receptors on your tongue are temporarily blocked so that your perception of taste changes and when you eat a whole lemon or a lime it tastes very sweet and not sour at all it’s amazing!”

You get the idea: if people like your work, then it has the ability to naturally find an audience by being shared in this way. You do not have to expend any effort to forcibly push your work onto people, and with the incredible amount of connectivity we have through the internet this natural sharing is even more powerful. I was caught in a hurricane of Undertale fan art and Let’s Plays that led me to discover it for myself: I never saw the trailer or any ads until I went directly to the Steam Store page myself to add it to my wishlist.

In contrast, the idea of “selling yourself” is a smoking hot topic in the job market these days. Interviewers will expect you jump through hoops, take tests, fight gladiatorial battles against other applicants and toss out resumes, business cards and portfolios like a ninja throwing deadly, papery shurikens to convince them to pay for your work.

But none of that necessarily applies to art: I did not read The Hobbit as a child because I saw a commercial with JRR Tolkien pitching it through a catchy song. Robert A. Heinlein did not find me through my demographic information to tell me that Stranger in a Strange Land would be a perfect thought-provoking novel for me to read in my young adult years. I did not read Hitchiker’s Guide to the Galaxy because Douglas Adams designed Arthur Dent to be a relatable protagonist for American middleschoolers. I read all of those books because people in my life had read them and been truly moved by them, and they naturally recommended them to me. They represent earnest, sincere expressions of their creators’ thoughts and feelings for their own sake, not cheap marketing ploys.

You can design a product for the sole purpose of making money, and to that end craft it in such a way that it will grab attention easily and spread quickly through the largest possible audience. But art is a medium of expression and communication, and if your strongest feeling as you create it is “I want to make a ton of money!” then that is the only sentiment that will come through to your audience.

Make your work more than just a cry for attention: take a part of yourself and share it through your art. It may take a little longer for it to spread naturally, and not everyone who sees it may like it, but one way or another your art will expose people to new ideas and feelings, your ideas and feelings, and this experience will challenge them to think about your work, will encourage them to reconsider their own thoughts, and will cause them to grow, if maybe only a little, from this exchange with you.

[niarlat]

Finished at last! My groupmates Sarah and Tess did all the art for this project, I just did the scripting for the movement mechanics and random spawns and whatnot.

This game turned out magnificently thanks to my groupmates’ hard work and I daresay that lighting effect looks cooler than when you get a star in Super Mario Galaxy!