Date: Apr 26, 2009
Screenshot #1: Bugs! I hate those creepy crawlies! Oh, wait, wrong kind of bug! I'm referring to programming mistakes. This is a typical class 3 bug. Normally, the clouds are supposed to be seamless, not mixed up and scattered in such screwy ways. The problem was that I had the wrong sorting order. Instead of going A to Z, I had it going from Z to A. This is the first stage of development. The debug panel is used to show the current values of various variables, for monitoring and bug-hunting.
Date: Apr 27, 2009
Screenshot #2: This was difficult. The centering wasn't working properly (class 2). I had the rather common class 1 "the one-frame delay" bug with the cloud deck above, and there was this strange "missing row" at the top of the screen (class 1) that I couldn't figure out what was causing it. Fixing bugs, even class 1 and 0 bugs, is part of software development. It all started with the getting high videos for Jumping Flash 2 (where I max the height). I soon had visions. The vision was that, at the very top of the screen from the 0 position (shown here), the clouds should have a scaling of 128. Scaling you might ask? Scaling is essentially the size and distance of an object. Each scaling unit's distance varies depending on the field of view, but this game uses 100 feet for each scaling unit (there's a fairly advanced formula using a tangent to calculate this). Double the scaling means the object appears to be twice as far and 4 times bigger (by area). A scaling of 128 means it's 12,800 feet (~2 3/7 (~2 5/12) miles)), from the "camera" straight ahead to it (ignoring the left/right and up/down offset). I match this vision precisely.
Date: Apr 27, 2009
Screenshot #3: Questioning on memory usage and the number of colors for the platforms, I found that using 125 colors was the best, but it meant a lot of work in the code... until I remembered that you can have an array of structs, pointers, and even 2D arrays. This greatly simplified it. This may seem like an overly repetitive level, but it's not a level at all. I was testing to make sure the color-adjusting function worked properly. The goal platform, to the right, is key to completing levels. These are the so-called 1x1 platforms - they are 1 block wide by 1 block high (one block is 32 pixels). The platforms have a scaling of 1. For the clouds above, with the 128 scaling at the top, picture 4 of these platforms back to back. That is how much distance is needed to have the clouds move just one pixel! This gives a sense of extreme distance. How high are the clouds from the 0 point? Take 1536 of those 1x1's and stack them one on top of the other. Now that's high!
Date: Apr 30, 2009
Screenshot #4: Are you a collector? This is a collection of many of the game's objects put into one. Yep, testing stuff, again. On the top are the 4x1 platforms. Below are the 1x1's. At the far bottom is the goal platform, in its new, bigger form (so it stands out in the crowd, due to its importance). The other items, besides the clouds, are the first of the objects added. Hazards are the only things left out. The top row are the extra lives. They get increasingly more difficult to get and rarer as you go from left to right. The same goes for the collectables below. The collectables, from left to right, are: sapphire, emerald, topaz, ruby, diamond, gold bullion, and treasure chest. The latter is extremely rare and is worth some serious points if you find one. Below the 1x1's are the hearts. From left to right, they restore 5, 10, 25, and 100 HP. The bottom row contains the springs. As you go to the right from the left, the springs get progressively more powerful. The blue ones give a 50 mph jump, enough for 19 blocks (a little less than the screen's height). The green one gives 75 mph. The rare red one gives 125 mph, enough for 5 screen's worth of height.
Date: Apr 30, 2009
Screenshot #5: The forest world takes place high up. Note the "Y position" on the debug panel. The lowest points for levels hovers around 2048. A life if lost by falling below 1536. What's this "CU" unit? That's "coordinate units". One CU is 11/75 of a foot, 1.76 inches, or 4.4704 centimeters. It's based on my animations since 2002 - it's the distance travelled at 1 mph in one of my animation's frames (which lasts 100 milliseconds). Those hills near the center of the screen are very far away - their scaling is 256, putting them almost 5 miles away. You can tell that there is a fog bank that envelops the low-lying areas of the scenery. This is actually exactly how I envisioned it.
Date: May 1, 2009
Screenshot #6: From suggestions on the second YouTube video, and one of my own new ideas, I made changes to the icons. In addition, the lighting's ambient value went from 25% to 50%, making objects brighter overall, and thus easier to see. With the lower quality graphics, this increased lighting ambient also improves the quality a little since the lines aren't as easily visible.
Date: May 3, 2009
Screenshot #7: Oddly, I forgot to take this screenshot when I had it on May 1. This is the basic idea on what a level may look like in the game. Without the level creator, it's difficult to reliably position objects because I have to directly set positions within the code itself, rather than loading a level file that already contains this data. The YouTube video (which uses the darker version of the icons) explains the basic flow of this level.
Date: May 4, 2009
Screenshot #8: The character, whose name is currently undecided, is the one you'll be controlling. This is what things look like behind the scenes as I'm creating the character, just as I finished it. What is shown in the image window, at 16x true size, is the first frame of 2 for the waiting state. The waiting state occurs after remaining still on the ground for at least 5 seconds. The layers group shows a few others. Those blue lines are just temporary things, used to gauge the depth of water and where it'll come on the character. The brown for the ground is also temporary, also used as a reference. They are not to be included in the actual result. There are other temporary layers as well, used as templates to speed things up, and other references I could use. Behind is Windows Task Manager. Due to a class 7 bug with this program upon using the menus, sometimes resising windows, I need Windows Task Manager as quick reference to closing the program. On a single core system, it can take 5 minutes to close, and it makes Windows unresponsive due to the infinite loop GIMP has. It's a problem I've had for 2 years, since 2.2.8 was released. The Word document is my design document, used to reference what I need for the character.
Date: May 5, 2009
Screenshot #9: Stage 4 of the process and word wrap really caused a lot of problems when it came to rewriting the "DrawBMPFont" function. It was either a class 7 infinite loop bug, a class 6 stack corruption bug, a class 1 odd spacing bug, and a class 1 missing-characters-at-end-of-line bug that caused a lot of trouble. All but the second case were the most common, the latter 2 caused the most trouble. I had a series of ten tests to check every aspect of the function. All of them had to pass (succeed without problems or bugs), and if something didn't, I went back to the function, made corrections using the debugger to help find out what exactly is going on, and retry. Text, in programming, is referred to as a string, which is actually an array of variables, usually of the char type (8-bit). These are the 10 tests I had:
A simple string without spaces. This tests to make sure the text appeared on screen correctly.
A simple string with a single space. This tests to make sure spaces are checked properly, for word wrap.
A simple string with several spaces. This tests to make sure important-character-indexing was done properly, required for word wrap.
A simple string with lots of extra spaces in the middle. This tests to make sure each and every important character is indexed properly, rather than skipping.
A fairly simple but very long string. This tests word wrap to make sure it works properly. This'll make the menus of both this game and TSO easy to do, instead of having to manually add line feeds (returns).
A simple string with 5 spaces used to represent a tab. This tests to make sure I can use proper indentation, often used with both menu options and the menu help area. (yes, I know about using "\t".)
A simple string with line feeds. This tests to make sure line feeds are processed properly. Line feeds are like returns. They are very useful in many areas, even the on-screen data.
A fairly simple string with excessive spaces at the end where word wrap is to occur. This tests to make sure those extra spaces upon word wrap occurring are completely ignored. Otherwise, it'll cause the next line to have lots of extra spaces at the start, which is rather odd.
A fairly complex string that is a combo of the most important stuff. This tests to make sure everything of high importance is working properly.
A complex string that combines all elements of all previous tests. This is the ultimate test, testing everything of high and low importance. If this passes, the function is fixed. If not, it's another change.
Test case 10 is shown in the screenshot, the results anyway. There are a lot of excessive spaces at the end of the "Boy was that rough!" part near the bottom, but you don't see them, exactly as I'm expecting. The background also looks rather odd at the bottom. In this world, you're not supposed to be this low - falling out occurs below 1536 CU, not 300.
Date: May 5, 2009
Screenshot #10: With the medium-density clouds already created, and that a low-density version was needed, I thought I'd post a screenshot showing the design concept. Note the arc at the right. The 3D design of the clouds using only 2D elements isn't all that difficult for setting the sizes - it's 4th grade level math. If you double the distance (scaling), the width and height, each, must be halved. Using Excel helped me get the correct widths. Making the clouds involves 7 stages. I basically just draw the clouds at roughly a 1:1 size (this is about 1024x1024), blur them, scatter them, use the repeated scaling function, optimize them, then save them in the various zones. Lastly, I set up the variables, pointers, etc. in the program for drawing, then test them. A later screenshot shows the results.