E02 Multiplatform 2D Game Engine

New to v11.09.18:

Keywords/Expressions - Replace certain Math and Conditional Commands with a friendlier expression syntax; use variables/values right in the expression

Sprite File and Sprite Editor - A new Sprite File format has been created to replace the textual Sprite Data from Character/Object Defs, and allow Sprite Set and Sprite Frame lists to be manipulated from within the Sprite Editor, including importing new Frame graphics from external images

Stamps- Structures larger than a single 8x8 Tile can be combined to form "Stamps", which can be used in the Level Editor's new "Stamp Draw Mode" to build levels more quickly. Functions similar to the existing Copy/Paste feature, but Stamps can be cycled through like Tiles, and are displayed below the cursor while editing

[See the What's New document for further details, more updates, and older versions]

--------------------------------------------------------

E02 is a versatile, performance-oriented engine for creating many different types of 2D games. Any game developed with E02 will run on any supported system (assuming the spec of the lowest-supported system has been considered), which currently include: DOS, Windows, Linux, Intel/PowerPC MacOSX, PSP (Custom Firmware), Wii (Homebrew Channel), and GP2X Wiz

For more information, check out the official site:
http://stealth.hapisan.com/E02

Games currently in-development for E02 include:
Megaman: Triple Threat - http://stealth.hapisan.com/MMTT
Sonic the Hedgehog: Project Mettrix - http://stealth.hapisan.com/Mettrix

Currently-Available game templates include:
Generic Template - Just enough to be able to put something on the screen and fiddle with it
Sonic the Hedgehog Template - Made from the same scripts and data as Project Mettrix; demonstrates basic Sonic 3 gameplay for Sonic and provides a basis on which new levels, enemies, items, and abilities can be added (At present, this large template has not been updated to use the Alias system introduced in E02 v11.08.11. This update is in progress, and will be released when it is complete)
http://stealth.hapisan.com/E02/#Templates

For discussion and support, visit the Forum:
http://stealth.hapisan.com/Forum

Or the official IRC channel:
Server- irc.badnik.net
Channel- #OC

The following resources are also available for instant update notification:
http://www.twitter.com/E02Stealth
http://www.youtube.com/OCStealth

 

That's always a difficult question to answer, because I obviously know the thing inside and out :P

I don't know much about Actionscript at all, and don't have all that much actual experience with Game Maker, but I can tell you that it's significantly different from working with GM. You'd be doing the majority of the work external from E02 itself- You'll need to use a text editor of some kind to create and modify the Function scripts, as well as the scripts that link everything together and control other aspects of the game, and you would probably want to do a large portion of your level creation work (at least the initial portion) in an external graphic editor and then import it with the Tile Ripper, though, the Tile and Level editors are accessible from within the game to do touch-up work, or any larger tasks you become comfortable with using them for. I assume, though, that the limited C experience, at least, has prepared you for working without a drag-and-drop kind of environment

The Functions are written in a language that more than one person has compared to assembly, rather than something "high-level" like C. I'm entirely aware of the fact that that sounds very intimidating (as I was intimidated by assembly itself at one point), but the real similarity is mostly in the fact that it's instruction-based. One step at a time, one instruction per line, which becomes most noticeable when performing math operations, for example (no single-line expressions), but there are plenty of higher-level operations that can be performed with single Commands, too. Check out this movement Function for a BuzzBomber, for example:

http://stealth.hapisan.com/E02/ForumStuff/BuzzAlias.txt

Other than that, the best I can tell you is that it really depends on your dedication. You'd get a whole lot more out of running through some of the documentation to get a better feel for how some of it works, since all of the information is in there, and you can decide how to read it to best get the exact information you're looking for. Try having a look at the Getting Started document and following any links that catch your interest

There's also the very underfeatured Generic Template mentioned above to start out with, and the Sonic one for when you're comfortable with working with something larger in scale. If those don't get you very far, I do plan to do some other template/tutorial sets for other features or feature groups, but I haven't gotten around to starting any yet

 

It's really not that bad once you get into it. If you already know how to program, I don't think you should really have any trouble with it at all. The big thing about assembly is that it looks arcane, you have to deal with swapping things in and out of the registers and managing the stack manually all the time, and as far as it goes for me, I get the impression that I was basically taught to fear it. The Commands in E02 should look a little more understandable than the usual assembly instruction set, and you don't have a limited number of on-processor registers that you have to constantly make use of to get any work done, nor do you have to use a stack to keep up with them between routine calls, because most of the time you're not going to end up clobbering them

I think the biggest issue is, again, stuff like breaking expressions up into a series of individual operations, and it's really not that difficult to get a handle on

Some people seem to think that, though more in relation to SonED2 than E02. Come to find out, though (if my memory serves correctly), aside from drawing the bitmap form of some of the art on their "Digitizer" machines, they (Sonic Team, at least) actually created their data by hand by entering the raw hex values. There were some other level creation utilities and corresponding libraries that came around later in the same era, though, some of which supported multiple platforms

Thanks :P

Some of the way E02 works lends itself well to performance. The tiled levels, for example- It's a much faster method than some other systems use; they use a ton of freely-placeable, freely-sizeable objects to draw up a level, which take more processing to render, and would usually all have to be tested against all objects at all times for it to actually work

Well, again, I think it's a lot simpler than it looks at first. Since you have some general programming experience, it shouldn't be much of a stretch to get a handle on using E02's Function scripting. Remember that the forum and IRC channel are available if you get suck on something :P

I don't like to discuss plans or future features for my projects because I don't want to start making promises about doing or not doing anything, or when anything will actually happen. But, I guess I will say a few things:

-I wouldn't count on an IDE. It's not really necessary, so my time would be better spent on making other parts of E02 more powerful, for the moment. I don't disagree that there could be some advantages, but there would be so much work involved with design and implementation that I would end up putting off better features for too long
-Support for scaling, rotation, and high-color effects like blending all lead to overhead and a performance loss. For this reason, I haven't touched them. I'm also not working with high-color effects because I'm not comfortable with breaking out of 8bit graphics with it at this time (as it is, the DOS version wouldn't be able to support high-color games). There may be a way to handle something like scale/rotate on an individual sprite basis that wouldn't impose on non-scale/rotate sprites, but it's not important to me to look into it very thoroughly right now. As for blending, I probably wouldn't go beyond allowing a single-color alpha overlay in levels using 64-color mode. If I were to implement any of these things, though, I would very strongly discourage their use. Often they're used unnecessarily, and both the end-user and developer suffer for it
-Commands for drawing primatives will probably show up. Aside from the _Debug_Draw Command, they would be the only use for Scripted Drawing Functions

