Guided sidewinder rockets

[Legend]

I came across a video on youtube some time ago that had some really interesting weapon modifications.

In particular, these guided rockets.

https://www.youtube.com/watch?v=I15z...otation_624747

The author made a file with source available on the page of his other video for the mods, but it does not seem to contain the code for the guided rockets (or lightning gun mod) in the video above.

Does anyone know where I could find some info on how to do this? I have looked all over the net, but with no luck. I can only find code for outright homing rockets, and the only guided rocket code I can find, is in the form of a chase-cam type of effect where you are steering the rocket from right behind. But nothing like the vid above.

Unfortunately, the author seems to be mia and I have had no luck contacting him.

ANyways, Thanks if anyone can help.

Here is the link to the first vid with the other mods and the download link:

https://www.youtube.com/watch?v=HL77cYQ4-wg

[Dutch]

At the moment I'm busy, but in a little while I'll take a look at it and give you a hand. I'm not a great coder by any means but I'm sure I can figure something out to help.

[Legend]

Right on. Thanks dutch.

[Dutch]

Cool.

It looks to call a constantly updated traceline function in the direction of the player's aim to then guide the rocket to the trace end position. I'll bet when he lets go of the mouse button, the rocket then changes course to wherever he aims. Gimme a little while and I can pull that off.

[Dutch]

Took me about an one and a half hours, but that was with adding comments and cleaning the code and all.

The continuously played sound can be replaced with a beeping noise or something more appropriate, I just threw that sound in as an example.

This was pretty quick, it's not perfect but it's fun as hell Obviously you'll have to play around with it to make it better.

