About this blog
Projects, Games, Code, Tutorials...
Entries in this blog
Note that this is a replicate of my recent website post.
I just watched the second part of looking at XNA and am speechless. Deploying, running, and debugging an XNA game straight from Visual Studio, on an Xbox 360.... Wow.... I'm really looking forward to getting my hands on that Creator's Club certificate.
Wow, it has been a while. I should really make it a routine to write something either on here, or the new website!
The old site was hacked together and I didn't really know how Drupal worked when I put it together. This new version uses Drupal 5.0 and actually uses it correctly and looks pretty clean too; I like it. The image gallery isn't quite an image gallery though, I'll have to figure that out later.
Last week, I attempted to install Linux on my system and accidently screwed up the partitions. So I formatted everything and installed Windows Vista RC2. This happened just before Vista went RTM too, unfortunately. Looks like I'll have to get myself a copy of Vista release once it's around. So far it has worked with everything quite nicely....
So, I switched web hosts and moved everything over to the new host (TIGC, Slylabs, and Rob Loach .Net). The sad thing is that robloach.net kinda broke in the process. I think I'll just until wait the next version of Drupal comes out to fix it...
Speaking of Drupal, Krisc and I started up OpenXNA to take advantage of all the new space and bandwidth I have. Its goal is to bring together a community of XNA developers by providing a place to put open-source XNA projects, libraries, tutorials and resources. Krisc started up a his new version of Dx5D, which would be pretty neat to see, and I uploaded PongXNA and BrickBust (including on http://svn.openxna.net).
What OpenXNA needs is more contributers, a good theme, a bit more organization, and it'll be good. So, if you want to put some XNA stuff up on there, feel free to register!
"Eat my shorts!"
Seeing that I had never made a breakout clone, I decided to throw one together, while still experimenting more with XNA.
Look Behind You!
After a bit of fooling around in XNA a bit, I (almost) made an XNA renderer for CeGuiSharp. There's still a bunch wrong with it and I'm not quite sure that I'll continue to hack at it. CeGuiSharp is such a mess and it's almost worth a complete rewrite from scratch with a new design. But you can see what came out from CeGuiSharp through XNA on the right (click to enlarge).
Another thing I've discovered is the use of GameComponents with XNA technology. You have the ability to drag these components onto the designer and then the components will automatically start-up, update and draw for you without you haven't to code anything. It's pretty neat and making them is rather fun. I had a try at it with making a couple of them:
Once you give the BitmapFont the data file and image file generated from LMNOpc Bitmap Font Builder, you have the ability to easily draw text on the screen.
Using a BitmapFont for rendering, the Framerate component will tell you how fast your application is running
A bad thing about the XNA input framework is that it doesn't provide events to any of the input methods so you're left to instantiating KeyboardState, MouseState, GamePadState, etc. The Input component fixes this by providing a number of user input events (KeyDown, KeyUp, MouseMove, GamePadButtonDown, etc).
I'll get around to making a game using these components and publish the source. Maybe a Snake clone because I haven't done one of those yet.....
Dubbed Power Rangers, Bitch
As most of you know already, the XNA Framework beta was released so I thought I'd give it a try. It apparently requires Visual Studio 2005 C# Express (VS2005 Standard doesn't cut it), so I had to install that. Once that was installed, I loaded up XNA, ran one of the demos and kept on getting the following error:
It was time to upgrade my eight year old machine. I've had problems with it in the past anyway. The power suply was dying, it only had one USB slot, the fan sounded like an airplane. I needed something new.
So, I got a laptop. I got a Fujitsu Lifebook S Series and you can see the new rig that I have setup with it on the right. When I place it in its dock, it hooks up to the monitor, keyboard, stereo, mouse, ethernet LAN, etc. It works quite nicely and I'm really looking forward to trying it out in downtown Toronto with the new wireless network.
Here are the specs:
Centrino Duo T2400 (2 1.83 GHz Processors)
1 GB SDRAM
Mobile Intel(R) 945GM Express Chipset Video
TouchPad and TouchStick
14 Inch Monitor (1400x1050)
The first thing I had to do was test it with some games:
It barely runs Doom 3
Half-Life 2 runs at minimum graphics
Civilization IV runs perfectly (Yay!)
N64 Emulation is perfect
Couldn't even run Elder Scrolls IV: Oblivion
Guild Wars is beautiful
Beyond Good and Evil works, of course
After playing around with some games and picking up an Xbox 360 Controller for Windows, I thought I'd finally get back to trying out XNA. I went through the first XNA tutorial without any problems and it worked on the new laptop.
The Pong challenge was next on my list and here is the result:
What's next, you ask? I've been trying to figure out how to write XNA Game Components. Something where you can just drag the component onto your designer form and it would render the component. I'd like to have a small toolset of XNA components ready for use in any XNA application (think Framerate, BitmapFonts, Console window, etc)....
In the Event of Snakes on Plane
I've made some progress on the 2D platform gaming goodness also known as Hazardous Hal:
(click to enlarge)
A lot of things were redesigned, including a state system for the player. This means that it's much easier to manage whether they're falling, jumping, standing, etc. It's also very easy to add new states because you just derive from a class instead of checking tiles all the time. So far there's just HalJump, HalStand and HalWalk. Another thing the state system allowed is the ability to do high jumps by just holding down the jump key longer. The effect works very well, and is rather seemless...
The great thing about the system that's setup is that it's all completely exported from Tile Studio. This means I can completely change the level details, graphics, player details, animations, etc all through Tile Studio. If you take a look at the image on the left, you'll get an idea of what I'm talking about. It works really well so far, and I'm looking forward to seeing how it progresses.
What I need now is a design document and know where to go with it. I'm thinking about implementing Dangerous Dave with the technology, but still have to work on the backend stuff first. I'd have to find all new graphics, or, of course, steal some of Stompy's Goodness. What I have now will work until I get a design document going.
BooGame and Mono
I've decided to postpone work on BooGame until Hazardous Hal is finished. This will allow me to actually complete a game before going back into the grind with making BooGame compatible with Mono. Making BooGame Mono-compatible will be a big job:
Port BooGame to Boo
Debug BooGame with Mono
Get rid of Mono-related bugs
Debug some more
Tear out hair
Debug some more
" target="_blank">Mat Weddle of Obadiah Parker - "Hey Ya"
I have great, good and bad news.
I'll start with the great news:
Mono has setup a Mono VMware Image, which you can run SUSE ready packed with Mono through VMware Player. It's very nice because it lets you test our some of your .NET/Mono projects without having to reboot into a different operating system.
Mono VMware Image In Action (click to enlarge)
Now for the bad news: I decided to try out the Mono VMware Image with BooGame and discovered that some parts of BooGame don't work in Mono, making it very buggy on Linux and Mac. This is mostly because of the incompatibilities with the System.Drawing namespace between .NET and Mono. I'll have to find another way to get font rendering in BooGame to work for Mono support. Come September, I'll hopefully have a lot of time to hack away at it.
Now for the good news: Taking advantage of BooGame's sprite and tile engine system, I decided to put together a platform game. Stompy999's Stompy's Revenge was just so well done that I wanted to put out my own platformer. A big inspiration of mine way back in the day was Dangerous Dave, I wanted something along the same lines. Something that's simple, yet fun to play. So, I quickly came up with the name of Hazardous Hal.
Hazardous Hal First Stages (click to enlarge)
At the moment, I just stole the Mario graphics because I didn't want to worry about graphics at the moment. When you start a new game, you're thrown in this world, and you just have the ability to jump around, colliding with the blocks. The level itself was created through Tile Studio and the blocks arn't interactive yet. I don't even know if I'll use these blocks as I might end up just recreating Dangerous Dave using BooGame. In any case, it's pretty neat so far and I'm looking forward to see how it progresses.
Anyone else a Dangerous Dave fan?
The Super Mario Brothers Super Show!
One of the first graphical video games was Pong, so I decided to implement it using Boo and BooGame:
The source is quite easy to understand if you take it one line at a time:
// A Pong implementation using BooGame
// To run, drag ontop of BooPlayer, or run BooPlayer BooPlayerPong.boo
// By: Rob Loach (http://www.robloach.net)
public class Pong:
static font = BooGame.Font(FontFamily.GenericMonospace, 30, FontStyle.Bold)
static player1score = 0
static player2score = 0
static player1 = RectangleF(20, Display.Height / 2f - 25,10,100)
static player2 = RectangleF(Display.Width - 30, Display.Height / 2f - 25, 10, 100)
static ball = Circle(Display.Width / 2f, Display.Height / 2f, 15)
static ballSpeed = Vector(250, -350)
static originalBallSpeed = ballSpeed.Length
static playerSpeed = 300
static def Draw():
// Draw the score and players and the ball
font.Print(player1score + ' : ' + player2score, Color.White, Display.Width / 2f, 0f, ContentAlignment.TopCenter)
static def Update():
// Move the ball
ball.X += ballSpeed.X * Timer.DeltaSeconds
ball.Y += ballSpeed.Y * Timer.DeltaSeconds
// Move the players
player1.Y -= playerSpeed * Timer.DeltaSeconds
player1.Y += playerSpeed * Timer.DeltaSeconds
if ballSpeed.X > 0:
if ball.Y player2.Y -= playerSpeed * Timer.DeltaSeconds
elif ball.Y > player2.Y + player2.Height / 2f:
player2.Y += playerSpeed * Timer.DeltaSeconds
// Bound players and ball on screen
if player1.Y 0:
player1.Y = 0
player1Speed = 0
if player1.Y + player1.Height > Display.Height:
player1.Y = Display.Height - player1.Height
player1Speed = 0
if player2.Y 0:
player2.Y = 0
player2Speed = 0
if player2.Y + player2.Height > Display.Height:
player2.Y = Display.Height - player2.Height
player2Speed = 0
if ball.Top 0 and ballSpeed.Y 0:
ballSpeed = ballSpeed.Reflection(90)
if ball.Bottom >= Display.Height and ballSpeed.Y > 0:
ballSpeed = ballSpeed.Reflection(90)
if ball.Right 0:
ball.Location = PointF(Display.Width / 2f, Display.Height / 2f)
ballSpeed.X *= -1
ballSpeed.Length = originalBallSpeed
elif ball.Left > Display.Width:
ball.Location = PointF(Display.Width / 2f, Display.Height / 2f)
ballSpeed.X *= -1
ballSpeed.Length = originalBallSpeed
// Check collisions
if ballSpeed.X > 0:
ballSpeed = ballSpeed.Reflection(0)
ballSpeed.Length += 15f
elif ballSpeed.X 0:
ballSpeed = ballSpeed.Reflection(0)
ballSpeed.Length += 15f
static def KeyDown(obj, e as KeyboardEventArgs):
if e.Key == Keys.Escape:
static def Main():
Display.WindowCaption = 'BooGame - Pong!'
Display.ClearColor = Color.Black
Core.Draw += Draw
Core.Update += Update
Keyboard.KeyDown += KeyDown
Wow, the Python syntax highlighting doesn't work with Boo at all. Anyway, all you have to do to run it is to put it into a pong.boo file, and then drag the file onto BooPlayer.exe. It would be neat to have an online database of these BooPlayer scripts of which users could connect to and run the scripts remotely. That's for later though, after 4E5 [wink].
The hard thing about 4E5 is getting the graphics. I wish I had programmer art skillz, yo....
Dark Materia Star Trek Music
Sorry for disappearing and not being around as much as I would've liked. Work has called and I have to fill in the responsibilities of about two peoples' shifts, so it has been pretty intense. I'll be on and off and hopefully be able to keep the journal posts coming.
BooGame has made some progress, including a 0.4.0.0 release. It's coming together quite nicely and is starting to develop a small community and contributers (nagromo and Pipo DeClown are huge contributers). Without the steady submission of code, I doubt I could keep BooGame running by myself.
One of the latest developments has been the implementation of an in-game console. Tied together with Boo (no pun intended), the BooGame.Terminal makes the perfect in-game debugger your code. You have access to the whole BooGame library through the console in-game. Of course if you don't want the player to access the terminal, you can simply disable it. In the example on the right, in-game, I change the clear color to Purple and add a new sprite ("pear.png") to the game state.
Next up on the menu is to redesign the Font.Print system to make it easier to work with. Although it works right now, I'd like to implement the use of text alignment. Once that's implemented, it'll be extremely easy to make a pong clone completely in Boo script to be run through BooPlayer.
Once things are settling down, hopefully I'll be able to start on the 4E5 project. I've been talking with one of my friends about the rough game design and she came up with some rather interesting scenarios involving Fabio running around Venice.
The Tile Studio Sint example is now implemented with BooGame. Again, thanks go to Scet for his brilliance (helped fix the flickering water). So far the Sint example is only available through SVN.
Sint via BooGame
I'm currently porting SdlDotNet.Particles to BooGame for some interesting particle effects. It would be pretty neat to add some particle effects to the Sint example. Maybe have it so that when the priest jumps, fire comes out of his feat/ass [wink].
Once the particle system is ported, I'll make another release so you can get your hands on the Sint example binary and check it out. Thank you to all who have tried it out so far. What other examples should BooGame implement?
BooGame is now publically available through SourceForge. You can download it or check out the SVN.
What I need are testers and input. What does BooGame need? How is it lacking? Is anything not there that would really help you out? What other examples should be provided with the library? Would a SimpleExample be benefitial? Should I provide a tutorial series? Any suggestions as to what I should do with a website for BooGame?
Thanks goes to Scet for telling me that negative numbers in Tile Studio mean its an animated tile. Now BooGame has (almost) full Tile Studio support. Download it!
Do I Really Look Like That?
By Exploding Dog
After hacking at it for about three hours, I finally got Tile Studio working quite nicely with BooGame. I used its code output feature to output script files which are then interpreted by BooGame during runtime. Here's a shot of BooGame's new ScrollDemo example:
Download Latest Build
If you download the latest build, you'll see that you use the arrow keys to move the screen around. The moving background gives a neat effect. Unfortunately I'm extremely puzzled with the animated water tiles at the bottom right of the map, I'll take a look at those later. Big thanks go to Scet on this one.
Although it might be only on my system, OpenGL misses a few pixels with the tiles. I'm not entirely sure how to fix that, but I'm sure I'll find something.
SourceForge seems like the best place to host BooGame, so I submitted a project submission form. I would host it on my own site, but SourceForge gives you a load of project management resources which are very nice for open source solutions. I should have everything moved over by next week. Until then, enjoy!
Considering the lack of updates lately, I thought I'd just do a quick post saying what has been happening.
The website has finally been switched to Drupal. Everything seems to be working and I think it'll stay like this for a while. I published an article on plugin interfaces in .NET as there seemed to be a bunch of requests for such a thing.
Should I make a SourceForge project for BooGame? I've been working on a GUI system for it lately. It's pretty difficult considering the horrible font system I put together. I wish there was an good way to render truetype fonts in Tao.OpenGl. Right now I've just been using textured fonts along with a data file saying how wide each character is.
FTP uploading is now a part of ScreenCap. I was considering auto-FTP uploads, but that would really slow down the system when you're taking screenshot after screenshot. You just drag the screenshot files onto the program and it uploads it, nice and simple.
Listen to Lemon Demon's music
It's been quite halariously busy lately between school and family matters. Becoming a news editor on GameDev has also added a daily task that takes up even more time on my schedule. I always wanted to help out GameDev as much as I can, and I think I'm doing the right thing. It's been great to work with Kevin, Leigh, Yuri, Tiffany and everyone else on the GameDev and I'm really looking forward to see how things go.
Programmer16 helped out a lot with small donation regarding ScreenCap, so I decided to resurrect the project and upgrade it to .NET 2.0. I've completely redesigned it starting from scratch and working my way upwards and so far it's looking quite nice. Expect the new ScreenCap 2.0 release quite soon.
Although e107 is a good content management system (robloach.net), there are many small issues with it. Namingly a few comment system problems and a horrible content system plugin. After talking with Leigh about WordPress, I decided to try it out (robloach.net/beta). WordPress is a pretty fantastic system for a blog, but is somewhat lacking when it comes to content management.
After that, Drupal was next on the list (www2.robloach.net). I'm really torn between both of the systems as they both have their own pros and cons. I'll have to work on both a bit more and see how things go. Which one do you recommend?
Lil' Brudder can make it on his own.
Krisc brought up a video about a Managed OS in which they talked about developing an operating system in C#. During the interview, they mentioned they were using Virtual PC for testing and this made me realize that Virtual PC would be an awesome way to test my own stuff in Linux.
So I picked up a copy of Virtual PC along with the install CD of Kubuntu and had a hack at it. This is the aftermath:
Kubuntu via Virtual PC
It runs a bit slow, but that's to be expect when it comes to Virtual PC. I think I like Gnome more then KDE when it comes to desktop environments, so I'm considering switching back over to Ubuntu rather then Kubuntu.
Although the main purpose of this experience is to test out some of my projects in MonoDevelop, it is also nice to be able to try my hand with the Linux-scene. I always wanted to try it out and now I have the chance without having any permanent screw ups with my system. Virtual PC really is an amazing tool. Which do you prefer, KDE or Gnome?
Feuer Frei - Ascii Edition
My education program has gone on strike and this means that classes for the week were cancelled. Unfortunately we still need to do all assigned work, but it does mean that I've had a few more hours to work on Gsl. Today marks a special day, the first "good" test build of Gsl:
You can download the test and try it out yourself. Left click to add a blob, right click to remove one. You can also use the up and down arrows to add and remove. You'll notice that all graphics and sounds are held in resources.zip (yay PhysFS). I got it up to 50 blobs floating around before I decided to quit.
There are three things that arn't tested in this application: the font engine, the tile mapping and the scripting interface. Hopefully next test build will feature these components, but until then you're going to have to entertain yourself with this build.
I'm going to be implementing the concepts introduced with SdlDotNet.Particles in the efforts to create a particle system for it. I should also get around to implementing a simple Pong clone, that would be nice. Also need to somehow test it on Mono (it should work).....
VS2005 TE vs Kidney
Two new releases are on the .NET front:
SDL.NET 4.0.3-1 comes with a bunch of new stuff including some SurfaceControl fixes. I'm still not 100% confident with the SurfaceControl, but it is another step towards complete functionality. An example of using Tao.PhysFS for loading surfaces from zip files is now in there and I'm glad to report it works on Mono.
OdeDotNet 0.0.1 is finally out. This is the first public release and Terry and I hope it gets some attention in the (very small) community and builds up a small user-base.
I was picked up by the CeGui# team to help out with making it independant from both RealmForge and Axiom. This will be very neat as it'll eventually spawn other renderers, like Managed DirectX and Tao.OpenGl. So far, all that has happened has been the installation of the wiki and the forum. Still need to modify those a bit to make them functional.
I took out all of the game-related code from Gsl and moved it all into a script. So, now when you run Gsl, it reads an INI file and gets some information regarding the window size, caption, and the initialization script. It then runs the initialization script and away the engine goes. I'd really like to get CeGui# working with Gsl, but that won't be for a while. Expect a pong demo soon!
I still haven't implemented collision detection (bounding box or otherwise). I'm planning on having the tile map make use of TileStudio's tile boundries for tile-based collisions. Since the scripting system is directly embeded into Gsl, a Gsl script can make a whole new scripting interface to compile different scripts or create new dynamic objects. All you have to do is (in the scripting language itself):
script = Script('myScript.boo')
script.Invoke("Main"); // Call Main method
someInstance = script.CreateInstance("SomeClass")
Not right now, I just put it there so that I knew it was working. I could easily make it blink though, good idea. Once CeGui# is faily complete, I plan on using that for the in-game console.
Gsl now has text output. After having difficulties getting OpenGL lists to work in C#, I just rolled my own system which just manually loops goes through each character. Not really the best way to do thing, but it does mean that I can do neat things like line breaks, etc.
Click to enlarge
What you see above is a scripting dog flying around the screen along with some glasses I manually typed into the scripting interpreter. Here's what I typed in the screen:glasses = Sprite('glasses.png')
Core.Draw += glasses.Draw
glasses.X = 100f
glasses.Y = 100f
glasses.Rotation = 10f
glasses.RotatAs you can see, this is quite a powerful system. You can make objects dynamically during runtime and manipulate events quite easily.
Bill and Napoleon
The iPod is quite a fun toy, although I hate the fact that you're forced to use iTunes. I've subscribed to the Diggnation Video PodCast where the majority of the episodes are just about drinking beer and talking about stupid tech stuff off of digg.com.
Now that SourceForge has SVN access, I've switched OdeDotNet to SVN management as opposed to CVS. It's a very nice service those nice guys over at SourceForge have going. SDL.NET has also made the switch.
I've decided that "Gsl" is the code-name for this engine as a Google Search for Gsl results in about 1,820,000 items. So for now it's known as "The Project Code-Named Gsl", or just Gsl for short.
The map loading through Tile Studio is now stable. I'm working on the sequence data though. I still need some kind of font display system for Tao.OpenGl though. I might just have to make a P/Invoke library for FreeType, we'll see.
For anyone who needs one.
Considering we're in the middle of exams, I'm suprised the amount of progress I've made. Gsl really has some potential. Some of the new features since last update:
It appears that GakScript isn't Mono compliant. As a result, I've switched over to using Boo exclusively. I'm planning on having everything in Gsl run through script files to increase flexability and allow for easy expansion of the games.
FMOD Ex has been implemented for sound and music support. It is probably the best audio library as it is cross platform and loads a huge list of audio formats. Gsl still has a couple bugs with disposing sound channels, but I'm working on that one.
Before all sprites having more then one frame of animation had to be held on multiple textures. Tilesets are now implemented into Gsl so you can have one image containing a number of different frames of animation. This will really come in handy when implementing the mapping system.
This is still at early stages, but I'm trying to have Tile Studio output a Boo script file so that tiled maps are easy to make and load into the engine. Right now it works with static maps, but I'd like to have sequences and all that good stuff. A big thanks goes to Scet and his journal for motivating me to use Tile Studio.
Tao.PhysFs has been implemented for PhysFS file loading support. This means loading any needed file from a dynamic file structure with zip loading support. So far images, audio files, scripts and map files are all loaded through PhysFS and I plan to keep it as dynamic as possible.
I'm considering redesigning the Sprite system so that there is a TileSet object for any Texture needing it. This will greatly take work load off of the Sprite and Tile objects and probably help me down the road with the mapping system. I also need a font rendering system and some kind of GUI interface. Anyone got any recommendations?
Urban Dead - Zombie Goodness
First order of business is to state that the infamous coldacid gave me one of his Ubuntu packages so right now I'm running off the Ubuntu Live CD. Click on the thumbnail on the right to see what I'm looking at right now.
It's using Gnome at the moment and I wish I had more time to check out KDE, but I'm just too busy. I have to get a new computer one of these days so I can make this one my Linux sandbox [wink].
John Haller has setup a new website dedicated to giving applications the ability to run off of USB keys named PortableApps.com. He uses NSIS scripts to make a launcher for the programs which effectively makes them "portable" and able to run on USB keys without leaving anything behind (nothing saved in the registery or harddrive). It's perfect for schools or work where you're going to be using a different computer quite frequently. One of the most famous programs is Portable Firefox.
I've become interested in this and plan on trying my hand at making some applications "portable" with NSIS scripts. The only experience I've had with NSIS was making an install program for ScreenCap. Making applications portable via NSIS will give me experience and I'll eventually be able to do some pretty neat stuff with it. We'll just have to wait and see.
That would be so much fun.
I've been incredibly busy lately with school and projects it's actually not that funny. The only thing that keeps me going lately is the Chronicles of Narnia Soundtrack, simply amazing music. Today's topic of discussion is...
Game Scripting Language (GSL) I've been interested in working with OpenGL for 2D game development for quite a while now and only just recently decided to try it out. I was also interested in developing an interface where it would be extremely easy to create games from some simple scripting along with XML. So I started up a simple project named Game Scripting Language (or GSL for short).
It's written in C# using the Tao Framework and I only started it last week. So far you can create a new OpenGL window (using GLFW via Tao.Glfw), load multiple textures in an object oriented interface (DevIL via Tao.DevIl) and then display them with ortho projection. I'm planning on implementing PhysFS for zip loading as well as keeping it as Mono-compatible as possible.
Rather interesting video about the Chipmunks.
Thanks to frostburn from #GameDev helping me realize that memory needs to be allocated before written into, Tao.PhysFs is now complete. I've uploaded it to the Tao Framework SVN and everything is good to go. Take a look at the source.
Oli has done some pretty awesome stuff with GameMonkey script lately, including gmSDL, GameMonkey bindings to SDL. I'm really going to have to try that scripting language out one day. I've been fooling around a bit with IronPython, but I doubt it runs with Mono. Anyone else have any experience with embedded scripting languages?
As you may know, I teamed up with Terry of Tao.Ode to put together object oriented bindings to the Tao.Ode project. Although it's still a very young project and not very functional yet, we put together a website: OdeDotNet hosted over at SourceForge.
A number of things don't work within the library including collision and some bugs when it comes to the garbage collector. But there are in fact two working examples so far: Basic and BodiesAndJoints. Seeing the BodiesAndJoints example in action is pretty neat. The library isn't truly functional yet and we'll get around to finishing it up later on. The problem is that Tao.Ode has some troubles with the unmanaged collision joint callbacks. Once that is figured out, implementing correct collisions into OdeDotNet should be a breeze.
I want one.
School classes are now in full speed now and my schedule is pretty leaniant when it comes to time. Consisting of only four days of classes, I should have enough time to decrease the number of items on my todo list.
After a short chat about the naming convention of Tao.PhysFs with you guys and a number of Tao veterans, I've decide to finalize the name as Tao.PhysFs.Fs. Thanks to Oli for all his help thus far. It should be up within the next two weeks if there arn't any problems with authentication. Today's topic of discussion is....
After becoming a developer on SDL.NET, jendave and I have been working hard finding bugs within the library and adding new features that should be in there. Many GameDev members have since joined the forum it has really helped with bug finding and making the use of OpenGL (Tao.OpenGl) from SDL.NET very easy. We've ported all of the RedBook examples as well as quite a large number of the NeHe tutorials and they work quite nicely.
I implemented a 2D particle engine for SDL.NET and named it SdlDotNet.Particles. Considering how abstract and flexible it is, it could be used with pretty much any graphics medium though. If you take a look at it, you'll notice that it consists of particles, manipulators and emitters. The particles are single particles that fly around, the manipulators change the particles in some way, and the emitters shoot out particles. Rather clever, I find. You can take a look at SDL.NET's Particle Example for a demo.
There are still so many bugs in the library it's not funny. The next release is coming out next week or so. Is there anything that should be implemented that isn't already in there?
Parent's Primer to Computer Slang