In short, though- E02 is pretty much as-is. I don't plan to stop working on it anytime soon, but I'd really advise that you base whether or not you're going to use it on the current release, because many things won't change, and I can't say what additions will be made, or when they'll be made

 

There's not much to the Function syntax, just provide a Command and its parameters, and perform one operation at a time. You'll notice that many of the basic Aliases (which, if you haven't noticed, have replaced the Command and Variable IDs in the recent update) look like C, and for the most-part, the ones that don't are higher-level functionality that might as well be equated to library function calls. The only thing that might be a little tricky about basic function creation is the "fetching" aspect, but it shouldn't take long for it to become clear how it works

I certainly wouldn't say that, considering what E02 does take care of on its own. You will do a lot of coding for a complex game, but that's true of pretty much any system. It's my understanding that lot of people are putting a lot of their own work into Game Maker games lately, or are at least relying on other people's major works, which would be easily relatable to my templates. As I stated in a previous post, I also intend to create more basic and advanced templates that can be built upon or harvested for functionality

One of the benefits would be one of the "advertising" points- It's multiplatform. You fill in the assets and game logic, and you get it running on about 7 platforms for free- there's absolutely nothing else to do

You're also not only getting the low-level handling of graphics output taken care of, but sound output, and key/button input. As you said, there are APIs to take care of that (although, even of the ones that are multiplatform, I don't think they have this broad of a range), but it's not just that. You're also getting other game-internal systems handled for you, and I've expended alot of effort in designing them for both functionality and performance. Some of this includes:

-Level and Tile management- automatic tiled scrolling with available fine-control through script, dynamic level segment looping control, automatic tile animation, automatic and script-controlled palette animation, easily-swappable palettes, a couple of useful tile property settings

-Although Levels are created with Tiles for performance, there is still functionality available to use mobile objects that have a collision reaction very much like the surface of a level

-A few sprite features such as multiple boundary boxes of three different types for each frame

-Animation management with a few accessory features such as allowing more than one animation per object, and assigning any of them freely-controllable offsets, while taking all visible frames and their boxes and offsets into account for any collision testing

-Object handling system- priority and other list management such as insertion and removal during spawning and destruction, fine level collision with or without path following, pretty much an "interrupt" type system to test for and manage object/object and player/object collisions the moment they happen (in-hand with the "phase" management for calling the individual function types, such as movement, drawing, and collision), "activity range" and resetting, four-level object freeze control by flags, etc

-Player handling system- all the benefits of individual objects from the object system, but with better path management, a few other accessible built-in statuses and controls, "key events" for reacting to input, "movement modes" for managing player state and separating the key events, "Boundary Events" for automatically triggering functions when the player or his camera enter defineable areas, a modifiable "animations list" for dynamic animation selection control...