EDIT: one thing I forgot: if the player fires normally (let's go of fire button immediately), then you may want to add an alternate .think function for removing it after 5 seconds. Probably not necessary but it would maintain consistency.

EDIT2: And move that stupid centerprint messaging I threw in to an sprint in the corner. The more I watch it, the more it annoys the hell out of me lol

[ame="http://www.youtube.com/watch?v=4hwhvTsEwQ0"]Guided Missile for Quake1[/ame]

Here is my finalized code. You can basically overwrite the entire rocket launcher code from id's QC code in weapons.qc, then compile:

/*
================================================== ============================
MISSILES

Functions related to firing missiles from the Rocket Launcher, including a
'tracing' feature for guiding fired missiles. Written by id Software, with
modifications and new functions by Dutch.
================================================== ============================
*/

/*
================================
Definitions

Floats needed to carry out code.
================================
*/

.float tracing; // used to determine if player can fire another shot.

/*
================================
Explosion Sprite

Exploding sprite animation frame functions.
================================
*/

void() s_explode1 = [0, s_explode2] {};
void() s_explode2 = [1, s_explode3] {};
void() s_explode3 = [2, s_explode4] {};
void() s_explode4 = [3, s_explode5] {};
void() s_explode5 = [4, s_explode6] {};
void() s_explode6 = [5, SUB_Remove] {};

/*
================================
BecomeExplosion

Sets the missile to the sprite.
================================
*/

void() BecomeExplosion =
{
// we don't want movement, solidity, or .touch calls:

self.movetype = MOVETYPE_NONE;
self.solid = SOLID_NOT;
self.velocity = '0 0 0';
self.touch = SUB_Null;
setmodel (self, "progs/s_explod.spr");
s_explode1 ();
};

/*
================================
T_MissileTouch

Missile touch function.
================================
*/

void() T_MissileTouch =
{
local float damg;

// turn off .tracing flag to allow for more player firing:

self.owner.tracing = FALSE;

// don't explode on player upon launch:

if (other == self.owner)
return;

// set the damage value as a local float:

damg = 100 + random()*20;

// do damage to entities with health, but do half damage to shamblers:

if (other.health)
{
if (other.classname == "monster_shambler")
damg = damg * 0.5;
T_Damage(other, self, self.owner, damg );
}

// don't do radius damage to the other, because all the damage was done in the impact:

T_RadiusDamage(self, self.owner, 120, other);

// set the origin back so the explosion sprite isn't buried in the wall:

self.origin = self.origin - 8*normalize(self.velocity);

// send temporary entity information to the missile's exploding origin:

WriteByte(MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte(MSG_BROADCAST, TE_EXPLOSION);
WriteCoord(MSG_BROADCAST, self.origin_x);
WriteCoord(MSG_BROADCAST, self.origin_y);
WriteCoord(MSG_BROADCAST, self.origin_z);

// set final properties and call the exploding sprite animation:

BecomeExplosion();
};

/*
================================
TrajectoryUpdate

The missile's .think function.
================================
*/

void() TrajectoryUpdate =
{
local vector start, end, save;
local vector new;

// if player lets off the fire button, or is killed, don't trace:

if (!self.owner.button0 || self.owner.deadflag != DEAD_NO)
{
//turn .tracing flag off and inform the player:

self.owner.tracing = FALSE;
centerprint(self.owner, "TRACE OFF\n");

// set a time removal if no longer tracing:

self.think = SUB_Remove;
self.nextthink = time + 5;

// skip any following code:

return;
}

// set .tracing true to prevent more missile firing:

self.owner.tracing = TRUE;

// make vectors in relation to the player (the missile owner):

makevectors(self.owner.v_angle);

// traceline from the player's viewpoint to wherever he's aiming, and save the point he is aiming
// at as a vector position ('save'). Make a new vector ('new') from the missile's
// origin to the player's aiming point, and normalize it to a value of 1:

start = self.owner.origin;
end = aim(self.owner, 10000);
traceline(start, end*10000, FALSE, self.owner);
save = trace_endpos;
new = normalize(save - self.origin);

// change the missile's trajectory to the vector between the missile's current position
// and the player's aim point, and restore the speed of 1000:

self.velocity = new*1000;

// re-orient the missile model to point forward towards it's destination:

self.angles = vectoangles(self.velocity);

// cycle this .think function every 10/1000ths of a second:

self.think = TrajectoryUpdate;
self.nextthink = time + 0.01;

// inform the player he is tracing with a message and a highly repeated sound (sound can
// be anything, obviously, this was just easiest to copy and paste in):

centerprint(self.owner, "TRACING...\n");
sound(self.owner, CHAN_WEAPON, "weapons/sgun1.wav", 1, ATTN_NORM);
};

/*
================================
W_FireRocket

The player's fire function.
================================
*/

void() W_FireRocket =
{
local entity missile;

// set vectors in relation to player (self):

makevectors(self.v_angle);

// update player's ammo count, play the firing sound, apply punchangle:

self.currentammo = self.ammo_rockets = self.ammo_rockets - 1;
sound(self, CHAN_WEAPON, "weapons/sgun1.wav", 1, ATTN_NORM);
self.punchangle_x = -2;

// create the missile, set owner as the player, set movetype and solid, and denote classname:

missile = spawn();
missile.owner = self;
missile.movetype = MOVETYPE_FLYMISSILE;
missile.solid = SOLID_BBOX;
missile.classname = "missile";

// set missile model as the correct mdl with no bounding box, and a starting origin
// directly in front of the player's origin (updated with v_up to make sense when
// aiming up or down):

setmodel(missile, "progs/missile.mdl");
setsize(missile, '0 0 0', '0 0 0');
setorigin(missile, self.origin + v_forward*8 + v_up*16);

// set initial velocity towards player's aimpoint with a speed of 1000, and orient
// model angles in the vector direction, and set .touch function:

missile.velocity = aim(self, 10000);
missile.velocity = missile.velocity*1000;
missile.angles = vectoangles(missile.velocity);
missile.touch = T_MissileTouch;

// call the updating .think function after 1/10th of a second has passed to allow the
// missile to get a ways out before altering course (in case player doesn't want to
// trace, he has time to let go of the fire button):

missile.think = TrajectoryUpdate;
missile.nextthink = time + 0.1;
};

/*
================================
NOTE: you will need to replace/add:

else if (self.weapon == IT_ROCKET_LAUNCHER)
{
self.attack_finished = time + 0.8;

if (self.tracing == TRUE)
return;

player_rocket1();
W_FireRocket();
}

in the W_Attack() function to
prevent further firing if the
player is tracing. You can also
add this check at the top of
ImpulseCommands() to ensure that
weapons can't be switched while
tracing.
================================
*/

[R00k]

There was a server called BigQEd's that had modified weapons, one was a guided missile. But, in his mod, he put the player's POV on the missile so the missile was visible like the weapon model but allowed you to glide around corners and seek out enemies. Not hard to do with a simple SVC_ to set the viewport.

[Legend]

Whoa! Right on, thanks Dutch.

I'll play around with it later this afternoon. I might get rid of that sound constantly repeating all together though.

From the vid, the control looks really tight. I think in the original mod by moatdd from the vid I posted, rocket can only have the course altered once. Or at least it seems so, after that maneuvering thruster kicks it in the opposite direction first.

About where in the code you posted could I make the control a little looser or make it so you can only curve the rocket in one direction? And is the thruster possible? I assume the player has to keep the fire button held down to control the rocket but should be able to move freely once they let go?

Thanks again.

@r00k:
Yeah, I've seen plenty of code that had the pov guided rockets, but I don't like them much myself and I think this kind of rocket seems more fun.

[Dutch]

I'll have to look into it when I get home tonight, but it wouldn't be too difficult to limit control.

Also, in trajectoryupdate, add

self.owner.attack_finished = time + 0.1;

within the (!self.owner.button0) if statement and in the T_MissileTouch() function.

This prevents player from accidentally firing a new rocket after the tracing rocket explodes, or is no longer being traced, like I kept doing in that video.

EDIT: No don't do that, it could possibly overwrite the normal self.attack_finished. Add a check to see if attack_finished is done before updating it.

[Legend]

I'll have to look into it when I get home tonight, but it wouldn't be too difficult to limit control.

No don't do that, it could possibly overwrite the normal self.attack_finished. Add a check to see if attack_finished is done before updating it.

You mean don't hold down the fire button or this could happen? I tried finding some code for having two different behaviors whether the button is tapped or held. No luck so far. THat was how I had planned to have it work. If the player just taps the button, then a normal rocket fires. If the button is held down, then the guiding system kicks in and when the player releases the button, they would no longer control it even if they held the button again.

Either that, or maybe the rocket detonates when the player lets go? Maybe just just add an impulse to bind to a separate button instead that could make the rocket detonate in mid flight before impact.

(sorry, just spouting out ideas now so I have them down somewhere. )

Thanks again Dutch. It's really appreciated.

[Dutch]

No problem. The way the code is right now, the player can tap the button and it fires normally. If you hold the button, you have control until you let go or the rocket explodes. If you make it to where it explodes when you let go, you won't be able to sling rockets around corners and what not.

It still needs some tweaking, I have thought of a couple glitches. I can fix these for you if you want, or use the current code as a good base to modify and learn on. Its up to you dude.

[Dutch]

Just got home from work and this little side project has been a nice distraction from my mod, so I thought I'd keep toying with it.

Regarding the self.attack_finished issues I though I had...nevermind. I just did some extensive testing and it works just as it should.

If you tap the button (meaning you let go before 1/10th of a second passes, so if you simply tap normally this condition is met for most people), then the .think function reads this as a lack of self.button0 (the firing button) and re-sets the .think function to a timed removal, therefore preventing any possible trajectory updating, and it restores the player's .tracing field to FALSE, so he is able to fire again.

Holding the fire button past 1/10th of a second after firing initiates trajectory changing UNTIL the button is released, at which point the rocket resumes it's most recent trajectory update, and it cannot be controlled again.

What this means is there is no need to update the attack_finished field, as the player cannot fire anyway.

The only problem I can see is a loss of accuracy for tracing rockets towards the player's final aim point, I'll try to figure out what's causing this.

Additionally, I will see about modifying control of the rocket.

Get back to ya soon.

[Dutch]

@Legend

EDIT: Good news, with the rocket lag I describe below, it possible to sling rockets around corners WITHOUT the impulse commands, so just forget about that hokey setup. Takes a little practice, but is fun as hell and pretty satisfying when you pull it off. I'm going to use this code for a Rift weapon in my mod, but use this as much as you want/however you want.

EDIT2: I highlighted the code that you can remove yellow (the code regarding the stupid impulses I made).

Ok, here's where it sits now. I was able to tighten up the accuracy and put in a few more checks to eliminate the glitches that I know of (there really shouldn't be that many).

As requested, I found a way of decreasing responsiveness of the rocket. The secret is in setting it's velocity during the constantly updated .think function:

BEFORE:
self.velocity = normalize(trace_endpos - self.origin)*1000;
AFTER:
self.velocity = normalize(trace_endpos - (self.origin - self.velocity))*1000;

Adding a multiplier to the highlighted self.velocity above will modify it further. So to make it lag more, times it by 2 or whatever. To tighten it up, divide it. For full, absolute responsiveness by removing it (like the BEFORE).

If you aren't familiar with the above syntax, basically we are re-defining the rocket's velocity (remember from trigonometry that velocity is defined as a vector, which takes into account SPEED and DIRECTION). We adjust the angle by creating a vector [normalize(trace_endpos - (self.origin - self.velocity)]. What is happening there, is we are reading a 3 dimensional (x,y,z) point where the player's viewpoint contacts the game world, and we are drawing a line (that is what traceline function does) from that point to the rocket's current origin (another 3d point). This line is the vector (direction) in which the rocket moves. Since the .think function is called every 0.05 seconds, the transition is smooth to the human eye, because it's happening very quickly.

Ok, so we have our vector. But we have no way of knowing the actual distance (the length of the line) between the rocket's origin and the trace_endpos (the point of the game world where the player is aiming). So we normalize it. This takes the entire distance and sets it equal to one. This may seem unnecessary, but it is important when we go to set the speed of the rocket.

So now we have defined the direction of the rocket's velocity. We now need the speed. That is why we multiply the direction by 1000, which is id Software's original rocket speed (in my mod, I prefer 1200...this is easily changed).

What I really want to emphasize is where I subtract off the self.velocity from the self.origin. This creates a lag in the vector, because it is modifying the velocity based on a position well behind the rocket's actual position. This creates a certain level of unresponsiveness to the rocket, which I suppose is more realistic.

Since you wanted the ability to throw the rocket left, right, up, or down (like in the YouTube video you found), I threw in a quick Impulse system. If you bind the 4 new impulses to your arrow keys, you will be able to abandon control of the rocket and throw it in a direction. Impulse 20 will go right, 21 will go left, 22 will go up, and 23 directs down. I just bound these to my arrow keys. There is a more complicated way of doing this that I can think of, but it would be better. If you can measure how fast the player changes his aim angle, you could toss the rocket (like in the video), but that's pretty involved and I'm out of steam on this for the moment.

I apologize if you know most of this already, but maybe somebody else will read this and learn something. Like I said, I'm not a great coder, but I tell you what, it wasn't long ago this was all jargon to me. Spike really helped me learn some of this stuff, he's the man. His shit is better at coding than I am

I have another idea I'm going to try to implement, I'll get back to you a little later about it.

At any rate, here's the code now. I had to take the comments out for my own sanity (it looked really cluttered), but it's not too complicated and would be a good thing to study up on if you are interested. Otherwise, just ask me about anything that's vague and I'll try my best to explain.

Here you go buddy:

/*
================================================== ============================
MISSILES

Functions related to firing missiles from the Rocket Launcher, including a
'tracing' feature for guiding fired missiles. Written by id Software, with
modifications and new functions by Dutch.
================================================== ============================
*/

/*
================================
Definitions

Floats needed to carry out code.
================================
*/

.float tracing;
.float rocketdir;

/*
================================
Explosion Sprite

Exploding sprite animation frame functions.
================================
*/

void() s_explode1 = [0, s_explode2] {};
void() s_explode2 = [1, s_explode3] {};
void() s_explode3 = [2, s_explode4] {};
void() s_explode4 = [3, s_explode5] {};
void() s_explode5 = [4, s_explode6] {};
void() s_explode6 = [5, SUB_Remove] {};

/*
================================
BecomeExplosion

Sets the missile to the sprite.
================================
*/

void() BecomeExplosion =
{
self.movetype = MOVETYPE_NONE;
self.solid = SOLID_NOT;
self.velocity = '0 0 0';
self.touch = SUB_Null;
setmodel (self, "progs/s_explod.spr");
s_explode1 ();
};

/*
================================
T_MissileTouch

Missile touch function.
================================
*/

void() T_MissileTouch =
{
local float damg;

self.owner.tracing = FALSE;
self.owner.rocketdir = 0;

damg = 100 + random()*20;

if (other.health)
{
if (other.classname == "monster_shambler")
damg = damg * 0.5;
T_Damage(other, self, self.owner, damg );
}

T_RadiusDamage(self, self.owner, 120, other);

self.origin = self.origin - 8*normalize(self.velocity);

WriteByte(MSG_BROADCAST, SVC_TEMPENTITY);
WriteByte(MSG_BROADCAST, TE_EXPLOSION);
WriteCoord(MSG_BROADCAST, self.origin_x);
WriteCoord(MSG_BROADCAST, self.origin_y);
WriteCoord(MSG_BROADCAST, self.origin_z);

BecomeExplosion();
};

/*
================================
TrajectoryUpdate

The missile's .think function.
================================
*/

void() TrajectoryUpdate =
{
if (!self.owner.button0 || self.owner.deadflag != DEAD_NO)
{
self.owner.tracing = FALSE;
self.think = SUB_Remove;
self.nextthink = time + 5;
return;
}

self.owner.tracing = TRUE;
makevectors(self.owner.v_angle);

if (self.owner.rocketdir == 0)
traceline(self.owner.origin, aim(self.owner, 100000)*100000, FALSE, self.owner);
else if (self.owner.rocketdir == 1)
traceline(self.origin, self.origin + v_right, FALSE, self);
else if (self.owner.rocketdir == 2)
traceline(self.origin, self.origin - v_right, FALSE, self);
else if (self.owner.rocketdir == 3)
traceline(self.origin, self.origin + v_up, FALSE, self);
else
traceline(self.origin, self.origin - v_up, FALSE, self);

self.velocity = normalize(trace_endpos - (self.origin - self.velocity))*1000;
self.angles = vectoangles(self.velocity);

if (self.owner.rocketdir == 0)
{
self.think = TrajectoryUpdate;
self.nextthink = time + 0.05;
}
else
{
self.owner.rocketdir = 0;
self.owner.tracing = FALSE;
self.think = SUB_Remove;
self.nextthink = time + 5;
return;
}
};

/*
================================
W_FireRocket

The player's fire function.
================================
*/

void() W_FireRocket =
{
local entity missile;

makevectors(self.v_angle);

self.currentammo = self.ammo_rockets = self.ammo_rockets - 1;
sound(self, CHAN_WEAPON, "weapons/sgun1.wav", 1, ATTN_NORM);
self.punchangle_x = -2;

missile = spawn();
missile.owner = self;
missile.movetype = MOVETYPE_FLYMISSILE;
missile.solid = SOLID_BBOX;
missile.classname = "missile";

setmodel(missile, "progs/missile.mdl");
setsize(missile, '0 0 0', '0 0 0');
setorigin(missile, self.origin + v_forward*8 + self.view_ofs - v_up*;

missile.velocity = aim(self, 100000);
missile.velocity = missile.velocity*1000;
missile.angles = vectoangles(missile.velocity);
missile.touch = T_MissileTouch;

missile.think = TrajectoryUpdate;
missile.nextthink = time + 0.2;
};

/*
================================================
NOTES:
_______________________________
* Be sure the "sv_aim" cvar has a value
>= 1, as auto aiming creates some very
odd results in tracing.
_______________________________
* Replace/add the following in W_Attack()
to prevent more rocket firing while
tracing:

else if (self.weapon == IT_ROCKET_LAUNCHER)
{
self.attack_finished = time + 0.8;

if (self.tracing == TRUE)
return;

player_rocket1();
W_FireRocket();
}
_______________________________
* Add the following to SuperDamageSound()
before any other code in the function
to prevent a continuously played
Quad damage sound while tracing:

if (self.tracing == TRUE)
return;
_______________________________
* As extra re-assurance that players don't
spawn with tracing enabled (which disables
firing), add this to PutClientInServer()
(underneath self.invincible_time = 0 in
client.qc:

self.tracing = FALSE;
self.rocketdir = 0;
_______________________________
* Add this within the ImpulseCommands()
function, and then bind these impulses to
your preferred keys:

if (self.tracing == TRUE)
{
if (self.impulse == 20)
self.rocketdir = 1;
if (self.impulse == 21)
self.rocketdir = 2;
if (self.impulse == 22)
self.rocketdir = 3;
if (self.impulse == 23)
self.rocketdir = 4;
}
_______________________________
* Update the W_WeaponFrame() function so
that the self.attack_finished if statement
looks like this:

if (time < self.attack_finished && self.tracing == FALSE)
return;
================================================
*/

[Legend]

Thank you so much Dutch. Unfortunately, I got called into work the last minute, had to work late, and have to be back early in the morning so I won't be able to play with the code as I thought I would today. Tomorrow afternoon for sure though.

It still needs some tweaking, I have thought of a couple glitches. I can fix these for you if you want, or use the current code as a good base to modify and learn on. Its up to you dude.

I would love to see the version of the code with the bugs fixed (which I assume is in the last code sample you posted) so I can compare them to figure out the differences.

I'm still very new to QuakeC and have only done a handful of minor modifications so far, and unfortunately, most of the resources and tutorials for QuakeC seem to be dead links. So, I really appreciate how in depth you have gone with your explanations of the code and the thinking behind it. I will definitely be trying to bend your ear on a few other ideas/concepts that I want to incorporate after this one gets sorted.

BTW, RiftQuake looks really cool.

My ultimate goal is to build on Moatdd's weapon mod in the vids and create my "Arena of The Damned" mod concept. Which is basically Q3 Arena combined with DMSP with new weapon behavior without going too over the top and away from the original Quake.

Anyways, thank you so much again!

[Dutch]

No problem buddy, that is the finalized code on my end and you can play with it to make changes to your liking. It should be pretty much bug-free, if I find anything wrong you'll be the first to know. And if you suspect something is wrong let me know.

I'm still very new to QuakeC and have only done a handful of minor modifications so far, and unfortunately, most of the resources and tutorials for QuakeC seem to be dead links. So, I really appreciate how in depth you have gone with your explanations of the code and the thinking behind it. I will definitely be trying to bend your ear on a few other ideas/concepts that I want to incorporate after this one gets sorted.

Absolutely, I'll help the best I can. I really enjoyed this little challenge you came up with because it helped me build some ideas of my own for my mod. When you start your mod, make a build thread for it and ask questions there as well. Someone better than me will likely answer as well, probably Spike, and he will have an answer for everything.

BTW, RiftQuake looks really cool.

Thank you sir!

My ultimate goal is to build on Moatdd's weapon mod in the vids and create my "Arena of The Damned" mod concept. Which is basically Q3 Arena combined with DMSP with new weapon behavior without going too over the top and away from the original Quake.

Sounds legit, looking forward to seeing your progress!

EDIT: I would recommend trying that code without the impulse shit, just remove the yellow highlighted stuff in the codeblock. If you decide to try it, you can always add it back in. I didn't spend much time on the impulse stuff because I liked the rocket behavior without it, but that is obviously just personal preference. I have an idea of how to make the rocket direction swing better without the impulses, if you are interested I can try it out and share my results.

[Legend]

Hey Dutch. Thanks yet again.

I intended to remove the impulse stuff since from your description, it seemed like it would only them curve in the exact cardinal 4 directions. But I have still yet to actually get to sit down and try it yet unfortunately cause I keep getting called into work and other things at home to deal with. Or just plain being too tired once I finally get a chance to sit down. Was about to try last night but then passed out. lol.

I would definitely still be interested in your ideas for making it swing better without the impulses.

From the mod video, I gathered that the main thing was that the rocket becomes guided for only a moment. The maneuvering thruster kicks in the opposite direction the player looks, then follows in that direction to curve the rocket that way. But the player doesn't actually have full control over it's path. From what I could tell, the player can only control the direction the rocket curves towards only a single time and then cannot control it's path anymore after that thruster kicks in. That is how I was thinking it worked/would work anyways. I also intend to make it so the guided rockets require some cells in addition to a rocket in order to fire.

I should be able to sit down with the code finally tomorrow (hopefully) and play around with it.

Once I get about halfway done with my mod idea, I will definitely make a thread for it. I want to finish the weapons/items first, which includes these rocket concepts, a hopefully really fun tweak to the double shotgun (which is next), and one (hopefully fun and interesting) new gun. Then the dmsp aspect of it at least. Then post it and finish the q3 style concepts last.

I didn't want to make a thread with too many questions at once in case I actually do manage to find some info after. It's a shame that so many of the quakec tutorials and info sites seem to be dead now. And For some reason I can't seem to get registered on Inside 3D to ask there as well.

P.s. I'm glad you got some use out of trying this idea and helping me out as well. I had another rocket idea that I think is possible that I don't actually intend to use myself though. But with rift quake, from what I can tell so far, may be of interest to you. At least as another fun programming challenge if you're interested.