• Advertisement
  • entries
  • comments
  • views

About this blog

Merry Prankster Games: Temple of the Abyssal Winds

Entries in this blog

Well, work has been going quite well on Unannounced SENG Game, to the point where I'd like to announce it soon, and release in a few months. So, I need some cover art! Here's my pitch:
Merry Prankster Games is working on a classic, single player role-playing game, for release on Windows and IPad. I need an icon and 2 pieces of cover art.

The icon should be suitable both for use as an icon, a logo, and perhaps an image in something like an app-store. It should be clean and scalable to a wide variety of resolutions. The cover art should be in a realistic/painting style for a relatively serious feel. I have ideas for how all should look, but the artist's input is welcome and important as well.

This work is to be done on a paid, contract basis, with MPG getting exclusive rights to the work, and can begin immediately.

Merry Prankster Games is a one man studio (Geoff Dunbar), and can be found at http://prankster.com. See "10 Fantasy Fights" on that site for a tech-demo of the game I'm working on.

Please contact me at gtd@prankster.com if you are interested, capable, and available.[/quote]

I'm a little nervous as I've never commissioned work like this before. Any advice welcome!



Well, summer is done, and man, was I unproductive. Things are returning to normalcy, and I'm back to work on Unannounced SENG Game.

I did actually get some things done over the summer, including some planning, and one complete area. But there is still much to do. I'll try to announce more concrete plans in the next few weeks.

In the meantime, here is a screenshot from the very beginning of the game:

Well, I'm working on Unannounced SENG Game right now. I would to announce it soon, but I'm in the thick of development.

As part of the development, I need to add some more environments to the 10FF. Here's a screenshot of a solid wooden bridge over a river.


More to come later.

So, with 10 Fantasy Fights fully functional on iOS, I've got my proof of concept... games with my engine work fine on iOS or Windows. So, now it's time to make the actual game! I'll roll out a good announcement soon, but in the meantime I'll post enigmatic progress reports. Right now I'm working on the locations for the game, which (it turns out) is really hard, because that is also tightly bound to the quests in the game. Which is tightly bound to the factions and characters in the game. Which is tightly bound... OK, it goes on and on. Basically I need to iterate on the whole game plan.

But, for you, here's a preliminary, in progress, version of the overland map.

I just played through 10 Fantasy Fights on the iPad. Fixed a few little bugs on the way, but you can win the game, as this screenshot proves:


Only problem is, the interface is still a ported-over mouse interface, not a touch interface. So, it's pretty painful to go all the way through. Next big task is to make touch work the way it should.

Having just played, the things that really stand out are:

* 10FF is pausable real-time. It's more of a tactical game than action, so being able to pause and issue orders is really important. On the PC, this works great with spacebar. On the iPad, with no spacebar, the tiny little pause button is not nearly enough. I'll definitely make pause easier to hit, but also experiment with pausing whenever you select one of your characters, or even an auto-pause feature.
* For things like inventory and stores, I use drag and drop to move stuff around. Also, scroll bars when you have too much stuff. However, I'm going to have to make the scrollable stuff drag to scroll, as that's how touch interfaces work. What happens to the drag and drop of objects? Do I try to detect what the player is doing? Switch to "click the object", "click the destination"? Or what?
* Organizing your party right now requires clicking on tiny little buttons. Doesn't work at all.
* I was worried about hit detection on characters and monsters, but it actually works pretty well.
* On the PC, I have hover, which is useful. Currently, as a workaround, you can generally pause and then click on something to get info, but this also triggers actions. So, I need to make this better for touch.
* On the PC I use r-click to enter an info dialog for just about everything. I switched to long-press for iPad, which is OK. However, there are a lot of places where a tap could just do that too. Also, the UI needs some indication when you've held long enough when there is different behavior.

There's more, but enough to worry about now. My next plan is to sit down with all of the screen and figure out exactly what the behavior should be. Then try it out, and iterate until it is awesome.


iPad version

Here it is, a screenshot of 10FF running on an iPad Mini!


I am really psyched about this. This isn't just test or partial code; the complete engine is working, with "little" things like audio and everything. I believe the game is fully playable at this point, though I haven't gone through it to the finish yet.

The discerning will note: FPS: 0.96432 (and so on) at the bottom. Uhoh... When I first noticed the FPS, I was horrified. I mean, that isn't just a little slow. Step 1, I tried the Release version. No difference. Oh dear.

Step 2, I turned on the debug tracing. This was even more horrifying, as even running a game tick (without rendering anything) was taking 30ms. Getting 30 FPS isn't likely when you only get 30 FPS without even rendering! And rendering a frame was taking almost a full second.

