Posts Tagged ‘nme’
Time for our post-mortem
I won’t re-introduce the team, you can go to our “we’re in” post for that. Basically there were 3 of us and we’re pretty awesome!
So what happened?
Well, we made a time-bending tower-defence game called “10 Second Onslaught”. It’s about an onslaught you see, and the onslaught in question lasts 10 seconds:
The game wasn’t really “finished” after 72 hours even though it’s completely playable. I’m actually glad we were over-ambitious though: it’s a good beginning and something I’m still working on (in a separate branch of course )
What went well?
The art pipline was probably the one thing that went particularly well. Thomas is really a 3D artist, so soon reverted back from pixel art to making models and rendering them to bitmaps. To speed things up I wrote a couple of little ImageMagick scripts to mirror and then stick these images together into sheets. Then it was just a matter of using the haxelib spritesheet to have animated characters in the game
What went badly?
For various reasons, mostly the technology (OpenFL) being something only I had ever used before, I ended up writing a majority of the code, which is just stupid. Next time we’re going to have to organise ourselves better.
Read on for a rather long discussion of OpenFL, including comparisons to Unity 3D and Löve 2D…
A week has passed since LD48 and it’s a good time to take a deep breath and reflect. Rub our sore muscles. Think about what’s next. Weep uncontrollably. Whatever you need. In my case, Mass Splitter went out the door without a hitch! Well, rather, it was well under the maximum number of allowed hitches. It was within hitch tolerance. In truth, there were three hitches: I didn’t get in a main menu, I didn’t get in a tutorial or at least an instruction page, and there was only one level. But all these hitches pretty much have the same cause, that of running out of time, so how comes I haz runs out?
What Went Wrong
Architect hat mostly unworn
I spent a bunch of time trying to get some view components working with HaxePunk. HaxePunk handles origin a little differently than I would think it should work, so I spent a few hours on my View class, getting the Scale, Origin, and Position components to all work together. Great, they now work together.
I did this because my game has orbs in it, and the active orb has a tube spinning around the outside edge of it. You hold the spacebar to shrink the active orb and start growing a new orb on the other side of the tube. After I got the tube spinning at the right radius around the correct center point I then went to add the new orb. This new orb also needs to be placed at spinning radius from the center, so how do I get the true position of the edge of the tube?
Well I can’t. The tube’s actual position is derived inside the view class, so it doesn’t exist at the component level. So now I’d have to either hack into the View objects to get this information (which horrifies my MVC sensibilities), or just calculate the orbital position myself, which I did. Well gosh, that was easy. And now that I’ve done that I can position and rotate the tube using the same logic, so the tube stops scaling along with the size of the active orb, which is a better look I like anyway.
In essence, I looked at just one next thing to do, rather than the broader landscape. Without putting on the architect hat, I spent a few hours going down a rabbit hole I didn’t need or want. On the other hand, I’ve got a cooler View class now.
Failed to take the time to split up complicated classes
I didn’t universally fail this, but I could probably attribute a few hours of wasted energy because of failing to do this early or at all. In particular my firing system is doing several things rather than breaking it up into different systems. See Ash Entity System / What Went Right.
Not putting more of my personality into my game
Friends often tell me I’m funny. Even fine, up-standing strangers — if not calling me that — have in the least called me irreverent. I try not to listen to other categories of people whose job is to be offended by everything. Anyhow – you wouldn’t know these things about me from playing Mass Splitter. Sure, I don’t have to make humor a central aspect of all my games, but a) it’s clearly desirable in a competition where there’s a category for it, b) there are many kinds of humor besides pratfalls and puns that can serve a dramatic cause. Heard of irony? Sarcasm? Deprecation? Pathos? Impudent contempt? Not that Mass Splitter is a deep example of erudition (it’s not), but it’s better for one’s self esteem to believe your personality is a strength. And if it’s not … well, you should work on your personality. Are you trying to tell me I should work on my personality? Stop staring at me like that.
What Went Right
Ash Entity Framework
Richard Lord’s Ash Entity Framework is really good. It’s an entity component system. I used the Haxe port maintained by Dan Korostelev. It was really fun to learn how to use an entity system and put it into practice. For those who don’t know, apparently those folks at AAA game houses have been using these things for years. The idea is to eschew traditional static object hierarchies for a data-driven composition approach. Richard has some great articles about it on his website.
Everyone seems to approach an entity system differently; in Ash the entity is a fairly generic object. You create a new Entity instance, optionally give it a name, add components to it, and add it to the engine. Usually it’s the job of a factory to create the entities with the components you need, but that’s up to you. Components are simply data-holders that you create, with little if no logic in them. Ash components do not need to derive from any base class, any object could be a component. All the behavior for your game goes into the systems you write, derived from the System class and added to the engine instance driving your game. When you call engine.update(time), all your systems execute in the appropriate sequence. Although Ash provides a signaling capability, Richard recommends you use boolean flags or components as markers to indicate when events happen, so that a component event (such as “this changed”) is only responded to by a system when it executes. Using engine.getNodeList(MyNode) a system fetches a list of entities from the engine that are relevant to it. Nodes are classes that contain one or more components; only those entities holding the components you specify will be returned.
I enjoyed using Ash quite a bit and encourage you to look at my source on Github if you’re interested in seeing one possible way of using the library.
Last compo I thought I picked a small idea but apparently it wasn’t small enough because I couldn’t get it done in time. This one was doable — juuuust barely. I tried to get a playable prototype as soon as possible; I would have liked to go to bed on Saturday night with it playable. Now, that didn’t work. Pthbth. The prototype wasn’t playable until Sunday afternoon, but imagine if I wasn’t striving for earlier! Suck-sess.
I’ve had previous practice with HaxePunk, and I started messing with Ash in a previous game I attempted to complete for the 7-day Roguelike. Even though THAT attempt was a failure, it gave me crucial practice that made this submission possible, and also gave me base code to pick at for Mass Splitter. Of course, more practice would be better, so I shouldn’t wait four months for my next game…
This audio tool is available in several forms; the one I used is BFXR. Sooooo convenient. Sure, all your sounds do tend to sound video gamey retro screechy crunchy if you don’t post-process them, but a lot of people go for that, and damn if it isn’t quick to pump out some placeholders. (… that wind up being the final sounds when you run out of time)
Shut up, good enough, it’s playable
Shut up, I say! It’s good enough. It’s playable. I’m just happy I got out a game. Would I have liked to get those extra things I conceived of? Of course. Over time, with practice, I’ll be able to meet the goals I think I should be capable of. (I’m a damn perfectionist. I’d be faster if I wasn’t always trying some different way of doing things.)
I finished something playable in time that some people actually liked. Next time I’ll do even better.
I’m in for the compo. Too bad about the potato theme, though…
Editor: Sublime Text 2
Framework: HaxePunk, HaxePunk-AI, Ash-Haxe
Visuals: Photoshop, FilterForge
Audio: Audacity, VLC, Bfxr, Autotracker-py
Version Control: Git
I’ll be using the Ash entity system. I’ve written some components, systems, and views in a prior game that I may want to
pilfer leverage for the compo. You can find that base code on GitHub. Dead Grinder is not really a game at this moment, so much as it’s a pile of code that could theoretically be reassembled into something resembling a game given additional effort.
Good luck everyone!
With all the potato craziness, I forgot to announce this fact!
I’m in for my 6th(!) Ludum Dare. I plan to use Haxe + NME + HaxePunk to make a game for web and mobile devices. I’ll use GraphicsGale or GIMP for art, bfxr and audacity and maybe something else for sound, and caffeine to keep me awake.
Have fun everyone! Remember: #NoPotato #YesMeat
Thanks Ludum Dare and 1GAM, for encouraging me to put out more games … even if they are shamefully dull and unplayable. I had been working on a game about operating an underwater base but it was taking me too long to figure out what the game is actually about. I mean, okay, yes, it’s about an underwater base, but the game I want to make which is part economic sim and part micromanaging the staff was again reaching beyond my February grasp. Instead I cranked out a quick idea I had about manipulating Conway’s Game of Life. The game, Death to Conway, is a turn-based simulation of the Game of Life, and you’re given an opportunity to kill an extra cell in between generations. Excitement? Thrills? Who needs em! We’ve got cells, lots of terrible cells, and they must all be killed!
Play Now (in browser)
This was another HaxePunk joint. HaxePunk is sort of in flux now as the developer is making some additional changes to better support hardware acceleration on native targets, so I rolled back to HaxePunk 1.72a to build this one.
I don’t know why I have to code everything twice. I think it’s a failure to personally commit to my own requirements. I knew I wanted to have the ability to run the simulation separate from the display, but since I didn’t commit to it at the start, I tightly coupled the simulation with the rendering system. Then of course I get the game working and realize no one is going to have an idea if they did well or not. The game showed you how many turns you took, but this doesn’t factor in how hard the level is. So then I decoupled the simulation from the rendering. Now I can quietly put it through 50 generations or so to determine how long it runs before it becomes stable, and then use this number of steps and number of remaining live cells to come up with some estimated “par” value for the player to play against. If I had simply committed to adding this feature in at the start, I could have saved myself some rework.
This will be my first Ludum Dare, but no worries. I’ll be using HaxePunk with Haxe NME so I can port my game effortlessly, and it will be quickly prototyped. This should be fun, however I will only have around 18 hours of game-making time. I’ll be tweeting as I make it at @tophattedcoder.
- Language: Haxe
- Framework/Libraries: HaxePunk and Haxe NME
- IDE: MonoDevelop
- Graphics: GNU Image Manipulation Program, Inkscape and mtPaint
- Audio: Sfxr (isn’t WINE the greatest?)
- Something to show off about.
- Make revised version of game, sell it on major game marketplaces.
Here is the progress of my game : Game Console Story.
As this name implies, the game will talk about the evolution of the game consoles.
It is a “grow game” : you start with the Atari 2600 then you do grow this console using technological advances on it. The goal is to achieve the best console ever.
I made the organization chart, a bit of code and 2 little assets :
Here’s my brief Postmortem for my game Tiny Crash Landing.
Play the game Here:
This is my first game I’ve made for Ludum Dare! I had to be part of the 10th anniversary.
What went well:
Art – I spent around 5 hours the first day doing the main tiles and character art+animation. I used Photoshop for doing animation for the first time, it’s not that well suited to it, but I didn’t want to download and mess around with any new software. I’m quite pleased with the character and animation, especially since I did it in a few hours.
Music – I think I spent about an hour making the music and sounds. I’m glad I made the music before I began programming, otherwise I would not have had time for it at the end. I mostly randomised some notes and played around with SynPlant and added some filters and stuff until it sounded ok!
Sound Effects - I mostly used sound effects in place of proper presentation, since adding a sound effect is a lot easier than adding a proper intro/outro screens. The only difference between what happens when the player wins or dies is the sound effect!
Programming – I liked my decision to use Haxe/NME I haven’t been using it more than a couple few weeks but I think it’s very easy to pick up for ActionScript users. I got a lot of code written, but most of it wasn’t gameplay code.
What did not go well:
Programming - I completely ran out of time regarding the code! I probably spent around 3/4 of the time doing code, but didn’t really get enough done to make a complete game. I think the biggest problem was I was coding everything from scratch, so I spent most of my time writing a blitting renderer, collision code and a scrolling camera etc and not enough time on actual gameplay.
Missing Features – I had no time to add an options menu with a mute option, or reconfigure keys. I had planned on having enemies, that is why the guy can shoot, but has nothing to shoot at! I also planned on having procedurally generated maps that wrapped around, I also planned on having a minimap that revealed as you explored. Story was also a main part, but I will save that for the post Ludum Dare version.
I haven’t had a lot of feedback yet, but all of the feedback I’ve received so far has be very positive and constructive over all. I’m very pleased that people have complimented my art and audio!
What I would do differently next time:
Use a game framework, or make my own! I should have used a framework like Flixel or Flashpunk so I could focus on writing game code instead. My goal before next Ludum Dare, is to get familiar with Flixel/Flashpunk so I could use them in a 2 day jam.
Until next time:
I would like to work on a post Ludum Dare version of my game, with story, extra characters, proper procedurally generated maps, enemies etc.
Thanks for reading, now I’m off to play and rate other people’s games!
For LD23 I decided to use Haxe + NME to develop a multiplatform game.. so my game it’s a one button multiplatform platform game
I had two issues regarding Android version: scale and sounds.. the scale issue was solved by reading the documentation, and the sound issue was an incorrect asset type declaration.
This is my entry running in a Samsung Galaxy Tab:
You can download the Android version or try the flash and cpp version here
Good luck to all!!!!
Wow, NME works great thanks all people working on NME/haXe.
So I have submited my game and it is working on:
- Android (http://games.corne.info/LD/LD23/release/dist/astronautics-android.apk)
- Linux (http://games.corne.info/LD/LD23/release/dist/astronautics-linux-x86.tar.gz)
- Windows (http://games.corne.info/LD/LD23/release/dist/astronautics-windows.zip)
- HTML5 (http://games.corne.info/LD/LD23/release/)
- Flash (but the stars on the background) (http://games.corne.info/LD/LD23/release/dist/astronautics-flash.swf)
Not tested but compiled:
Not able to compile but probably working (Thanks Apple)
What went well:
haXe + NME, the cross platform compiler + its graphical friend. I never thought I would be able to deliver so much version of my game without having to change anything in the code (except for a -1 to 999999 for the HTML5 version). During this two days I was compiling to random targets and if something didn’t work on a version I didn’t have to check a very long script. And a few times it saved me from code that wasn’t correct. On some platforms it did work, but on one platform it got some problems so I knew something wasn’t right.
Inkscape, I didn’t know that I could draw planets so nice. I impressed myself this weekend (thanks LD).
What went wrong:
I think the game has still some memory leaks. But I’m not able to fix that in time, IF i’m even able to fix it. It is possible that it is a bug in NME. And second, my code is a mess. Long time no scripting didn’t make it better.
But I really like the product I have made this weekend.
If someone one a mac knows how to use haXe + NME. Could you please download the source (http://games.corne.info/LD/LD23/release/dist/astronautics-source.tar.gz) and compile it for iOS/OSX?
My entry: http://www.ludumdare.com/compo/ludum-dare-23/?action=preview&uid=4506
I submitted my entry: Haxe Planets.
It’s a one button platformer made in Haxe + NME.
Obligatory screenshot of final release:
Things that I couldn’t finish: better graphics, better music, more enemies, O2 tanks, time restriction… a second mission Having no time to improve the music is the worst part
I chose Haxe+NME to release the game in diffent platforms. I tested the game in Flash, HTML5, Android and Windows native and it works very well, except for the music, that only works as expected in Flash. I will try to correct this issue and let you know.
Best luck to all!!!!
Finished the bug hunting plus minor tweaking ( like volume control)
You can check my game in the list :
There is a secret level to be found ! Don’t hesitate to comment if you find it but don’t say how you get there so everyone can search for themselves.
The quality of the background vary from levels. I admit I am really not good at graphics
I finaly have a playable version of the game Now I only have to fix some bugs and than I can add additional stuff.
You can play the HTML5 version here: http://games.corne.info/LD/LD23/6/html5/bin/
Used so far:
- Planet are being spawned
- My rockets flies and attaches hisself to the planets
- Gameover screen
What I want to add:
I decided to make a small plaftorm game using snow globes
I have my platform engine running and created a small editor to make the levels. But it seems my system is flawed and I got some collision problem. I should have gone for a classic grid collisions instead.
demo is up here (contains collision bug right now :/) : http://ttermeer.com/ld23/
Well back to fixing my collision problem before making the next levels
First part of the game is done. A multiplatform intro screen. It doesnt do much than only show the logo and some stars. But it does work and I like that .
You can view HTML5 version over here: http://games.corne.info/LD/LD23/html5/bin/
A photo of Android, Linux and HTML5 version:
- WebOS (maybe)
And if someone else will compile it for me:
First time for me. Curious to see what I can come up with, even if my graphic skills are just terrible
Here is what I plan to use :
Language : haXe
Engine : haXe NME
Targeted plaftorm : Web (Flash, maybe HTML 5 is NME output requires no tweak), Windows.
I only used haXe twice so far so my knowdlege ain’t very strong however it is fairly simple to use as it is based on AS3. It will allow me to target any platform I want in the future ( even mobiles, mac and linux).
NME is a flash like API. Same structure with Stage, sprites and so on but with a much faster rendering (at least on the mobile test I did)
I will posting my progress on my G+ profile, you can follow me on :