Once upon a night

First, I believe that apologies are in order for the delay in updating. I finally got a job in a Barcelona-based studio, and I've been happily working there as a junior programmer since August :)

The rest of my daytime (and, more often than not, night time as well T_T) up until last Tuesday has been devoted to our master's final project delivery, which was presented that day on Caixaforum. 

First, a Konami exec came and gave a talk about the upcoming release of Castlevania: Lords of Shadow, developed by Mercury Steam, a Madrid-based studio, and then the 5 teams showcased their projects.

• The creature. A full 2.5d platformer game, featuring 20 levels. Your mission will be to help a creature being complete again by getting back some parts of its body, scattered around several areas.
  
• Wyverns Assault. A funny, retro-style beat 'em up game where you're a huge dragon fighting hordes of soldiers and destructing everything :-D
  
• Undertown. A graphically amazing action game a la God of War, made by just an artist and a programmer. The main character must fight the Disgusting (Asquerosos, in Spanish: that's their real name) and other monsters so he can have his girlfriend back.
  
• Ghosty Town. This game has a truly original concept where you're put in the place of a ghost that must scare the hell out of all the villagers of a small town in order to conquer it.
  

You should check them all (although some of them still lack a proper downloadable release, ours being one of them -_-U), there's a lot of work put into each and everyone of them, and the results have been really good imho.

And yes...I mentioned there were 5 teams, but only 4 projects are listed above.

So now, enter Once upon a night!

The game puts you in the place of Any, a girl (it wasn't always like that, though ^_^U) that's been trapped in her dreams by a malfunctioning magical clock. To escape and wake up again, she must find a set of gears, springs and other pieces to make it work properly again. These gears are supposed to be similar gameplay-wise to the stars on Mario 64, to name a very obvious example, as it was one of the most important references we took. To retrieve them, she'll have to solve the puzzles scattered throughout the two parallel worlds of dreams and nightmares that shape a level.

I performed tasks as a designer (well, the whole team was, actually, which is something that I now deem a terrible mistake) and, mainly, as a programmer.

Since our work tends to slip unnoticed, I'll compensate by listing the main features I wrote as a programmer. I might talk a bit more about some specific features in the future if I'm in the mood or anyone is interested. I'm sure that lots of stupid errors will be found, but that will allow everybody, specially myself, to learn from those mistakes.

- Base application engine skeleton. It consisted of a main Application class that would contain the remaining subsystems, encapsulated as independent (or that was the goal) modules to handle audio, graphics, AI, etc. After initialization, it just starts the game loop and handles input and state management, the game's subsystems being the ones in charge for updating the world and their attributes.
       
- A stack-based FSM for the game state manager. I had previously used a simpler approach for my previous games, based on IDs and an abstract factory to provide concrete implementations of the states. The stack approach has worked quite well despite an embarrassing error I detected not much time ago concerning state changes -_-U

- Event manager. A template-based approach that allowed any subsystem or the game world itself to subscribe/unsubscribe and react to specific events triggered by the animation engine, the physics subsystem, etc. Events were posted to a priority queue and dispatched at a fixed point of the game update call.

- Game entities management...partially (it was more of a joint task). This is kind of a long story: during preproduction and the earlier parts of the production stage, I had been reading several books and articles on the internet about component-based architectures and data driven design, and thought it could be nice, as it would allow to avoid deeply nested class hierarchies, deadly diamonds, and such. More importantly, we would have a flexible architecture to make it possible to define new entities without changing much code, or modifying their attributes' values without recompiling the whole project.

However, I was unable to communicate the concepts and new philosophy to my fellow programmers, and besides there were conflicts with the level loading module, so we came up with an alternate, middle-of-the-road approach that, honestly, could have been much better.

I still won't desist, though, and sooner or later I'll come up with some tests to compare the implementation, usage and ease to understand that type of architecture as opposed to the classical inheritance-based ones.

- Scripting engine. We used LUA and luabind as an interface between that scripting language and C++ to implement the following features:

* FSM-based AI-controlled entities. I believe we could have made entities a lot more script dependent, allowing them to react to state changes (for instance, playing sounds, changing animations and such) inside LUA code instead of delegating to the main C++ code, but it was
decided to leave it at that.

* Triggers. We had some entities that could act as triggers when another entity (typically, Any, but it wasn't the only one) entered/exit/was at the volume defined by the trigger. Through LUA, we could define a pair of functions condition/action, so that the logic subsystem could check if a set of additional conditions had been fulfilled (besides the enter/exit/presence checks, of course) and, in that case, execute the action function. This provided triggers with some interesting flexibility.

* Cutscenes. The in-game cutscenes in our game were also coded in LUA, taking advantage of the coroutine feature LUA provides (this was a bit difficult to understand at first). We had made available a set of exported functions (move an entity, change an animation, show a message box, etc), and then all we had to do was define the script to launch the different actions sequentially.

- Audio engine. It was based on FMOD and a specialisation of Ogre3D's ResourceManager, that made it possible to define sound resources as scripts that could configure several properties: looping, 3D, intensity thresholds, etc.

- User interface: To tell the truth, the user interface is actually split into three different components:

- The actual GUI subsystem, used for good old buttons, combos, etc., widgets. For these ones I went with CEGUI, an open source GUI library that already came bundled with the Ogre release we used (1.6.5). The more familiar that I got with it, the more powerful I've been finding it, so we could have used it instead of overlays in some other places, but then it was too late ^^U

Skinning a GUI layout, however, has been hell (well, I managed to come with a new skin on two days under a lot of time pressure, but still, it was a nightmare)

- Ogre's overlays. Mainly used for the HUD, and for almost the whole development cycle, the pause and game over screens (they got replaced with the third approach in the end). Ogre provides a specification for overlay scripts, but I find it a bit messy when you want to do some more complex positioning.

- Ogre's Rectangle2D class. Even simpler approach, consisting on creating a quad and applying a material to it. The intro, game over and loading screens are examples of this.

- Several graphical features.

- Animation engine. We adapted some code of an animation blender found on Ogre3D's wiki, adding the possibility to incorporate partial blending using an array of weighted bones. Unfortunately, it wasn't used at it fullest, due to time constraints and bugs.

- Initial approach to incorporating soft shadows, that unfortunately didn't make the cut. They were working, but then, when the change world functionality you've seen on the video was incorporated, it stopped functioning. The world change being a key feature of the game, it took precedence and dynamic shadows were removed until a later stage in the game.

- Some special effects. Nothing fancy, though. Some of them were reused from existing open source code, and then incorporated to the game:
    - The intermittent tint effect shown every time Any gets hit. This one was pretty easy to implement by using a pixel shader that would apply a tint whose intensity would vary according to a sine-like function.
    - The flashlight halo effect, combining texture and node animation  with a projective decal. The particles were incorporated at a later stage by another fellow programmer.
    - A lens flare, but it triggered on very rigid constraints, so it had to be tweaked a bit.

- Gameplay programming. I implemented the behaviours for several entities in our game.

- Any.
- The tripollos in the world of dreams.
- The scared plants (those weird plants that hide when Any gets close).
- The diamond trees. They work like the multiple-coin boxes from the Mario platformers: you may hit them for a set amount of time and obtain diamonds.
- Egg nests: These ones could drop an item -or a tripollo- from a varying choice of weighted.
- The story book item.
- An initial version of the world change item.
- Signposts.

As you can see, there were quite a few things to do @_@. Despite all this,  to be completely honest, I'm not entirely satisfied with the end result, despite the efforts the whole team has put onto it. Maybe it's just that I'm too hard on myself, but I believe that some degree of ambition and self-criticism should be a must for anybody that aims at developing games professionally, and I think that our game still has a long way to go until it can reach the status of 'acceptable'. The experience, however, has been really valuable, either as an example or as a counterexample.

Last, I would like to recommend a book that I found particularly useful during all this time (it's not the only one at all, but it was the one I've enjoyed the most):

Game Engine Programming, by Jason Gregory. I discovered it while I was looking for some algorithms on game loop synchronization, or maybe for entity managers and event handling. This book is amazing: exhaustive (it covers such things as animation engine programming, physics or entity management) and at the time I found it quite easy to read.

My first game design challenges

A couple of months or so ago I decided to stop lurking, and then I began submitting my own entries for Game Career Guide’s Game Design Challenges. In case you don’t know, Game Career Guide is one of Gamasutra’s sister sites, specifically oriented to students. It features some interesting articles on game development by prominent people in the industry, and it also holds a game design competition every few weeks. For these challenges, that are quite useful as a way to exercise one’s skills at designing and, mainly, communicating your idea as concisely as you can, they suggest a topic from which to devise a game, and then anyone may submit their own design in 500 words or less, including a maximum of three images. The most relevant ones are listed on the site. When I first learned about it, I instantly got interested and thought that I would take part on it as soon as I came up with a half decent idea. Inspiration, though, is a bit reluctant to assist me half of the time, so I have only participated three times so far. I got an honorable mention and a second place (the results for the third one haven’t been posted yet), so I guess I can’t complain. However, I’m still aiming for the first place. From now on, I’ll devote a whole post to future challenges, which I’ll update when the results are out...or maybe I should create a specific page to list the challenges, whatever. For today’s post, however, I was planning to share my first two entries.

My first time: Romance (No pun intended)

On the challenge’s wording they dealt with the romancing genre (for instance, the Tokimeki Memorial series), which is quite popular in Japan. Attempts to carry over those titles to Europe and the United States have kind of failed though. Our ‘mission’ was to design a game with romance as its main theme that could be more appealing to occidental mindsets.

To provide a bit of context, as the game will be heavily story-driven, I had the main idea while recalling 'Eternal Sunshine of the Spotless Mind', one of my favourite films ever.

The goal consists of gathering the pieces of a perplexing puzzle: the memories of your girlfriend/boyfriend and the relationship you had/have, which apparently you have completely forgotten. Solving the riddle doesn't mean you both get to live happily ever after: as you regain new memories and get closer to your goal, your decisions throughout the game and your interactions with other characters may significantly affect the outcome.

You won't be alone in your journey: Together with a partially controllable NPC who's going through the same, you'll have to cooperate to find out why your respective significant others seem to have been erased from your memories...if they ever existed.

At the beginning, you'll get to choose your gender and sexual orientation: they'll determine your partner's identity. Then you can pick a career (such as a scientist, a painter, a PR or a stripper) with benefits and disadvantages to your skills. There will also be some traits to choose which will set some background story-wise and grant you with further bonuses and handicaps. Your character's appearance will be customizable, for the eye candy.

Your companion will start with some skills of her own. As you progress through the game and get to know her better, you'll be able to 'discover' her own traits (not necessarily the same set you were offered in the beginning) and further refine her skills.

The plot will advance by completing certain sub-goals: - Get some reaction from an NPC, through conversational trees or performing in-game actions. - Reach some particular location. - Cooperative missions. Say, your partner uses her persuasion skill to distract some guy while you sneak past and then use your amazing ability to find information to...find some information. - Mini-game solving, related to whatever you're doing. Oblivion is useful as a bad and a good example: While I found the persuasion wheel totally unimmersive, the lock picking mini-game was, in contrast, reasonably well done.

Solving a sub-goal will trigger some hint about your relationship (which will contribute to get you attached to him/her, lest you might end up always romancing a secondary or even more unimportant character) and may give some clues for the next mission.

If you end up romancing other people (you cheater!), you'll have to talk to them, give them gifts or help them out. Your choices during the game may also modify the approval of one potential lover (where that option makes sense: no clairvoyance!). I'm afraid I won't be spoiling much if I say beforehand your companion will be a love interest, but there'll be more, some of which you might not get to meet on a single playthrough.

Last, there will be a variety of optional areas where you can get some benefits: insight about missions or the game world, shops, secondary quests, workplaces, motels, etcetera.

I enjoyed a lot imagining how the story would unfold. My weak point was, however, that I lacked a bit of focus on the gameplay. As a result, it isn’t totally clear if the game will be more of an RPG, vastly focused on conversations and character development, than a sandbox.
This is something that I have tried to solve for the subsequent entries. I still like the idea very much, and I intend to further develop it as soon as I can think of a set of suitable mechanics.

The results of the challenge, as well as the entries on the following pages, are listed right below, so you can read what other people did. My entry, that you’ve already read, is on page 8. http://www.gamecareerguide.com/features/835/results_from_game_design_.php

Second entry, second place :D: Inappropriate title

The second challenge I participated in asked contestants to take the title of a game that has nothing to do with the game itself and make another one that is better suited to that title. Examples included were Vagrant Story or Guilty Gear.

This time I opted for a more casual approach. I was playing Braid at that time (amazing game, by the way), and I couldn’t see how braids had anything to do with a time-controlling platformer (aside from a really brief mention on the plot introductory texts for one level). I then remembered Ratatouille and suddenly everything made sense: what about a hairdresser louse?

Don’t tell me it isn’t cute

As Louse Sassoon, a hairdresser-wannabe louse (Ratatouille anyone?), your dream is to make your human host wear the best-looking braids in the neighbourhood. To do so, you'll get to tame a set of rebel hair locks, forming the links that will shape the braid(s). However, humans and even your fellow lice will be around, decided to crush your dreams.

At the beginning of the level you'll get explained the type of braid you must do, as well as the possible new features you may encounter in it.

Then the game will star with Louse swinging from one of the locks (There will be some wind, blowing with varying strengths depending on the level). From there, it can jump to another lock either on its own, or carrying around the lock Louse was previously hanging from. If the jump is done while carrying around a lock of hair, one of the "links" of the braid will be made. After that, Louse will keep making links by repeating this process until time runs out. You must decide carefully when to jump so Louse can reach the desired lock avoiding to fall down. In addition to jumping and swinging, Louse can also use some items that may help it defeat its enemies, get some power-ups or score additional points. All the levels have a set duration. The area of interest where Louse will be able to put its skills to use will remain fixed for some seconds, and then the braid will go up (think of Puzzle Bobble, but in reverse order). If no links were done, the braid's appearance will look messy and you'll get less points.

Once the time has run out, Louse will move on to the next level if it managed to achieve a minimum score. There will be more than one scoring levels to provide an additional challenge and reward your skill with some bonuses.

Obstacles/Enemies:

• Lice shampoo cloud. Be careful and avoid them at all costs, as these clouds may kill you.
• Enemy lice. They despise Louse because they think it brings shame to the family. To defeat them, throw them some nits and make them fall.
• Hairspray cloud. This ozone-layer-destroying cloud will also paralyse Louse for a few seconds, leaving it vulnerable against enemies, and making it lose some precious time.
• Hair drier. Strong wind gusts will blow for a while, making swinging and jumping from lock to lock more complicated.
• Others.

Items:

• Hair gel: It stops a lock from swinging around due to the wind.
• Nits: Keep them to fight the enemy lice.
• Beads and ribbons: Use them to increase your score, as the braids Louse will make will look prettier <3
• Blood bubble: It'll cover Louse, making it invulnerable for a few seconds.
• Extra lives: Well, I bet all of us know these ones already, don't we?
• End-of-level bonus: After finishing certain levels Louse will have a chance to make some cool hairstyle by combining the braids it has been making during the level. If successful, it'll earn a huge score bonus

A fellow programmer colleague from my Master’s final project, Aniol Alcaraz, ranked in third place. UPC seems to be hitting hard design-wise, doesn’t it? :)

Check the full list of winning entries here: http://www.gamecareerguide.com/features/855/results_from_game_design_.php

Third design: Michael Jackson

For the latest design challenge, our objective was to imagine a game centered about the late singer.

I’ve always thought that his videoclips were really original and elaborated -starting, of course, with Thriller, responsible for my irrational fear of zombies, so when I read about the challenge I thought that I could use that as an obvious theme. I was at a risk of ending up like on my first challenge, where I kind of left the essential gameplay aside, so I began plotting possible interesting mechanics.

Since leaving music and dance out of the picture is a no-no, I came up with a not-too-original rhythm game, borrowing lots from the Osu! Tatakae! Ouendan! and Elite Beat Agents games. To prevent my idea from being a total rip-off, I thought of an issue concerning these two games: The player can forget about the DS’s upper screen when playing. In fact, if she wants to achieve a nice score, she should forget about it, as it may be distracting. Storywise isn’t particularly meaningful either (except for the comic-book-like cutscenes that are played on the level’s play pauses), so iNiS might have done without the upper screen and nobody would have noticed the difference. I decided to solve that by adding an enemy to fight on the upper screen. Square’s The World Ends With You manages to do a two-screen combat system using both the stylus and the buttons that works reasonably well, and I thought it could be applied to my game, hence the 9 Michael Jackson’s evil impersonators he must defeat. (Oh, the number isn’t final...it could be 9, it could be 13,...)

Adding this ‘pay attention to both screens’ feature involves an additional complexity layer, which means the difficulty of the classic rhythm game on the lower screen must be decreased a bit so that the combined challenge is not unbearably difficult.

This is my original entry:
Michael Jackson vs the nine.
Nine die-hard fans who've taken their obsession way too far and now believe to have become him, have got rid of Michael's most famous video clips and replaced the originals with their own, utterly crappy versions. Michael will have to redo the videos performing the same moves that made him famous again while at the same time he defeats his evil impersonators to prevent his legend from being stained with shame.

Mechanics:
This is a rhythm game intended for the Nintendo DS. The main source of inspiration is Elite Beat Agents, but I’ve added a twist inspired on the battle system used in The World Ends with You to make the upper screen a bit more meaningful gameplay-wise than it was on EBA.



During a stage you’ll have to take care of two things:
Performing the dance moves as accurately as possible on the lower screen using the stylus. You’ll have to click and/or follow certain symbols at the right time to make Michael dance, and also increase the power meter (the better he performs, the more energy he’ll gain).
At the same time Michael dances, he’ll have to dodge, counter and attack the evil impersonator for the current stage (remember those fans have lost touch with reality and think the authentic Michael is actually an imitator himself). Michael’s fan will be displayed on the upper screen, and every now and then he’ll throw some spotlights, rocks, etc (dependant on the setting of the stage). The directional pad+L trigger (or ABXY buttons+ R trigger for left-handed people) will allow you to avoid the items, deflect them or attack your foe, pressing the buttons when appropriate. The damage you cause to him will be proportional to the “style meter”.

As the focus is on rhythm, the attack and dance sequences will have to be balanced so that Michael’s attacks blend in nicely with the music. In addition, the dance moves part should be a bit easier than it is on EBA so that when incorporating the upper-screen-focused gameplay the combined challenge level does not get impossibly difficult.

The stage ends either when the whole video has finished, or when the player loses, which will happen when the style level goes below a minimum (either by repeatedly failing at dancing, or by getting hit by the crazy fan). There is a middle-ground situation: if by the end of the stage the style level is above the minimum threshold but the player hasn’t beaten the enemy, the score will be computed and the experience will accumulate to the total experience counter, but the stage will not be considered as cleared till the enemy has been defeated..

Last, the game is structured on several tiers of two or three stages of increasing difficulty. The player may choose between the available stages freely, but all of them will have to be cleared before advancing to the next tier.

The time limit to submit entries ended yesterday, and they’ll be posting the results next week.

If I happen to have a good idea from which to code a simple game on XNA, C++ plus [OpenGL|DirectX] or Pygame for learning purposes (What should I do? A scrolling shooter? A platformer? A tower defense? I’m open to any suggestions), my next post might deal with it; otherwise, I may have to recycle a couple of incomplete designs that I have in mind. For now, I’ll just spoil the titles: Psyche, and The Path is The Goal (this one is probably temporary, though).

Wall Chaos (I)

Here is my second playable game, although due to the post's massive length, I've had to split it into two separate ones. The first one will introduce the game, and I'll go through its design choices, and on the second one I'll focus on coding details.

Wall Chaos is a game I did for a class assignment. They requested us to do a 2D game choosing among these three options:
- To make a 2D prototype of the game we'd chosen as the main project.
- To reuse and extend a 2D top-down tiled engine, a la Final Fantasy VI or the old Zelda games, to make an RTS or an RPG.
- To implement an isometric 2D game, the genre being free for us to choose.

The project was meant to be done in groups, but luckily we were also allowed to do it separately, which was what our group did, as we thought we'd have a bigger opportunity to learn from the experience (and I'll never be thankful enough for that decision, because I got the best mark in the class, mwahahhaha).

You can see Chuck Norris' mage twin in the middle of the picture, chased by mad

spiders

Although my favourite genres are precisely RPG and Strategy, I decided to make a game from the start (or almost), instead of reusing a basic engine, as I thought it would be more challenging and rewarding, and I could learn more.

I chose to do an isometric 2D 'shooter' game partially based on an idea I'd previously had for a 2.5D game. Although I wasn't considering the isometric map at all as a choice to implement the real deal, it just came naturally when I had to think of what kind of game to make. Still, I think a top-down view will suit it better, and when I put my mind seriously on it I'll do it that way.

This is the link to the binaries so you can download it. There is a short manual with the controls:

Wall Chaos binaries, v0.15

(Disclaimer: Music and sounds are obviously not mine; Credit for the sprites for the mage and the spider goes to Reiner's Tilesets. I did the walls, tiles and the health item sprite, as well as the HUD...the other graphics, well, I guess everybody knows them)

Here's the concept design:

Wall Chaos: The initial concept (Warning!! Wall of text ahead. To skip through the dirty details, read the TL;DR section instead)

Quick and dirty schematic 3D render, just so you can have an idea of how a level might be laid out. The green sphere would be the player, the red ones the enemies, and the small yellow one a projectile flying around the place.

Wall Chaos will be a 2.5D top-down action game taking place in rooms 'a la' Bomberman, focused in exciting, fast and challenging gameplay while at the same time allowing for some tactical possibilities.

Visually, the overall aesthetic look will be colourful and cartoony. Characters, enemies, etc., are therefore meant to be designed as super-deformed characters (References: Most 3D games for the DS, Dr Slump, Dragon Quest, MySims, ...).

The Legend of Zelda: Phantom Hourglass' visuals are also a great example of what I'd like to accomplish

Story: As the final test to complete your studies at a prestigious academy to be a wizard you're tasked to go to the remotest tower in the remotest corner of the kingdom and fetch your degree certificate, located in the highest floor of said tower. Instead of just answering a few questions,

you'll have to clear the game's many levels, each level matching a tower's floor. Some tips about the levels' layout, or the enemies that'll inhabit a level, may be given to you during cutscenes or loading screens.

Each room will be populated by several enemies you'll need to kill before time runs out. Of course, surviving is a must as well ;) To achieve that you'll cast attack spells with your magic wand, and invoke some powerful defensive magic to grant you some bonuses (such as a barrier deflecting enemy projectiles, increased defense or speed, elemental resistances, etcetera). By getting rid of certain enemies you may unlock new spells, and they'll drop items to help you through your quest, as the levels will get increasingly harder as you progress; you might get a better wand, a cloak of invisibility that might let you sneak past a column of enemies and such.

'But that sounds way too cliche and dull, and what's more, it seems way too easy and unchalleging. Where's the catch?,' you may be thinking.

Well, it turns out that the rooms are enchanted, and some walls will modify a magic projectile upon colliding. At its most basic, they'll simply rebound and decrease the projectile's life (for instance, initially the default spell may collide three times before fading out), but depending on the wall and spell type it may be imbued with additional effects (they may add up or not, allowing for some awesome combos in the first case).

As a result, the rebounds can be used strategically to defeat creatures located in unreachable places (for instance, in an island surrounded by lava), or to increase the spell's power. Stylish enemy deaths will be rewarded! (...and epic fails as well: there'll be something for everyone!)

However, a projectile will not differentiate between yourself (remember you're not a fully fledged wizard yet!) and your enemies, so the spells may hit you as well. You'll have to be careful!. Besides, there might be traps around a room.

WALLS:

- Common walls: The spell will just rebound keeping its properties, although its life time will decrease until it reaches zero. I'm considering to increase the damage they cause depending on the number of rebounds, so the last one before extinguishing will be the most powerful.

- Frozen walls: Depending on the type of spell that hits, the result may differ:

->A basic spell will turn into an ice spell, that may paralyse the first creature it finds on its way after colliding.

->A fire spell will revert to a basic spell.

->A lightning spell might turn into a combined IceStorm spell.

->...others

- Warp walls: If the spell hits that wall, it'll disappear to reappear through another warp wall located in the room.

- Fire walls:

-> A basic spell will turn into a fire spell: it can melt ice blocks or roast an enemy.

-> An ice spell will melt and extinguish.

- Piercing walls: It adds a spell a piercing ability: instead of dying out when hitting an enemy, it'll damage it and then pass past it.

- Etcetera

TYPES OF SPELLS. Some of them will be available as 'castable', and others will be made as a combination of several others, as the spell bumps against the enchanted walls.

- Basic spell: it just does damage.

- Piercing spell: it penetrates through enemies.

- Elemental spells: Fire, ice, lightning,...

- Sponge spell: it'll absorb any spell effect, adding them up no matter if they're even opposite ones (for instance, it might add the ice effect and then hit a fire wall without it getting destroyed: the resulting spell would cause ice AND fire damage)

After a while, you might end up with a Ultra-mega-super-powerful Spell of Doom, killing every creature at hand, only to find yourself dead as well because it hit a Warp Wall and then reappeared just behind you.

...and this would be the humiliating result

All of these rebound-based mechanics add an additional strategic component to the game, letting you cannon the projectiles around, as in the pool game. It also makes you keep your attention focused in both the enemies and your own attacks, or even a tricky, hostile environment. For instance, something 'funny' might happen to you after casting several spells without success or while staying still at the same place for a while...

Sadly, for this version (which is, basically, an initial prototype), I just had time to code one type of wall, one type of spell, two type of tiles (walkable and non-walkable) and a couple of items scattered around the levels (there were no enemy drops either). I didn't have enough time to implement some pathfinding, so the only kind of enemy moved around randomly like an idiot.

TL;DR Design in a few words, for the lazy ones.

Basically, you're put into a maze-like room where enemies roam freely: you must kill all of them before time runs out, hitting them with magic projectiles. The projectiles may rebound against walls, and you can use that fact to your advantage (although that might also lead you to certain death unless you're careful).

Tu sum it all up, despite the obvious limitations and flaws of this initial version I found the final result quite entertaining (okay, I may not be the most objective person to judge it), and I actually think that the complete idea has potential as a real, marketable game, so I'd like to implement the actual version. I was thinking of PC or DS as the platforms of choice, but it might work out on consoles (i.e, XBox Live, PSN network, etc) just as well.

Concept design: Würthel City

Given that compilation times on our final project for the masters are kind of high, I'm going to spend that idle time in-between doing something useful and write a new post.

(Yeah, I know I could use it as a legitimate excuse to slack off, as in XKCD's comic strip)

 

Well, going on-topic again:
At the end of yesterday's post I talked about a conceptual design we were asked to do by the U-Play Studios representative, which had come to give us a talk on starting up a video game developer studio. We were to think of ideas for a browser-based game.

To answer the question '...and what does a browser game look like?', there are lots of examples online, some of which you may have played already: Bitefight, Ogame, Ikariam, Striker Manager -done by the company that asked us to design the game, by the way-, and several more.

After a bit of brainstorming and casual chat with friends, I came up with 'Würthel City' (any similarity between the title/city name and certain massive corruption case in Spain being completely intentional). It allows players to put themselves in the shoes of a detective newly arrived to a metropolis where crime and corruption rates have skyrocketed.


Your goal as that detective is, of course, to become the best one out there. You'll be either competing or cooperating (via guilds detective agencies) with lots of other players to solve the highest number of cases.

To do that, you'll have to move around the areas of Würthel City, interact with NPCs and/or other human-controlled characters, and use your skills and equipment to make your way through the cases, which might range from robberies, drug trafficking, murders, corruption, kidnappings and such.






Click on this link for the English version of Würthel City's concept document.The PDF goes through these basic outlines in more detail. I apologise in advance for the crappy fake screenshots. I did some rough sketches at that moment to illustrate the concepts that I was trying to communicate, and didn't focus much in visual quality. I expect that they're descriptive enough, though.

PS: Würthel City, Spanish version

First attempts at design

So here we come again. I'm updating my stuff chronologically, and today it is time to post my first, lame attempts at game design, using an open source mind map tool called Freemind. I found it quite useful to sort out my thoughts.

This image shows the first one; it features some loose ideas about an evolution sim a bit influenced by Dwarf Fortress called Natsel. I began it hoping to create something more faithful to science than Spore turned out to be.



As you can see, I focused on how to create the world, the mechanisms throughout which the living beings would evolve and acquire new abilities, but I didn't get to develop the aspects more linked to gameplay.

Then I started thinking of THE MOTHER OF ALL RPGs, and started another mind map, this time a lot more exhaustive (but still incomplete). This one was one of the possible projects I proposed in the beginning of the master. Unfortunately, it wasn't appealing enough (besides being overly complex for the master's scope, I'd forgotten the mind map at home and had to write a dirty sketch with the concepts I managed to remember), but I'm still considering it as a future goal. I'll have to do an exhaustive go-through so I update it with some ideas that I've acquired recently while playing some other RPGs.

I'll probably talk more about this project in the future.

BEWARE!! Giant diagram.

On my following post I'll upload a conceptual design I did for an assignment which required us to devise a browser game. While the first thought that came to my mind was something related to those 'Choose your own adventure' books, set on the typical medieval-like fantasy world, I ended up switching to a detective sim after some chat with my flatmate.

PS: Here are the Spanish diagrams as well, although they're a bit outdated: While I was editing the English versions, I added a couple of notes and changes.

Natsel: Spanish version

RPG: Spanish version

PS2: In case Blogger decides to keep messing with the links to the images, here's the URL to the Imageshack album where I've uploaded the four diagrams