Step 3, I turned to the XCode profiler. After some tomfoolery with debug symbols, I got it going, and at last, some good news. Under the profiling, doing a game tick is really fast, a millisecond maybe. On further reflection, I believe that tracing from the iPad to the debugger (on a Mac) is really slow, taking almost a millisecond just to trace a line. So with tracing on, performance craters.

I'm left with the rendering code, which I know can be much more optimized. But, I got even better news from the profiler. The actual level rendering code is quite speedy. The vast majority of the bad performance is coming from the HUD rendering! Well, I can optimize the heck out of that... in fact the majority of the bad perf is from text rendering, which should be super easy to cache on a texture. So, that's good news.

Just to verify, I turned off the HUD and the game did actually render at 30 FPS. There were a few little glitches here and there, but I suspect I know what that is, and can optimize that away. So, all in all, good news.


Level rendering

Got level rendering working on the iOS simulator:


I had to show a screenshot of the very start of the beginning level, as I don't have the touch events wired properly yet and you can't move at all. The discerning eye will also note some face culling issues. And perf is crap. But definite progress.

Yes, the moment you've been waiting for! In all its glory, 10FF in the iPad simulator:

Oh wait, you thought that not only the game would run, but the graphics would render too? Well, that's asking a lot. You'll have to take my word for it that the game is, in fact running. But it seems there is still some work to do...


Game UI render

Happy Holidays everyone! Here is evidence of the UI rendering, with text (iOS simulator screenshot):


This is the actual 10FF UI. Other than some little glitches, you can successfully create a character and start a game! Which then crashes and burns before displaying a single frame. Getting there, though.


UI primitives

Working on UI rendering. Here's the outline of a button, and below it an image rendering. I don't have text working yet so the button looks a little funny without any label. Once I get text working, all of the other primitives should work fine, though.


iOS: Full Rendering

OK, after some fiddling (and some vacation), here is a render from iOS with full lighting, texturing, and animation. Woo!


Next, some cleanup and refactoring (mainly to support different lighting models). Then, particles effects.

More iOS progress. Screenshot:


This is a complex model, an orc, loading from the 10FF data. The orc consists of 12 actual models, stitched together so they can be swapped in and out as needed; for instance, if the orc decides to wield a sword instead of a club.

No textures yet, but I have implemented lighting. The weird lighting in this screenshot is because:

  • The ambient light is blue.
  • There is a green directional light to the top left.
  • There is a red point light to the top right.

    The weird colors let me know that I have actually implemented things properly. (There was a snafu with the normal vectors that was screwing me up for awhile, which this lighting made really obvious). Once I implement textures, I'll use more reasonable lighting.

    Next up, textures and animations. Animations should be super-simple, as the rendering code already handles them, it just needs to be told (by the shell application) what time it is. Textures are a little trickier, but still not too bad since the rendering code supports them just fine on Windows.

It Renders!

Well, after much effort and convolutions, here is the pile model from 10FF rendering in the iPad simulator:


Although I don't have texturing, lighting, or animation working, this is actually using the game's rendering code, which is a big accomplishment. Adding the proper rendering stuff in should (cough cough) actually be relatively easy, because it's just a matter of plugging in the iOS specific bits to the already functional graphics rendering code.

Continuing iPad 10FF

