Little Coding Fox

Random stuff #1214141412

2011-12-19T20:44:00.000Z

Something I implemented a couple of days ago while my net was down, based on some readings from Game Engine Design by Jason Gregory (http://www.gameenginebook.com):

Basically what I did there was add three differently colored lines pointing in the direction of each Coordinate Axis (X, Y, and Z). This is the basis for Debug Drawing, which is an amalgamation of techniques that allow a developer to verify why something is behaving differently than it should.

For instance, let's say that your character is shooting oddly. You could draw a line from its position towards the direction it is pointing at to verify what exactly is happening instead of just reading some confusing debug values or trying to figure out why your code is not working properly.

This is only a simple example, of course, but it is nonetheless very useful.

Fling for Android released!

2011-11-29T20:45:00.001Z

That's right, after a little over 9 months of work, Fling for Android has been released at last.

Right now you can't find it on the market without a direct link, since it was released just a few minutes ago, so you can find it at http://bit.ly/sd8bpO

Here's a youtube video on how the game is played:

Game Design Fragments: Layered stats

2011-09-27T15:46:00.002+01:00

DISCLAIMER: I'm not the best game designer out there, however I often come up with interesting ideas. I don't mind if you take an idea of mine and use it in a game of yours, however I'd love to know of any games that use any of my ideas. A credit line like idea based on the thoughts of Nuno Silva (Little Coding Fox)" would be nice too, although it is not required. I hope you find this information helpful.

Layered stats

We could have layers of stats, instead of the usual RPG stats. For instance, having a high confidence stat should increase both agility, precision, and speachcraft. So you'd have on the top layer, "Confidence", and on a lower layer "agility", "precision", "speechcraft".

Increasing a stat would automatically increase the upper stats related to it (so increasing either agility, precision, or speechcraft would increase Confidence too), and increasing a upper stat would increase all lower stats. (If you're confused by what I said, upper/lower means higher layer / lower layer)

This is interesting because increasing a lower stat would increase the upper stat, but would not increase all other stats of the same level. So the most expensive equipments for role playing games with this kind of stats would be those that increase the top-most layer, since it would increase all other stats.

Stuff I've done at CandyCane LLC

2011-09-02T13:01:00.000+01:00

Figured this would be useful somewhat, especially as a way to see what I've accomplished so far at my job...
I'll be updating this from time to time, since I can't remember everything I've done so far.

Not Platform Specific

Developed a CRC32 generator for unique IDs based on a string's data, more often used to save time when using Maps or to generate a unique ID for a game object
Developed a drawcall cache that caches several similar drawcalls and then draws them when a call with a different texture/blending mode is applied

iPhone

Developed Facebook, Twitter, and E-Mail support to Fling
Developed a custom Sound Engine supporting sound and music streaming, self-repeating sounds, music cross-fading, among other misc features
Implemented AdWhirl ads on the free version of Fling

Non-iPhone

Reimplemented native widgets like Text Fields and Alert Views to either a custom OpenGL implementation or the native equivalent of the targeted platform
Reimplemented large platform-specific parts of the CC codebase, like the OpenGL implementation, sound, file access, among other low-level code, from iOS to the targeted platform.
Developed a custom libPNG image loader that supports Grayscale, Gray-alpha, Indexed, and RGB/RGBA images, processing RGBA images so they had their alpha premultiplied.
Developed a custom FreeType text renderer that takes care of properly converting UTF-8 to UCS-4 in order to not only render high-quality text to existing bitmaps, but also to render unicode text properly. This renderer also formats the text accordingly so the game only had to send a blob of text and the maximum bitmap size to format and the formatting type (Characterwrap, Wordwrap, truncation, etc)
Reimplemented SFML's HTTP client to use non-SC++L code, since SC++L code of any kind would crash on Android, and used it to query the CC server for statistics purposes

Android

Partially (as of this post's original posting date) ported Fling to Android
Implemented AdMob ads and Tapjoy Offers for Fling Free
Implemented in-app purchases
Developed multiple java "gateways" to save RAM and allow the C++ side of the game to take as much control as possible.
Implemented screen scaling so the game works on all screen sizes.
Due to a lot of problems with the Android platform and Native Code, had to debug most things with no debugger, or at the very least, a print-based debugging session (that is, no debugger, just printing values from relevant variables or states)
Implemented app licensing and obfuscation of java code
Implemented a common java library used by all versions of Fling based around a base class that handles communicating with the native C++ Fling code and several Feature Sub-classes that implement features such as Admon Ads and in-app purchases
Implemented save file transferring between free and paid versions of an app
Wrote an app that can gather a user's adb logcat without that user having an SDK

webOS

Ported Fling to webOS
Partially ported Fuzzle to webOS
Developed a SDL_ttf Text Renderer (later superseeded by a FreeType Renderer I also developed)

Special Delivery

2011-08-31T22:36:00.002+01:00

I was looking through some of my mediafire files, and noticed an old not-so-stable version of some tools I developed for WorldBase. Those of you who have been following this blog might recognize them as the material editor, the model converter, and the world editor.

Since I ended up dropping it in favour of making the game on a stable game engine so I wouldn't get lost on the technology, and since I broke it all in the end (so I can't get you any code), and since I noticed that even if it was never completed, it was still pretty cool, I figured you guys might be interested in trying it.

Download Link: http://www.mediafire.com/?gmmyvkoykmn

Some Guidelines:

Some elements were never completed. For instance, some nodes on the Material Editor can't even be created, and the Light entity on the World Editor will crash the editor since it was never implemented.

Before you do anything, you need to keep in mind that all tools require the Core.package file which is generated from the BuildPackages.bat file in the System folder. Whenever you add/remove/modify a resource like a model or material or texture, you need to call BuildPackages again.

Material Editor:

In the Material Editor, you can drag nodes from the node list to the middle of the screen that has other nodes.

You can middle-click-drag on that area to move the working area too, so you don't run out of space.

To delete a node, select it with the left click and press DELETE on your keyboard.

To make nodes work with each other, left click on a connector (the black squares) and drag towards another connector (Node Inputs are to the right, Node Outputs are to the left, you can't connect one kind with the same kind). This will create a Connection between the two nodes.

To remove a connection, you must left click the connector while pressing CTRL. It may not remove it immediately, so try clicking a few times. This is a bug which I probably solved later on but I can't recover it right now.

Constants are the most used datatype. They come in four flavours: Constant, Constant2, Constant3, and Constant4. Each can keep a certain amount of values. Most Nodes provide a certain datatype as their value, like the Fresnel node which returns a Constant, and the Normal node which returns a Constant3.

Sometimes you will get errors, like incompatible data types. For instance, you can't LinearInterpolate a Constant as the first value with a Constant2 as the second value, since they are different data types. You can get over this by converting from a data type to another. This is usually only possible when you convert to a higher data type.

For instance, you can't convert from a Constant2 to a Constant. However you can convert a Constant to a Constant2 by e.g., setting a Multiply node with a Constant2 with values R: 1, G: 1 to multiply by the Constant you want to convert. In this case, you'd set the Constant2 as the "A" input, and the other Constant as the "B" input.

The TextureSample Node allows you to select a texture from the package filesystem. It has 4 Outputs ("Black", Red, Green, Blue, Alpha). The first output is a Constant4, while the other ones are all Constants. This allows you to extract the components of the texture for various uses.

An example would be if you had a "filter" texture and two other textures who you want to combine. You could use a LinearInterpolate node to interpolate between the two textures, and use the filter's Alpha component as the last input to LinearInterpolate to do so.

Model Editor:

In the model editor, you can import bXporter models or modify existing wbmodel models. Do notice that I don't remember which version of bXporter I used, and I do know it's not a very popular format, so you'll have to make do with the .bx models on the System folder.

After you convert or open a model, you can swap the Z-axis of the model (if it's showing improperly rotated for instance), and change its size.

Mind you that changing its size is not the same as performing a scale to the model. It'll literally make the model be at most have a height of X units.

You can change the materials of each mesh of the model too. To do so, click on a material on the list and it'll highlight the area the material belongs to in yellow. Double-Click it to choose one of the materials on the Package Filesystem and then double-click that material to replace the first material.

World Editor:

This is probably the most complex tool of them all. First, you should either open an existing world or create a new one. When you create a new one, you should choose a relatively small amount of sectors. That is because each sector contains a huge area.

After you create a new one, please wait patiently until it is done processing it. It will randomly generate the world's terrain and calculate the world's pseudo-average normals for lighting (this last part might take a while, however generally speaking on any decent computer it shouldn't take longer than a couple of minutes.

Afterwards you can move around the world, use the terrain tools (Raise, Lower, Flatten, and Paint (Paint was never implemented)), you can even create your own entities and spawn them in the world.

Mind you that the default entities (Light) are not implemented, and trying to use them will result in a crash. You can create new entities, although a lot of entity settings (Like having Physics and Client/Server ownership) do nothing since I never got to implement them. You can select a model, and then save the entity library and use it within the world. Other than that you can also browse the world around.

The viewport controls work as soon as you left-click once at it, so the viewport will gain Focus for your mouse input. Then you can hold the right mouse button to do mouse look with the camera, and use the left mouse button to use whatever tool you're using at the time.

That should be enough detail for now. I've delayed this post long enough. Remember that this is not a production-quality release, I'm only releasing it now because, although incomplete, it is "cool".

UDK Adventures #1

2011-07-18T10:43:00.002+01:00

I was playing with the UDK yesterday, making a fancy C++ DLL. This has been the 3rd time that UDK behaved oddly.

First it exhausted all my free RAM (That's over 4GB of free RAM out of 6GB) just trying to compile my scripts to use the DLL. Then it kept compiling forever without increasing much RAM. All this for a piece of 100% completely valid and completely logical code that had no way to cause any potential bugs at all.

Like I said, this already happened at least 3 times. It makes no sense at all how these issues happen, really... my first time it would say it can't Bind to the DLL, and the reason was that my DLLMain function did not return a value.

What the hell, man?

Android Adventures #2

2011-07-03T21:39:00.006+01:00

Here are a few more issues I remember having while porting Fling to Android (Note: When I refer to java code, I mean Android Java-specific code):

Optimizing the code with the compiler (e.g., -O1/2/3) caused awful graphical corruptions (see http://i51.tinypic.com/raqogl.png for a sample). Solution: Use vs-android and enable compiler optimization flags for certain files you figure could have something to do with it (e.g., your texture loading / resource loading class. You may even have to split the offending files so you can keep non-OpenGL code optimized.
The Java VM has a limit of 16MB for the Java heap, while the native heap has no limit. That means that for any minimally sophisticated game out there, you'll have to use the Android NDK to make a native binary while using java to access the Android APIs.
The file management APIs don't have any way to get the size of a file or seek it. This is especially bad for Asset files, which are resource files bundled with your package, since those are encrypted. So you have to read each file you need in chunks until you get a EOF flag while reading. In fact, there is an available() method that will return the total amount of bytes you can read until it "blocks for more input". That means that it can return 0, 1, 1234, infinite, etc. See http://developer.android.com/reference/android/content/res/AssetManager.AssetInputStream.html#available%28%29
(@#2 and #3) Because of these two problems, when our native code needed to read a resource file, I had to read the file to a java byte[] array, pass it as a buffer to C++, and then use a hackish way to change our File class's implementation between a resource file and a regular file since regular files didn't need to go through Java.
Java code sometimes doesn't behave in a standard way. An example of this would be when I created a texture through Java and used glTexImage2D, so I wouldn't have to compile libPNG and zlib statically with our bin. It would always fail with an INVALID_VALUE error. The documentations say that INVALID_VALUE only happens when width or height are < 0. The very same code, in C++, worked with 0 GL errors.
I had to load the game in a separate thread, not only because it could take a significant amount of time (On debug anyway), but also because a black screen for more than a second can cause any user to quit the app. The fact that the OpenGL thread is not on the main thread due to the way the GLSurfaceView class works didn't help either. So I had to make a proxy to properly init textures, and to draw the loading screen.
(@ #4, #5, #6) Because of all this, I had to severely modify the way textures are loaded and ended up doing the following when a resource file was required:

Java reads multiple chunks into memory while keeping a huge-ass buffer (e.g., 5MB in size) to prevent reallocs (this happens with any resource file request)
Copy the resource data to another array to prevent potential overlaps of read/writes through threads (Only copies actual data, not the whole 5MB buffer)
Copy the java resource data array to a C++ array
Free the java resource data since memory is of the essence
Decode the resource data with libPNG
Save the bitmap data, verify whether we're starting up (e.g., not on a GL thread), if so, queue it for init, otherwise init it now
On the GL thread, at the beginning of a frame, for each texture queued up, init it.

The Emulator runs at nearly 1 to 10 FPS most of the time. On a Core i7 2.80GHz computer. In fact, it will not run Fling, and will in fact freeze (as in, actually freeze, not give a "App not responding" Android warning when an app doesn't respond) and/or crash.
Installing the app packages takes over 2 minutes on the emulator (60KB/s), while on device takes less than 20 seconds (1-3MB/s on any decent device, 4+MB on a Samsung Galaxy S makes it take less than 6 seconds).

Comics! #1

2011-06-29T20:05:00.000+01:00

So I've recently become a member of Dark Horse Comics (Digital).

They have a lot of interesting comics, although I've never been much of a comic person. Until recently, anyway. The prices are all in USD, so if you live in Europe like me, you can get bundles of 4 or more issues for little more than one and a half of the price of regular comic in your country.

But that's not why I'm making this blog post. They're having the first issue of a comic called "The Helm" for free for a limited time. You also get plenty other free comics by default when you make an account. So if you're a comic guy or you think fantasy comics might be relevant to your interest, I advise you to make an account and choose "READ NOW" on "The Helm #1".

http://digital.darkhorse.com

Android Adventures #1

2011-06-28T12:54:00.000+01:00

Welcome to my first entry of my adventures on porting games to Android. Here I'll list all the "WTF"s I got these past few months.

The NDK Debugger doesn't work with NDK-built binaries (states various section-related errors). Use vs-android.
The NDK Debugger can't trap startup crashes on native code. Instead the app will restart over and over before the debugger attaches to the process.
Sometimes when the app crashes and I'm debugging without a debugger, the crash dumper crashes halfway through.
A simple stack overflow on layout crash causes the adb server to die. Gotta reboot. The only way to figure out why it crashed is to dump the adb logcat to a file before it crashes.
Including a single line of SC++L code will cause the app to not start at all, crashing at some SC++L-related code before any other code is even ran (initializer-related, probably). Solution: Don't use the SC++L.
Sometimes the addr2line program will give you an erroneous filename and line (e.g., TwoPlayerGame.cpp:0). Solution: Run addr2line with -C -f -e. It'll show the function prototypes.
Half the time GLSurfaceView will overlap any other views, no matter what layout you use.

I probably have a lot more issues to report, but it's been so long I can only remember a few.

Life stuff #1.#inf

2011-06-09T09:39:00.000+01:00

Today is my birthday. I'm 23 now, but life just feels more and more tireing no matter how much effort I put through.

At least today I'll have some fun with a couple of friends.

Cheers!

Life Stuff #25235252 million

2011-06-02T10:22:00.002+01:00

Sorry for the lack of updates, I've been very busy lately, and hardly had any time to do anything other than my full-time job.

Lately I've been working on a fancy pants universe around two characters, Anthe Ringwarden, Paladin and Zero, the Life Sculptor. Here's some concept art on them by SupaDave:

Other than that I've been very busy with Fling for Android and Fuzzle for webOS. Android has so many problems I have no idea how they even accept this kind of problems. But it's popular, otherwise we'd probably just have given up on it. Le sigh.

Also, I've started using my twitter for a change. Check http://www.twitter.com/LittleCodingFox .

Cheers.

Random Stuff #1

2011-05-09T11:26:00.002+01:00

When women need comforting they tell you it's time to go buy shoes
But they already have all the shoes!
So you know they actually need boots.
Now everything makes sense. Forever.

Ramblings #1

2011-04-07T17:41:00.002+01:00

This is a transcript from when I posted this on my gamedev.net journal:

Disclaimer

I'm sure most of you will disagree with my views, however please don't think of me as someone who is saying "I'm totally right, everyone else doesn't know squat", since these are merely opinions.

Happy birthmas!

So I've finally created my GDNet journal. Took me quite a while, too! I hope to be more active around here, as well as in my blog.

I've been working for a living as a game programmer for CandyCane LLC, a small smartphone game studio who has been producing a few games mainly for the iPhone, and more recently for HP Palm's webOS, Android, and Windows 7 Phone, where their probably most popular game is Fling, a game where you "fling" various game pieces so they bump and send each other out of the board until you get only one left. I've been working for them for exactly one year now.

It was a rough year, especially since this is my first job in the industry and I am still kind of a rookie, even though I've been programming for almost 11 years now. My biggest challenges so far have mainly been the game ports from iPhone to webOS and Android, but I'm getting better so it'll probably stop being such a challenge in this upcoming year of work.

Although my dreams of making awesome evolving 3D worlds, a project I called "WorldBase", have been delayed because of my job, I'm hoping to restart working on it in a few years when I have plenty more available resources and thus more security for the entire project, in order to prevent it from failing once more.
Learning how game technology works is very importantBut people tend to end up trying to make their own 3D Game Engine in the end. This is often a bad idea, especially nowadays when we have the UDK and Unity available free-of-charge.

Spending too long developing game tecnology is a curse you can't escape from

After you've learned how a large part of game tecnology can be developed, you start to feel picky when trying to select a game engine for your projects. That's mainly because you end up developing your own "style" and since all game engines are developed in different ways, with many different tools and interfaces, you will end up disliking them all, leaving you to make your own, once more. This is even more of a curse than most people expects, since you can start a project thinking "I'll make a simple basic game engine" and spend years working on it without realizing you're spending too much time on the tech with little of the game to show.

A lot of commercial game engines out there that are geared for Indies are not that great

Everyone loves talking about Torque, Unity, UDK, C4, etc. But fact is that some of those engines have less-than-friendly Indie licenses or are apparently not very good. As an example, I ordered Torque 2D when GarageGames was reborn and started selling all their products for $99 with Source included. I saw their License, and after posting a thread in their forums, they said the following:

@Nuno - The license allows you to use a copy of T2D for your own development. If you want others to help you in development, such as writing code or creating levels, they will each need a license. Anyone touch the editors, TorqueScript or C++ needs a license. If you have an artist that just creates the sprites but just hands them off to you, never touching T2D, then they do not need a license.

Make sense?

Well, this is horrible from an Indie point of view. Often Indies will have more than one programmer, and spending twice or more of the original license makes the whole thing incredibly expensive. Indies don't always have that much funding, so just getting $99 is quite a feat. If you get a SVN server for your project, which will include torquescript and maybe some C++, even if your artists don't use the SVN directly, you have to spend those $99 once more. Imagine this when their $99 promo goes back to the old price which is probably more than twice as expensive.

The worst part is that it seems that a lot of asset producers seem to be limiting the number of persons that can have access to purchased assets to one, maybe two persons, and the real world just doesn't work that way. In a world where websites like xp-dev.com and assembla.com provide free file versioning services like SVN and GIT, the ammount of people who have access to a SVN server is generally everyone who is part of the group that created the server. So what can you do in order to keep everything A-OK? Create a separate SVN server? Remove access to the SVN from most team members?

Often you'll also find engines that look great, but once you try their demos or look at their samples you notice how they're not something you'd enjoy using. A couple of examples would be C4's engine demo, which although looking pretty sweet, has horrible physics, and the Leadwerks engine's API, which is just ugly.

Now, I don't know if the developer who created the C4 demo just wanted to setup the demo's physics quickly, but trying the demo made me not want to get the engine at all. The biggest demotivator was when i tried to climb some stairs. I'd get stuck, press SPACE constantly in order to jump, and more than often I'd jump backwards somehow, causing me to have to painfully climb those stairs all over again.

It's really hard to manage a team even if there is genuine interest in a project

Yes, it's true. I've created a small Indie team called Flaming Torch Games, and even though we were getting some great progress on our first project, a game that we codenamed "Rectangle Bejeweled", the project is slowly dieing as I speak, even if there is no proper reason for this. Most of the team never communicates with each other, no matter what I try to get them to do so, and some people have barely done anything so far. The problem with internet teams is that they often forget about the team and often get busy with things in real life that will make them unavailable pretty much all of the time. The main problem is that most people just go "hey, that game is cool" but don't want to do any work or just lose interest because it's "a lot of work". However, when there are people actually trying to be productive for the team, they are still very busy, often with their full-time job. Bottom line is, people are very busy, so unless you hire them yourself you'll need a lot of luck to have an indie team that works.

3D games need a team, stat

Often you'll see someone single-handedly trying to make an awesome 3D game, maybe even attempting to do something really "simple" like a character moving in a small chunk of land with some buildings around. However, what I've noticed the most is that that's just not possible to do all by yourself. You need external resources, mainly art, since a programmer is often not an artist and free 3D models only get you so far. You also can't just make some simple textures for a 3D game to behave as "programmer art".

One Year at CandyCane

2011-03-24T12:00:00.001Z

Today marks the day when I signed up to become a working citizen in my country so I could work for CandyCane. It was a rough time, things could have gone better, but hopefully this next year will go better.

To end this post, here's a dropbox gallery with Work-In-Progress screenshots of Fling for Android: http://www.dropbox.com/gallery/872159/2/CandyCaneWIPs/Android?h=0c4dc4

Behance Portfolio added to the blog!

2011-03-07T20:02:00.001Z

So after months of idleness I finally decided to make a Portfolio at Behance. You can take a look at it on the Behance Badge on the top left corner of the Blog. Let me know what you think!

Game Released - Fling for Palm webOS

2011-02-22T17:52:00.002Z

My port of Fling for webOS has finally been released! Here is the description as shown in the appstore:

The puzzle-sensation played by millions is now available on WebOS!

Featuring 10,000s of unique puzzles, such that no two puzzles you encounter are ever the same, and split into 30 levels of increasing difficulty, Fling! guarantees you many long hours of puzzling fun!
Each puzzle has a single, unique solution, and is solved by simply flinging (pushing) the furballs, and watching them bump each other off the edge of the screen, until only one is left. Four different game modes are provided:

FREE-PLAY mode - play at your own pace and difficulty, while the game tracks your stats and keeps track of all puzzles solved/failed, allowing you to browse your entire puzzle-solving history, and go back to any previously solved/unsolved puzzle to attempt to (re-)solve it!

ARCADE mode - race against the clock, solving as many puzzles of ever-increasing difficulty as you can before your time runs out!

CHALLENGE mode - solve sets of puzzles within a given amount of time to progress, while trying to beat your personal best times for each level!

FRENZY mode - add a whole new twist to the classic gameplay. Suited to speed addicts - instead of solving puzzles, you just need to keep the board clear as new furballs are continually added!

OTHER KEY FEATURES:

HINTS and UNDOs are provided to help you solve the puzzles when stuck

Original game music

Local+Global high-scores lists

Automatic saving of games - always come back to the game right where you left it!

"genuinely addictive ... replay value is incredibly high ... a polished, simple and engaging puzzler" - ztgamedomain.com, 8.5/10
"simple enough for a child to pick up and play, yet challenging enough to keep adults hitting the Undo button and trying again" - appsmile.com, 5/5
"slickly presented, fiendishly addictive and hugely popular puzzler" - gamepeople.co.uk

Here are some links:
http://developer.palm.com/appredirect/?packageid=com.mbgames.fling&applicationid=7669 and
http://itunes.apple.com/us/app/fling/id325815008?mt=8

Game Design Fragments - A new magic system

2011-01-28T19:50:00.002Z

Hey there. I was considering posting about this for a while, and felt that I might as well make some sort of semi-regular game design series so the blog gets more frequent entries.

DISCLAIMER: I'm not the best game designer out there, however I often come up with interesting ideas. I don't mind if you take an idea of mine and use it in a game of yours, however I'd love to know of any games that use any of my ideas. A credit line like idea based on the thoughts of Nuno Silva (Little Coding Fox)" would be nice too, although it is not required. I hope you find this information helpful.

An user-generated magic system based on fragments

Most magic systems used in a wide variety of games, mainly role playing games, use a skill-based and level-based system to both deliver and improve magic powers to their users. Although this has proven to work well for years, some improvements are due, since the same formula has been used time and time again, and tends to become old.

Essences

Essences are fragments of an effect. They have a certain kind of nature (as an example, the 5 colors of Magic the Gathering cards), which defines the "spirit" the player must enforce upon themselves as to be able to recreate the essence.

Essences are connected together in order to craft spells. Depending on the ammount of essences, the spell becomes harder and takes longer to cast. Each essence has a chance to fail, and if any essence at all fails during the cast of the spell, the spell "counters itself", potentially giving out a negative effect to the caster depending on how dangerous/powerful the spell is.

Essences put together with incompatible natures have a higher chance to fail when being cast. An example of this would be having Black and White natures next to each others on the spell.

Essences may have limited positions when being crafted. For instance, you may want to balance damage-dealing spells so that a player can't add three "Lightning Bolt" essences in a row, which may be overpowered in your implementation.

Essences may have parameters, which enhance their usability and as such make spell crafting both more fun, more complex, and more interesting. An example would be a Fireball essence which has a slider that allows the user to define the intensity of the Fireball. A lower intensity has more chances to succeed while a higher intensity has a higher chance to fail.

You may also add some form of unlocking of essences to your player. Instead of unlocking entirely new spells, you'd progressively e.g., offer a chance to gain a new Essence based on a battle with a particular enemy. This way, each battle would be a different experience and have different rewards based on a form of an item rolling system.

Conclusion

This concludes this game design fragment. As you can see, this system has the potential to become quite fun when properly implemented, and to provide an experience never before seen in a computer game.

Crap, time sure moves fast

2010-12-20T11:28:00.000Z

I thought my last post was more recent than this. It's been almost a whole month! Sorry about that.
I was unable to check whether there's any serious problems with me, however in about one week i'll be able to go to the doctor (finally!), so i'll finally see if there's something wrong.

However, as of lately i haven't had any more issues with my heart, so it might have been a one-time thing. That repeated 5 times during the night. Yeah...

Now on for some good news! I was accepted into the Age of Empires Online Closed Beta! I cannot give any details, what with it being a closed beta, but i can tell you that so far it has been fun and very similar to age of empires 2's gameplay (which is great to most people).

Also i'm currently struggling to get Fling for webOS out the door, since it has terrible performance issues at the moment, even though the Palm claim that the device i'm building for (Palm Pre Plus) has the same processor as the iPhone, yet the game runs just fine on iPhone but not on the device. Heck, while running on Windows it runs blazing fast!

My time at CandyCane has been a mix of good times and not so great times, with days often filled with lots of pressure due to mistakes created by me due to poor education since i'm 99% self-taught. At least i have a great boss and colleagues!

Well, that's all for today. Hope you guys don't mind the irregular updates. Cheers!

What the HELL, body?

2010-11-29T10:09:00.000Z

I dont know what the hell is going on but lately i've been in need to go to a doctor due to massive stress being randomly dispensed upon me for no good reason, all my teeth are getting out of place due to wisdom teeth growing, and today i had at least 5 instances of my heart aching a hell lot during the night.

If i dont post within 3 months i'm probably officially dead in real life.

Life updates Pt. 1

2010-11-23T16:44:00.000Z

So hey, new post after how many months now? 5? Wowzers!

WorldBase has been temporarily put on hold. Why, you ask? Because not only does my job take a lot of time from me, but also because i need to rewrite WorldBase from scratch following on the teachings of Game Engine Architecture by Jason Gregory, which is a big step forward since i used to just make stuff up constantly which kept situations like "oops, everything is working very badly so i gotta rewrite".

Of course you might be asking, "why not use a premade game engine?". There are plenty of reasons why i dont do that. The main is that WorldBase needs to include a custom-made world editor so users can create their own worlds without using an overly complex game engine editor which gives you plenty of unnecessary steps both while using said editor and while configuring everything for the game to recognize the world properly.

There are other reasons, such as that most free and some pay-for middleware tends to either have a bad license (GPL-ish), or not work very well at all, or just have obscure bugs and crashes from seemingly very simple things.

I've also recently formed a small game development team to work on a couple of casual games. I won't spoil it for now, but hopefully there'll be a private beta of the first casual game, where i'll post a few keys on a few places like this blog for you. Mind you it's a casual game, so don't expect fancy 3D things.

Outside game development, i've been playing World of Warcraft, Team Fortress 2, Dungeons and Dragons Online, and the newly released Poker Night at the Inventory. I've also been randomgifting steam games to friends. Ain't i in a jolly christmas spirit?

There's not much else to talk about... I'll try to post more often, though. Hope this post wasnt too boring for ya though. See you around!

WorldBase Progress Pt. 39

2010-07-05T18:51:00.000+01:00

Sorry for the lack of updates.

I've been having a hard time fixing a bug with WorldBase, trying to optimize it as much as i can to prevent waiting 'till forever for some resources to load or having epic slowdowns while they're loading. Mainly i'm using a separate resource thread now.

A thread lets you split your program into two or more (one per thread, we start with the main thread), and threads share data. However, sometimes threads read and write at a memory area at the same time, causing memory corruption. So there are ways to synchronize threads, although those ways aren't easy as pie.

So basically i'm having races for control for each thread, which makes them wait too long to do stuff, so e.g., something that should take less than 10ms may take over 2 seconds to complete.

Multithreaded programming is really hard, thus why i haven't been able to fix it yet. Stay tuned for more news, hopefully i'll fix it this month.

WorldBase Progress Pt. 38

2010-05-23T00:24:00.000+01:00

Here's a sneak peek on the new features on WorldEdit:

WorldBase Progress Pt. 37

2010-05-11T21:44:00.002+01:00

Well, wasnt expecting to post twice in a row today, but this is too good to wait a few weeks before i show it.
Here're some photos from me presenting my work on WorldBase at the Inércia 2010 Demoparty that happened two weeks ago. For all photos taken there, go here.

On what exactly WorldBase is...

2010-05-11T20:54:00.000+01:00

I figured it'd be nice to have a bit of a sum up of what exactly WorldBase's genre is and how the game will be played.

WorldBase is a Party Online Role Playing Sandbox (PORPS). What this means is, it's a role playing sandbox for a small ammount of players. A good example of what i mean by "small ammount" would be 1 to 4 players. It also means that you'll be able to play it alone.

And now for how the game will be played. Mainly, you select a world, and you'll be able to select one of the playable species and a starting point. While you're doing that, each starting point should already have quite a lot of Beings doing various things, and you'll be able to select various Goals to do, learn new Technologies, among other things. Putting it in fewer words, you'll help the World evolve.

And that's pretty much it. Maybe when WorldBase is further into development i'll be able to provide a better sum up. Hope you guys don't feel disappointed by the lack of juicy information on this post. Stay tuned for more progress reports sometime soon.

WorldBase Progress Pt. 36

2010-05-03T12:45:00.003+01:00

Presenting: Entities!