-The "Status script" system that provides easily-managed movable "objects" (fixed or variable text, or sprite graphics) with absolute or relative positioning and with nestable draw windows, and "selections" for managing menu-style input, useful for HUDs, Title Screens, menus, etc

-The "Functions" system is like a multi-tasker to some degree; it's separated into a few processors such as the general functions, various function types for each player, various function types for each object, status script functions, tile plane control functions, music-controlled "XM event" functions, etc, all of which can be made to start or stop the processing of other functions (including manipulating other processors, to certain extents) at any time, and each of those functions can be made to "break" at any point to move on to the rest of the game before they continue processing, at which point, they'll return to the exact point at which they were told to "break"

-A few more powerful script commands to take care of certain high-level tasks with a single call

-The Utilities for data creation and manipulation (such as Level Ripper [which is also available in the "utilities" menu in the interface, although only the command-line version is documented], Tile Editor, Level Editor, Sprite Editor, Object Layout and Status Editor) are not only available, but can be accessed at any time during gameplay for quickly checking up on issues and/or making and testing adjustments

I'm probably leaving stuff out, too, but I think that the fact that E02 handles all of that, and handles it well, makes it very useful

 

Try downloading it again. It seems that the last time I put together the full mac archive, I ended up omitting one of the files... sorry about that

Whenever the Mac version seems to just plain quit like that, it might output some information about the issue if you try running it from a terminal window (it depends on what the issue actually is, but most missing file and script syntax errors should show)

If you're doing your initial work in an external graphics editor, you'll be able to work with portions of any size you want. Once the art is imported, it will be broken into 8x8 pieces for the engine, but there's a selection copy/paste functionality in the editor that will let you draw larger groups of tiles to the level all at once, and if you hold down the paste button and drag, the copied section will be pasted beside itself as if on a grid. Whenever I need to work with larger placeable level bits, I keep a list of them either way off to the side on my working plane, or I'll keep them on a separate plane that I can switch to and from

Thanks!

It's not exactly meant to work with the same types of interfaces as MMF/GM, but it does have minimal graphical interfaces for level editing and manipulating objects that are already placed into the level (which is actually done by setting up a method to switch the player character to a placement mode during gameplay) and sprite frame properties such as draw offsets, collision boundaries, and hotspots (I mention both since I'm uncertain of which one you're referring to as "sprites")

I should note, though, that E02 itself hardly does anything specifically related to Sonic, but it does provide enough functionality and control over the game to allow something like that to be recreated accurately

Well, Allegro is advertised as a "game library", rather than a "game engine". You could put as much as you want into a library, but, at least for me, describing something as an "engine" really seems to indicate that there is a lot more going on. You're still going to have to customize it to get exactly what you want out of it, but the lower-level stuff is pretty much already taken care of. Libraries are generally meant to provide functionality for you to call on while you're building the "engine" yourself. They're not particularly comparable

But that is basically also to say that you seem to be right about E02. You fill in the assets (graphics, music, level data..) and game logic (the code to define how objects move, how their collision settings are used and what to do upon collision, how the player moves and responds to input...), and E02 takes care of the rest of it itself (it performs the actual movement and collision tests and such, and as a more direct response to what you said, it handles all of the calculations and actual blitting to get the sprites and level layout onto the screen based on their current position and animation, and the camera position and scroll settings, respectively)

I am also a person who can really appreciate well-done palettized 2D graphics. Not that there's anything wrong with 3D or realism when they're also handled well, but I am pretty fond of this sort of thing

As for the availability of large amounts of RAM, you're still limited by the spec of the least powerful system that you want to support, and there are a few differences between the way things work with E02 and the way most games on a system like the Genesis work that actually make E02 use significantly more RAM. That's not to say that you can't still pack more into it, but it's something to consider when trying to determine exactly how much

 

New to v11.09.18:

Keywords/Expressions - Replace certain Math and Conditional Commands with a friendlier expression syntax; use variables/values right in the expression

Sprite File and Sprite Editor - A new Sprite File format has been created to replace the textual Sprite Data from Character/Object Defs, and allow Sprite Set and Sprite Frame lists to be manipulated from within the Sprite Editor, including importing new Frame graphics from external images

Stamps- Structures larger than a single 8x8 Tile can be combined to form "Stamps", which can be used in the Level Editor's new "Stamp Draw Mode" to build levels more quickly. Functions similar to the existing Copy/Paste feature, but Stamps can be cycled through like Tiles, and are displayed below the cursor while editing

[See the What's New document for further details, more updates, and older versions]