Back from vacation. Sadly still no visible progress. I've done a fair amount of code replacement, replacing Windows-specific code with platform-independent versions of the same code:

  • Replaced D3DX math code with CML math code (http://cmldev.net/).
  • Replaced D3DX model-loading code with AssImp model-loading code (http://assimp.sourceforge.net/index.html).
  • Replaced D3DX particle code (ID3DXSprite) with my own sprite code.

    It all works on Windows, and should all work just fine on iOS. Next piece is the model rendering code. Luckily my rendering is pretty simple, so I'm not too worried, but it's still a big change.

    Hopefully next time, I'll at least be rendering 10FF models in the iPad simulator.

iPad 10FF

So, my next move with 10FF is to port it to work on the iPad. In one sense, this is a little frustrating, because I've got most of the pieces ready to make a commercial game from the SENG engine. But at this point, it makes sense to take a step back and make the engine work on iOS _before_ I invest in making a whole bunch of content that might not work well on iOS.

In theory, the port won't be too bad. SENG has a whole bunch of platform agnostic game-running code, and 10FF has a bunch of content that should also be platform agnostic. The big bits that need to be ported are the graphics rendering code, and the UI code. Neither of these bunches of code are too sophisticated, so porting them shouldn't be too bad. In theory.

My current task is replacing a bunch of DirectX specific code with platform agnostic equivalents. Things like 3D math and 3D model loading. I can do all of this coding on Windows in 10FF, which is handy because I can immediately test it rather than doing a massive, monolithic port and then debug for weeks/months.

In the meantime, for a screenshot, here's a tile rendering test I did in the iPad emulator:


Pathfinding Part 2

See Part 1 for background: https://www.gamedev.net/blog/717/entry-2255124-pathfinding-part-1/

OK, so I had reached the point of frustration with my old pathfinding... what to do about it? It had become obvious to me that my pathfinding would have to do some searching to find a path to the target, rather than just walking towards the target semi-blindly.

The classic pathfinding algorithm is called A*. Simplified: A* does a search of the pathfinding space, optimizing the search such that it looks first at paths that go towards the target. It is relatively efficient and quite effective. I won't try to give a full description of A* as that has already been done, many places, very well. Here's one example from the comments: http://www.policyalmanac.org/games/aStarTutorial.htm

However, I had some concerns about A*:

  1. While efficient as far as search algorithms go, it is still a search algorithm. Running it every "tick" (generally 60 times per second) for every actor in a SENG game would have some cost.
  2. A* works very well for one entity searching in a static environment. However, as few as 2 entities can get stuck doing A*, constantly running into each other without ever finding the target. This is solveable, but I'd already solved these issues with my heuristic.
  3. Most importantly: A* works on a discrete space, like a chess-board. SENG has a continuous movement space. The Internet suggests some ways to deal with this, but it isn't a clear cut-and-dried algorithm. Mostly, "first, divide your space into discrete chunks".

A quick note: SENG uses a tile system for basic terrain (2.5 feet x 2.5 feet tiles). However, "objects" (like tables) and actors can have arbitrary position. Movement of actors is in any direction. Disallowing movement except along tiles (in order to implement A*) would be a significant step backwards for the game engine.

I decided to do a combination of A* and my heuristic:

  1. If we are close to the target, or far from the target, just use the "move towards the target" heuristic.
  2. Run A*, just using the tiles of the area (ignoring other actors).

    • If A* fails (no path to the target, or path too long), just move towards the target.

  • Pick the point on the A* path 12.5 feet from the moving actor. Call this the waypoint.

    • Use the heuristic movement to move towards the waypoint until we are halfway there, or if we aren't making progress towards the waypoint.

    • Go back to (1).

      OK, here's an example. In this picture, the actor wants to follow the green path. A* calculates the blue path as the optimal path to the target. (Note that this path would actually be a jagged line due to the tile based nature of the algorithm, but I didn't feel like drawing that). The red path represents the waypoint that the actor has selected to move towards.


      In this picture, the actor has gotten halfway to the waypoint, so he recalculates:


      And, in this last picture, the actor got halfway to the next waypoint. Note that the waypoint is now starting to move around the corner; however, the heuristic movement is capable of negotiating simple obstacles and will "bounce" around the corner of lava in the way.


      I am very pleased; this new pathfinding algorithm combines many of the good features of A* and the heuristic:

      1. Very efficient. We generally only perform a search of the area tiles every few seconds (per actor). There is no noticeable performance impact of this pathfinding algorithm vs the heuristic.
      2. Works well with moving targets and moving obstacles. The heuristic algorithm, with its simple minded directed movement, deals quite well with this. A* is restricted to the long-range planning where these problems aren't a factor.
      3. Movement is continuous, so the actor moves directly towards the target with no zig-zagging. There is actually just a little visible zig-zagging due to waypoints always being the center of a tile, but it is barely noticeable.
      4. Properly moves around indentations, long walls and other complex formations, due to use of A*.

      When I next release a beta of 10 Fantasy Fights, you can experience for yourself!
  • Pathfinding Part 1

    So, pathfinding has been a long-time issue with my SENG engine. The traditional pathfinding I've used is heuristic based. Something like:

    1. Move straight towards the target.
    2. If you hit a wall, walk along the wall until you pass the corner of the wall, and then go back to (1).

      • If you hit something else while walking along a wall, turn around and try to go around the wall the other way.

  • If you hit another actor, pick clockwise or counter-clockwise, and go around that actor until you are clear of the actor.

    1. Picking direction:

      1. Generally, pick the direction that will be the shortest path to the target.
      2. However, if the actor is already going around _you_, pick the same direction as him.

    2. If you hit another actor while doing this, go the same direction around the second actor.
    3. If you hit something else (wall), switch directions.

    For example, in this picture, the actor wants to follow the green arrow. It will follow the red path and successfully reach the target:

    This heuristic works very well in many situations. It goes around actors and pillars very well. And (also important), in terms of performance, it is very inexpensive.

    However, there are a few little issues. The first is that when an actor runs into a long wall (sadly common in things like houses, castles, etc), if he chooses to go the wrong way, he wanders off into the distance aimlessly. Actually, not aimlessly... very directly and without pause.

    The second, and even more annoying, is that if the actor runs into a little indentation in a barrier, he will happily run back and forth within that indentation pretty much forever. This is bad when the barrier is a wall, but if it is something like a river, the actor may be mere feet from his target, with the path to the target in plain view for all, but he simply bounces back and forth.

    For example, in this picture, the actor wants to follow the green arrow. It will follow the red path, and run back and forth forever:

    The final straw for me was when I discovered such an indentation on the last level of 10 Fantasy Fights. It is entirely possible to get the Big Bad Boss stuck in this indentation, and shoot arrows at him until he drops, at no danger to the party.

    Next time: What I did about the pathfinding issue.
  • This may be of no interest to anyone but me, but it is helpful for me to go and check for comments on 10FF. Here are the various posts and announcements about 10FF:

    Promotion is Hard!

    So I've spent all the time making 10 Fantasy Fights (http://prankster.com/10ff). People should be lining up to play it, right? Haha.

    For the past few days, I've been posting to various announcement forums, emailing news editor etc, on a variety of Indie and RPG game sites. Such as:

    • Here.
    • RPGCodex.
    • RampantGames.
    • TIGSource.
    • IndieDB.
    • IndieRPGs.
    • RPGWatch.
    • IndieGames.
    • IndieGamer.

      (If you have any more ideas where I should announce 10FF, please feel free to drop a comment or email!)

      Well, a few people have downloaded 10FF now, but so far the only feedback I've gotten is a sarcastic thread about my use of "real-time" and "realism" in the announcement I wrote. I must remind myself that this stuff takes time.

    Merry Prankster Games announces the release of 10 Fantasy Fights version 1.0 (Beta)! More information or download here:


    10 Fantasy Fights is a demonstration game by Merry Prankster Games. In 10 Fantasy Fights, you control a party of adventurers though a series of 10 fights designed to exercise all aspects of the SENG game engine. You will rapidly advance from a simple battle of a single inexperienced warrior against lowly minions, all the way to controlling a mighty band of legendary heroes against a near-invincible demon lord.

    10 Fantasy Fights is a single player computer role-playing game for computers running Microsoft Windows. 10 Fantasy Fights is evocative of the classic CRPG games of the 90s, but updated to run well on modern computers, using modern technology.


    • Pause-able, Real-Time game-play - 10 Fantasy Fights runs in real-time for maximum realism, but allows you to pause the game any time to issue orders to your adventurers.
    • Party-Based - In 10 Fantasy Fights you control up to 4 main heroes, and can control additional summoned creatures.
    • Custom Game System - 10 Fantasy Fights uses the custom SENG RPG system, which will be familiar to pencil-and-paper RPG players, but updated to work well in a real-time computer environment.
    • Character Development - 10 Fantasy Fights features over 80 skills, hundreds of spells, and hundreds of items to customize your heroes to your liking.
    • 3D graphics - 10 Fantasy Fights uses a fully 3D graphics engine to provide a detailed, dynamic environment for your adventures.
    • Varied Adventure - 10 Fantasy Fights will lead your party through 10 fights with widely varied environments and tactics.
    • Free - 10 Fantasy Fights is a demonstration game, and is free for your enjoyment. Please give Feedback on the game so we can improve our games in the future.

      Give 10 Fantasy Fights a try! http://www.prankster.com/10ff
    10 Fantasy Fights is a Merry Prankster Games demonstration game. For more information: http://www.prankster.com/10ff

    Please post any bugs or technical issues you experience with 10 Fantasy Fights in the comments below. Or, if you are shy, feel free to email [email="10ff@prankster.com?subject=10FF%20bug"]10ff@prankster.com[/email].
    10 Fantasy Fights is a Merry Prankster Games demonstration game. For more information: http://www.prankster.com/10ff

    Please post any comments or questions you have on 10 Fantasy Fights gameplay in the comments below. Suitable topics include:

    • Leveling skill/attribute choices you found interesting, effective, or otherwise.
    • Which other actors to include in a party at any level or fight.
    • Strategies for defeating any of the fights.
    • Other gameplay related topics.
    10 Fantasy Fights is a Merry Prankster Games demonstration game. For more information: http://www.prankster.com/10ff

    Merry Prankster Games is desperate for feedback! Please post in the comments below any feedback you have on the game. Or, if you are shy, email directly: [email="10ff@prankster.com?subject=10FF%20Feedback"]10ff@prankster.com[/email]

    See the first comment for some suggestions on what I'm looking for in feedback.
    • Advertisement