TIGSource Forums

Tengoku is a component-based game engine that I'm working on, written in Forth.  

Component-based systems are the newest trend in game development.  What "component-based" means, is basically, that you can add features to game objects randomly, without a class hierarchy.  In some systems, you can add and remove functionality from game objects while the game is running.  Tengoku is one such system.

In Tengoku, it has its own OO extension to Forth where there is actually no inheritance at all, everything is done with aggregation and interfaces.  This has made things overall simpler, because I never deal with tangle-y inheritance issues.

Part of what this project is all about is enabling faster, interactive development.  Forth's crazy-fast, interactive compiler helps with that.

Tengoku is actually an SDK containing multiple libraries, one of which is the engine itself, which I've called Lotus.  Lotus is intended to be the first of a series of engines that are optimized for certain spectrums of games (and will in some senses represent a linear advancement in terms of speed and capability).

Project page is here (http://code.google.com/p/tengoku-engine/downloads/list)

Download here (http://code.google.com/p/tengoku-engine/)

Blog is here (http://tengoku-engine.blogspot.com)

Here's a feature list with more-or-less-current progress next to each. I'll try to update it whenever I post new builds.

As of version 1.41.3.0:

Version 1 documentation - 10%
Official support for 2D games - 80%
Custom object-oriented language without inheritance; uses integration, interfaces, generics, and "delegation" (a form of multiple inheritance)
Collections with generic functions - 90%
Double linked list-trees (Nodes) - 100%
Lists - 90%
Stacks - 100%, might be scrapped and functionality moved to lists
Wordmaps - 100% with some room for optimization
Independent heap - 100% with some room for optimization
Support for static and dynamic objects; but thanks to specialized heap, dynamic objects can be created at compile-time - N/A
Fixed point math - 80%
Fixed point vectors - 80%
Quicksort - 100%
Filesystem access, with STDOUT-like mode for text output functions - 50%
Bindings to OpenGL, including support for OpenGL extensions - 100%
Bindings to SDL, Sprig, FMOD, DevIL, more - 60%
Mouse and keyboard input - 60%
Color manipulation - 80%
Collision detection routines - 60%
Tilesets and Tilemaps with collision detection; lets you pack sprites into a tileset for game characters too - 90%
Retained-mode accelerated drawing, with VBO support - 90%
Immediate-style primitives (rectangles, lines, ovals, etc) - 90%
Support for all major image formats thanks to DevIL - 99% (BMP's come out flipped)
High performance cooperative multitasking system enables coroutines like Unity, though much easier to use and more flexible (sorry, I just realized that that's unqualified) - 100%
Flash-style tweening - 100%
Profiling (there's no "goal" for this so no progress %)
Component-oriented engine - 90%
Interactive Debugging and Compilation - 90%
Generic frame-based animation system, can be used for tile, sprite, 3D model, or anything - 90%
Global 2D collision component - 90%

In-dev:
  GUI - 5%
  Appmanager OS for creating custom game-building tools that run "inside" the game - 10%
  Resource manager for automatically loading assets - 10%

TODO:
  Resource embedding into executable (have old code for this, need to port)
  ODE physics (or maybe Chipmunk)
  SSE math
  text drawing support (port old code, maybe start with monospace just to have something quickly)
  spritesheets (old code)
  Sound and music (i'm planning on using the BASS library, being the only API I can access via Forth that isn't prohibitively expensive for indie devs)

Posted build 1.41.3.0 and updated the OP

Engine 1.0 is feature-complete but still alpha.  The only thing that remains is a refactoring to make things cleaner and that will probably make the API mutate a bit.  After that, it will be promoted to beta.

I noticed interest took a sharp dive, which I guess could be expected from an engine that's in alpha so it can't really be used for anything serious until it's 1) finished and 2) documented.

I was wondering if anyone might mind filling me in on why you personally decided not to try the engine, or, if you did but gave up, why you gave up on it?   I guess those are the two hypotheses I want to test.

It partially doesn't matter to me, I'm finishing this thing and using it for my own stuff, but, you know, feedback is nice. :)

Well, it looks interesting, but I really don't have time to make games this semester, and I especially don't have time to learn a new language and make games. I started messing with forth a little when you first posted this in technical, and if I had a lot more free time, I might spend a while learning this.

Really interesting ideas!
The interactive compiler of Forth sounds really sweet.
How is it with crossplatform compatibility?
Am i expected to write games in Forth or are there bindings for other languages? Because skimming through the wikipedia article about Forth gives me the impression that its a pretty low-level language for system purposes.
A personal wish would be for python bindings.

There is no cross-platform support, yet.  It could be ported to other Forths - that's probably any platform you could think of - but this might not happen until up to a year from now, best guess.

As for Python bindings?  Well dude, it's a Forth SDK.  Would kinda defeat the purpose, wouldn't it?  ;)

I thought about this, and thought I should respond.  Python is fine, but Forth is not limited to its low-level core functions, I took Forth and extended it to be very high level - that is what you do in this language.  Because I wanted them, there are now lists, dictionaries (but I call them "wordmaps"), interfaces, components, and highly abstracted objects.  The thing is, all this stuff is tightly coupled to the Forth language, and ultimately, making it accessible from another language would be moot.  You have to think of this as a custom language in and of itself, specifically designed for the purpose of writing games.  Providing bindings to Python would be pointless, after all, there are libraries that do more than this thing does.  It's just the WAY I do it that makes it valuable.  I'm advocating Forth as an easier and (potentially) attractive language for game development.

Forth used to be the language of choice for astronomers. I don't know why though.

Development marches forward.  I guess you could characterize this as a "cleanup" phase.  After this, Tengoku as an SDK will officially go into beta featuring its seminal game engine that I recently called "Lotus".

@moi Probably because it's a great language for experimentation; it lets you explore things.  It is more aligned to giving you ways to basically fiddle with bare metal.  Writing drivers for modern hardware is never fun though.

Forth is heavy factoring.  It's encapsulating sequences of operations that in other languages you wouldn't normally (or couldn't normally) make into functions.  This leads to a kind of new custom language every time; Forth embraces the fact that that's what computer programs really are. (After all, a big part of programming is giving things names, right?)

What's this? a GRAPHICS EDITOR???  :monoclepop:

(http://rogerlevy.net/images/gedi.png)

I don't know why people aren't already doing games for this engine, it looks awesome!
Plus forth! (+5 nerdery)

Thanks.  :)  Actually it's been incredibly buggy and muddled up til, like, last week.  So I don't blame anyone for abandoning an alpha projie.  It is definitely shaping up now, though.

Hmmm. Sometimes I wonder if it would make sense to create a DLL version of the engine.  But I it's only a hunch that I don't know the rationale for, besides I guess allowing others to use it in whatever language.

 :-\

I was bored so I decided to add a little tilemap editor so you can use the graphics editor to create tilesets more easily.

(http://rogerlevy.net/images/10-8-2010_1158pm.png)

check it out, here's all the source code for that little box.  you can place tiles, pick them up, erase them, and flip them horizontally or vertically (and clear the flip)

I've updated the quick start guide.  http://code.google.com/p/tengoku-engine/wiki/QuickStartGuide?ts=1286850746&updated=QuickStartGuide

I am going to write some general overview docs shortly and upload a new build since quite a few parts of the API are solidified and stable.

Hey if I posted a link here to the graphics editor would people be willing to test it?  I have no idea how reliable it will be in the outside world.  It would be so so helpful I would love you.

Started a Mercurial repository today.  Mostly because my thumb drive crapped out.

Yeah sure.