hamsoft v1.0

Ok so no flashy screenies this time but the pview terrain is now generated entirely fractally, and you can walk around the whole planet.

Working firstly on different ways of selecting areas of terrain and then later tarting it up for worlds with vegetation and atmospheres.

Have fun you crazy mofos.

Ok my inbox has been flatlined with the amount of requests for a shot with a better texture. Technically actually that's a lie. Well here's one anyways, apologies for anyone still using dialup.

I'm working on getting these textures generated at the moment. ETA in the next couple of weeks.

I've put up the new hamsoft website that i've been working on. It should be a bit easier to use and a bit more browser compliant (although it looks better in firefox than ie. Also in the tradition of most things i do it's not completely finished yet, although you should get some idea of the final product.

Anyway it's easily skinnable so if you don't like it or think you could do a better job let me know...

The main addition to the site is an rss feed to the titles of our development posts on the official Hamsoft LJ which should help keep you up to date with the latest developments.

Over the next few weeks inbetween working on Hamwars i'll integrate the hamwars website and start work on a user registration system.

Anyway it's back to work on the universe generator for me, hope you are all well and as excited as us about hamwars as we are (well maybe not as excited as Mark).

This weekend we managed to get the server/client working cross network and the performance was not all that bad either, further to that i've meddled a little on the server side and it now accepts http requests! This means that players will be able to request game infomation from the server through their browser (more info on the uses of this at a later date).

I've also setup the basic architecture for in game messaging and player structures.

... oh almost forgot, i'm working on a new hamsoft/hamwars website that actually doesn't suck...more soon

Look at the cockpit to see the specular lighting. Bumpmapping is also happening in this picture if you look at the back of the model.

Frankly I was expecting it to look a little better than this. I'll keep tweaking it although I will be working on the planetary view for the next week or so...

Hi, I'm EA, the foolish mortal agreeing to do most of the art and music direction on the Hamwars project.

I thought I'd update this journal today, as the last couple of weeks have been pretty landmark in the development of this game. I need to pay tribute to the two coders; Zombiepron and especially Slaytanist for his graphics engines. It has dawned on us only recently that this game will not only *be* good, but *look* good. Very good. Not like Doom 3 good or UT2004 good, but technically better than Quake 2, better than Civ 3 good. Best full freeware game out there good. And for a three-man team in their spare time, it's going to be pretty impressive.
Slaytanist is sorting our bump and gloss mapping as I type. The voxel engine he made will blow Civ 3 out of the water.

Yet the game itself is still so open-ended that the player will be given complete freedom. Not only in the way it's played (Zompiepron's web interface will allow much of the game to be played remotely), but what you do while you're playing. Can you name me another game in which it is possible, yet not obligatory, to genetically engineer, train and weaponise the wildlife on your planets?

Giant Spider model (Feb 2006, 213 vertices, 256 colours)

This is the game we all wanted to play as kids. So we're not going to be skimping on the small things.

You have been reading a propaganda message on behalf of Hamsoft, by EA (the untouchable).

Work is picking up pace again on Hamwars. We now have timelapse buttons to show the dynamic orbits.. hold them on to watch the planets zip about :)

Lots of work is planned for the coming days.. largely tarting up the GUI but a great deal of structural work too.

Blah

Here's another one for all you phanz..

Blah

Yey! hamsoft now ranks 14 on a search for 'hamsoft' on alltheweb.com which is more than can be said for google (boohiss).

alltheweb is my new best friend

We are on the verge of completing the underlying universe model although when i say on the verge i am actually lying but, you know, it's pretty close.

I dare say within a week or so we may have some screenshots to show of our trips through the hamwars universe!

assythment has kindly offered to help with the gfx and musak which can only be a godsend considering the combined ineptitdue of myself and

slaytanist .

once we have the universe model up and running it's time to get down to the game mechanics! and once we have some kind of basic game ready we will be releasing it for testing. WOWZ!!!!!1

I thought we needed a forum yo

I doubt it's exactly secure mate but it would be nice to have somewhere to organise our thoughts, we have like 80 pages of craptalk between us and there must be a fucking design in there!

Sign ye up and I'll fuckin admin ya!

Oh aye.. my idea for the title screen:

HAMWAAAARZ

Or something :)

Bad news with the Hamsoft samplie - leHam was using software he though was pretty distinctive (and, errrm, hot) so he's gonna have another bash with PD stuffs. TBH it doesn't even need to sound half as good as it did but he's a fucking perfectionist so it may take a while :(

=======================================>EDiT<==========================================

Got a fullbright-when-selected toggle button - it would be cool to have this actually greying out when it's selected. I'm thinking in a bit of having a list of buttons like sprite data and either writing to the back buffer or the actual background we're blitting depending on whether it's a toggle button or not. Pretty confident about this.

I do need to overhaul the way I'm handling buttons though, I reckon we'll have problems with this system when we have a huge number of nested menus. Seeing now why all the old games had icons a fixed size and position (oh yeah, and they could just right-shift the mouse x and get the button number, I get it)..

Orbiting: dude I'm guessing the axis of rotation remeins fixed while a planet is orbiting, rather than rotating with it. Because of gyroscopes or something. Do you know if it does?

Did a bit of werk on the HAMWARZ client today. The display is now confined to a box (400*400 I think) although it's certainly changable, with some shitty pixor in the remaining screen as a placeholder. There's a quit button and the name of the planet your mouse is over is displayed. Also the shitty pixor contains a rather badly spraycanned 'starfield' if you can call it that..

I hope I'm handling the buttons sensibly; I realise we will need a fuckload of different popups and other crap so we probably need it a little more versatile. Popups I will do soon but I'm knee deep in this shit and have a fuckload to do!

Files in teh usual place.

Update; now it's loading stuff thru a char buffer to sort of vaguely simulate a client-server exchange. You can move around the system with the arrow keys and 1/0 on the keypad for up/down; the top keypad keys 4-9 are for rotation. Right now the rotation on the planets is proper screwed, if anyone can tell me how to properly convert unit vectors to euler angles (without gimbal locking altho this is hardly the biggest worry right now) I'd be fucking chuffed!

Fialz in the usual place or will be when I upload them.

Right.. after I fix this frigging rotation issue I can see a few directions to go in:

Tart up Solarpanel (selection/hovering messages, "Talking to server" message, skybox, confine it to a 'window', controls at the side and crap) <-- we need a gui sketched out for this and pretty much everything else!!
Hamwarz Message Protocol(R)
Recycle a bunch of crap and start on the Starmap
Player data structures
Unit structures, and incorporate these into the maps
Further screens for the units
Fractal generation of planet maps
Server-side simulation

Any/all/none of the above? Most of these should take a day or two each max but at current rate will be more like a fortnight :) The bottom one will likely take months; probably best to get something mediocre running pretty soon then dip into it when we feel like it.

I need a fucking drink :S

EDiT> HURRAY! The Y/Z rotation appears done (like, the poles look like they're where they're supposed to be) I'll tell you the truth mate I HAVE NO FUCKING CLUE how I'm gonna get them to spin right.
EDiT> X-rot is working. Rolling (7 and 9 on the keypad) seems to have the opposite effect on the angles you would think, which is weird, and 'fixing' it fucks the rest up. How queer. Maybe the matrix ops are wrong?

A fair bit has changed with the ballmapper, phong is now looking a lot prettier and I've set up a nightmap for Earth.

Also changed the pallette shading so it doesn't look so 1995 ( :( ), a problem with this though is now the moon doesn't look bumpmapped anymore! And since I liked the effect I might go and code some bumpmapping :) This will add a couple of ops to the innerloop as well as creating a smallish texture (720*360*2 bytes) and a smallish table, should this chew up bandwidth or clientside render speed we could certainly make it togglable.

Oh aye I've jacked up the envmap to utterly obese proportions, it will take a minute or two to calc (generation is still unoptimised and it's a 128meg table :O ) so go make a brew or something :D. I've set it so you can change the lot at compilation just by changing PHONGRSBITS and PHONGRTBITS to something a little lower, if you wish. The changes I've made to the phongmapper don't stop there.. you can change it back to an 8meg table and it still looks infinitely better (the way the lightangles were calced was a little fucked before and it was jerking about like an electrician with Parkinson's)

//Wondering if we could generate this envmap while the client is DLing stuff?

Source, exe and textures are in the same place.

UPDATE: exe with 8meg table and two with 32megs for comparison in the zip too.
UPDATE: Precalc MUCH faster now; I've not even optimised it, just built sin tables.
UPDATE: Added clipping which sort of sets me up to represent this shit in real space and not just screen coords. Grr :)

Also I've had an idea for selecting planets (rather than the map painted on them) - create a list of bounding boxes sorted by distance from camera. It will then check the boxes in order and edge-detect if you're in the box (for planets a check by radius would be enough) and give a hovering planet name if you're over it, and set a global pointer to the object. When you click it it will set the planet as selected, zoom you in, let you select shit on the planet and all that good crap. What do you reckon?

Getting crap off the planet once it's selected will be another one of those spherical cord transforms I'm starting to really love.

Yes that was sarcasm.

What the fuck am I talking about we can use the mapper tables which will be better anyway cus we can brush over any, ahem discrepancies between the mapper output and what should actually be there.

Since all the distances are crazy in a spacegame I don't think we'll need a z-buffer except a sort of localised one per spaceship but if you think it would be useful it's your call. If we're even representing spaceships as models in the planetary grid (they're gonna be fucking tiny! Except for like orbital superbarges and Death Arks and whatever crazy shit we want) Maybe just a red circle for enemy units, yellow for neutral/non-combat and blue or somshit for friendly. These circles could also represent large ports and cities on the map. Whatever.

Not so worried about potential Java speed issues now; so long as we only draw the screen when we have to I'm sure we could get away with 5-10fps, less even. It's gonna be pretty static as games go, wherever we go with it really.

Mem is starting to frighten me a little :) How much can you realistically use in a browser applet?!? Of course if we don't go that way it's not an issue.

Holy fuck I'm gonna go draw some Death Arks :D

hamwars is following it's usual stop start momentum, however it current appears to be in the start phase.

slaytanist has actually got a working ballmapper o' doom up and running however we are running into major problems, mainly due to our own ineptitude.

Anyway that's all i have to say for now, other than the screenshot on the main site is no longer a proper screenshot of the planet view. Java3D sucks, however i have seen

slaytanists ballmapper (that sounds so wrong) and it rocks... so there

Omfgazm!!

Dude I don't believe I actually did something resembling useful.

What do you think of speed and shit? I mean will it be acceptable runing in Jarvar etc? The innerloop needs a fuckload of work but I don't want to go overboard cus I know it has to be portable, erm yeah that's it. Speed aside I really need to put in some clipping so I can see it moving about.

I speak Klingon in all formal dialects and 37 coloquial forms.

//main.cpp

#include

[Error: Irreparable invalid markup ('<windows.h>') in entry. Owner must fix manually. Raw contents below.]

<a href="http://www.alariel.co.uk/Slaytanist/Balls.zip">Omfgazm!!</a>

Dude I don't believe I actually did something resembling useful.

What do you think of speed and shit? I mean will it be acceptable runing in Jarvar etc? The innerloop needs a fuckload of work but I don't want to go overboard cus I know it has to be portable, erm yeah that's it. Speed aside I really need to put in some clipping so I can see it moving about.

I speak Klingon in all formal dialects and 37 coloquial forms.

<lj-cut text="teh coed">

//main.cpp

#include <windows.h>
#include <ddraw.h>
#include <stdio.h>
#include <math.h>

#define WNDCLASSNAME "wndclass"

typedef unsigned short ushort;

#define pi 3.14159265

#define TEXT_HEAD 54
#define TEXT_FACEX 360
#define TEXT_FACEY 360
#define TEXTWIDTH 720
#define TEXTWID 2160
#define TEXTHEIGHT 360
#define TEXT_PAL 256

#define TOFMMAXX 400
#define TOFMMAXY 400
#define TOFDEGY 400
#define TOFBORD 312
#define TOFWIDTH (TOFMMAXX+2*TOFBORD)
#define TOFOFF (TOFWIDTH*TOFBORD)

#define _15BIT(r,g,b) (((r&248)<<7) + ((g&248)<<2) + (b>>3))
#define _16BIT(r,g,b) (((r&248)<<8) + ((g&252)<<3) + (b>>3))

#define SMALLFONTHEIGHT 128
#define SMALLFONTWIDTH 128
#define SMALLFONTPAL 256

//Timing shit
float timeAtGameStart;
UINT64 ticksPerSecond;
//FPS counter
float lastUpdate = 0;
float fpsUpdateInterval = 0.1f;
int numFrames = 0;
float fps = 0;

int CoordTable[TOFMMAXX*TOFMMAXY];

int xrot,yrot,zrot,count;
float skale,skalemod;

typedef struct texture_
{
byte ghey[(TEXTWID*TEXTHEIGHT)];
ushort pallete[TEXT_PAL];
} texture;

typedef struct textureoffsetmap_
{
int Tofflist[TOFMMAXX*TOFDEGY*4];
} textureoffsetmap;

typedef struct preoffsetmap_
{
int blarg[(TOFWIDTH*TOFWIDTH)];
} preoffsetmap;

typedef struct smallfont_
{
ushort ghey[(SMALLFONTHEIGHT*SMALLFONTWIDTH)];
} smallfont;

texture tehwurld;

preoffsetmap textoffs,moreoffs;
textureoffsetmap toffs;

smallfont QuakeChars;

unsigned char buffer[TEXTWIDTH*TEXTHEIGHT+TEXT_HEAD+TEXT_PAL*4+3072];

HDC hdc;
HWND hwnd;

DDSURFACEDESC2 ddsd;
LPDIRECTDRAW lpdd = NULL;
LPDIRECTDRAW7 lpdd7 = NULL;
LPDIRECTDRAWSURFACE7 lpPrimary = NULL;
LPDIRECTDRAWSURFACE7 back = NULL;

int swidth = 640;
int sheight = 480;
int sbpp = 16;

int lpitch = 0;
ushort *lpscreen = NULL;

bool quit = false;

char stringbuffer[256];

//***********************
//** MAPPING INIT SHIT **
//***********************

void InitBasicCoordConversionTables()
{
double S,p,r,t,y,lol,xnu,znu;
int x,z,n;
n = 0;
p = TOFMMAXX/2;
for (z=0;z<TOFMMAXY;z++)
{
for (x=0;x<TOFMMAXX;x++)
{
znu = z - p;
xnu = x - p;
y = xnu*xnu + znu*znu;
y = p*p - y;
if (y > 0)
{
y = sqrt(y);
S = xnu*xnu + y*y;
S = sqrt(S);
r = atan((y/xnu));
t = acos((znu/p));
if (r<0)
r = pi + r;
r = pi - r;
t = pi - t;
r = r*TEXT_FACEY / pi;
t = t*TEXT_FACEX / pi;
t = floor(t);
r = floor(r);
lol = r + t*TEXTWID;
lol = floor(lol);
CoordTable[n++] = (int)lol;
}
else
CoordTable[n++] = 0;
}
}
}

void InitToffs()
{
double S,p,r,t,y,lol,xnu,znu,zmax;
int x,z,n,a,b,c;
n = 0;
a = TOFMMAXX * TOFMMAXY;
b = TOFMMAXX * TOFMMAXY * 2;
c = TOFMMAXX * TOFMMAXY * 3;
p = TOFMMAXX/2;
for (z=0;z<TOFMMAXY;z++)
{
for (x=0;x<TOFMMAXX;x++)
{
znu = z - p;
xnu = x - p;
zmax = p*p - xnu*xnu;
zmax = sqrt(zmax);
znu = znu / p;
znu = znu * pi / 2;
znu = sin(znu);
znu = znu * zmax;
znu = znu;// + p;
y = xnu*xnu + znu*znu;
y = p*p - y;

if (y > 0)
y = sqrt(y);
else
y = 0.0000000000001;
S = xnu*xnu + y*y;
S = sqrt(S);
r = atan((y/xnu));

znu = znu / p;
if (znu < -0.999)
znu = -0.999;
if (znu > 0.999)
znu = 0.999;

t = acos((znu));

if (r<0)
r = pi + r;
r = pi - r;
t = pi - t;
r = r*TEXT_FACEY / pi;
r = TEXT_FACEX - r;
t = t*TEXT_FACEX / pi;
t = floor(t);
r = floor(r);
lol = r + t*TEXTWID;
lol = floor(lol);
toffs.Tofflist[n++] = (int)lol;
toffs.Tofflist[b++] = (int)lol;
t = TEXT_FACEY - t;
r = 2*TEXT_FACEX - r;
lol = r + t*TEXTWID;
lol = floor(lol);
toffs.Tofflist[a++] = (int)lol;
toffs.Tofflist[c++] = (int)lol;
//}
//else
//{
// Tofflist[n++] = 0;
// Tofflist[a++] = 0;
// Tofflist[b++] = 0;
// Tofflist[c++] = 0;
//}
znu = z - p;
y = xnu*xnu + znu*znu;
y = p*p - y;

if (y >= 0)
{
//znu = znu * p / zmax;
//znu = znu + p;
znu = znu / zmax;
//znu = (znu) * pi/2;
//if (znu > 0)
// znu = 2 - cos(znu);
//else
// znu = 0 + cos(znu);
znu = acos(znu);
znu = znu * 2 / pi;
znu = znu * p;
znu = znu + 2 * p;
lol = floor(znu);
lol = lol * TOFMMAXX;
lol = lol + x;// * TOFMMAXY;
textoffs.blarg[x+z*TOFWIDTH+TOFOFF+TOFBORD]=(int)lol;
moreoffs.blarg[TOFMMAXX-z+x*TOFWIDTH+TOFOFF+TOFBORD]=(int)lol;
}
//textoffs.blarg[x+z*TOFMMAXX]=(int)floor((x+(((p+(znu*p/zmax)))*TOFMMAXX)));
else
textoffs.blarg[x+z*TOFWIDTH+TOFOFF+TOFBORD]=0;
}
}
toffs.Tofflist[0]=0;
}

int Rottable1[720];
int Rottable2[720];
int Rottable3[720];
int Rottable4[720];
int Rottable5[720];
int Rottable6[720];

void MakeTehRotTables()
{
int rotthree;
float r1,theta,cockbitch;
cockbitch = sqrt(TOFMMAXX*TOFMMAXX/2);

for (rotthree = 0; rotthree < 720; rotthree ++)
{

theta = rotthree;
theta = theta * pi / 180;

r1 = sin(theta);
r1 = r1 * 0x1000;
r1 = r1 * cockbitch;
r1 = floor(r1);
Rottable1[rotthree] = (int)r1;

r1 = 0-cos(theta);
r1 = r1 * 0x1000;
r1 = r1 * cockbitch;
r1 = floor(r1);
Rottable2[rotthree] = (int)r1;

theta = rotthree;
theta = theta + 45;
if (theta > 360)
theta = theta - 360;
theta = theta * pi / 180;

r1 = cos(theta);
r1 = r1 * 0x1000;
r1 = floor(r1);
Rottable3[rotthree] = (int)r1;

r1 = sin(theta);
r1 = r1 * 0x1000;
r1 = floor(r1);
Rottable4[rotthree] = (int)r1;

r1 = 0-sin(theta);
r1 = r1 * 0x1000;
r1 = floor(r1);
Rottable5[rotthree] = (int)r1;

r1 = cos(theta);
r1 = r1 * 0x1000;
r1 = floor(r1);
Rottable6[rotthree] = (int)r1;

}
}

void Lols(int rot, int rottwo, int rotthree, int xpos, int ypos, float scale)
{
int x,y,z,umpaloompa,fag,flid,cheesy,ghey,size,u,v,tu,tv,du,dv,tdu,tdv,hahahahah,omgfagget,rho,sizex,sizey;
float r2;
preoffsetmap *texoffs;
int *lamer = toffs.Tofflist;
BYTE *fuckstix = tehwurld.ghey;

rho = rotthree;

size = (int)floor(scale*TOFMMAXY+2);
sizex = size;
sizey = size;

texoffs = &textoffs;

while (rho > 360)
rho = rho - 360;
while (rho < 0)
rho = rho + 360;
if (((rho > 0) && (rho < 90)) || ((rho > 180) && (rho < 270)))
{
rho = rho + 90;
texoffs = &moreoffs;
if (rho > 360)
rho = rho - 360;
}

tu = (TOFBORD+TOFMMAXX/2) << 12;
tv = (TOFBORD+TOFMMAXY/2) << 12;

tu = tu + Rottable1[rho];

tv = tv + Rottable2[rho];

r2 = 1 / scale;

du = (int)(Rottable3[rho] * r2);

dv = (int)(Rottable4[rho] * r2);// / scale);

tdu = (int)(Rottable5[rho] * r2);// / scale);

tdv = (int)(Rottable6[rho] * r2);// / scale);

flid = xpos - (int)(size/2) + ((ypos-(int)(size/2)) * lpitch/2);
fag = flid;

z = 0;
lamer = lamer + rottwo;
fuckstix = fuckstix + rot;

for (y=0;y<size;y++)
{
u = tu;
v = tv;
for (x=0;x<size;x++)
{
omgfagget = u & 0xFFFFF000;
hahahahah = v & 0xFFFFF000;
omgfagget = omgfagget >> 12;
hahahahah = (hahahahah >> 2) + omgfagget;
umpaloompa = (*texoffs).blarg[hahahahah];
if (umpaloompa)
{
umpaloompa = lamer[umpaloompa];
cheesy = fuckstix[umpaloompa];
lpscreen[fag]= tehwurld.pallete[cheesy];
}
u += du;
v += dv;
fag++;
}
flid = flid + (lpitch/2);
fag = flid;
tu += tdu;
tv += tdv;
}
}

void LoadTehWurld(texture *tex)
{
int x,y,z,i,j,k,l,m;
FILE *ptr;

ptr = fopen("tehwurld.bmp","r");

fread(buffer,261000,1,ptr);
fclose(ptr);
z = 0;

for(x=0;x<TEXT_HEAD;x++)
z++;
for(x=0;x<TEXT_PAL;x++)
{
(*tex).pallete[x] = (((buffer[z+2]&248)<<8) + ((buffer[z+1]&252)<<3) + (buffer[z]>>3));
z = z + 4;
}

i = z;
for(y=0;y<TEXTHEIGHT;y++)
{
k = y*TEXTWID;
l = k + TEXTWIDTH;
m = l + TEXTWIDTH;
j = (TEXTHEIGHT - y - 1)*TEXTWIDTH + i;
for(x=0;x<TEXTWIDTH;x++)
{
(*tex).ghey[k++] = buffer[j];
(*tex).ghey[l++] = buffer[j];
(*tex).ghey[m++] = buffer[j++];
}
}
}

void LoadConChars(smallfont *chars)
{
int x,y,z,i,j,k;
FILE *ptr;
ushort pall[256];
int col;

ptr = fopen("CONCHARS.bmp","r");

fread(buffer,261000,1,ptr);
fclose(ptr);
z = 0;

for(x=0;x<TEXT_HEAD;x++)
z++;
for(x=0;x<SMALLFONTPAL;x++)
{
pall[x] = (((buffer[z+2]&248)<<8) + ((buffer[z+1]&252)<<3) + (buffer[z]>>3));
z = z + 4;
}

i = z;
for(y=0;y<SMALLFONTHEIGHT;y++)
{
k = y*SMALLFONTWIDTH;
j = (SMALLFONTHEIGHT - y - 1)*SMALLFONTWIDTH + i;
for(x=0;x<SMALLFONTWIDTH;x++)
{
col = buffer[j++];
(*chars).ghey[k++] = pall[col];
}
}
}

//the sloppiest ftos function I believe you will ever see
char* ftos (float f)
{
int x;
char *string = stringbuffer; //eventually I will have a rotating set of these

x = (int)(f / 10000);
x = (int)fmod((double)x,10);
string[0]=(char)(x+0x30);
x = (int)(f / 1000);
x = (int)fmod((double)x,10);
string[1]=(char)(x+0x30);
x = (int)(f / 100);
x = (int)fmod((double)x,10);
string[2]=(char)(x+0x30);
x = (int)(f / 10);
x = (int)fmod((double)x,10);
string[3]=(char)(x+0x30);
x = (int)(f);
x = (int)fmod((double)x,10);
string[4]=(char)(x+0x30);
string[5]=(char)(0x2e);
x = (int)(f * 10);
x = (int)fmod((double)x,10);
string[6]=(char)(x+0x30);
x = (int)(f * 100);
x = (int)fmod((double)x,10);
string[7]=(char)(x+0x30);
string[8]=(char)(0);
return string;
}

//Certainly needs some work; I just knocked this up
//teh quick for the FPS countar, bounds checking,
//a saner way of calcing y and transparencies I'll
//do later!
void DrawSmallFont(int x, int y, char *pszText)
{
int src,crap,gay,why;
ushort *sauce,*targ;

targ = lpscreen+x+y*lpitch/2;

for (int i = 0; i < (int)strlen(pszText); i++)
{
crap = lpitch/2;
gay = crap;

src = (int)pszText[i];
why = src & 0x000000F0;
src = src & 0x0000000F;
why = why << 3;
src = src + why;
src = src << 3; //16 bit boi
sauce = QuakeChars.ghey;
sauce = sauce + src;

targ[0]=sauce[0];
targ[1]=sauce[1];
targ[2]=sauce[2];
targ[3]=sauce[3];
targ[4]=sauce[4];
targ[5]=sauce[5];
targ[6]=sauce[6];
targ[7]=sauce[7];

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*2)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*2)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*2)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*2)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*2)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*2)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*2)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*2)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*3)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*3)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*3)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*3)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*3)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*3)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*3)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*3)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*4)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*4)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*4)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*4)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*4)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*4)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*4)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*4)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*5)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*5)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*5)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*5)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*5)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*5)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*5)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*5)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*6)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*6)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*6)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*6)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*6)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*6)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*6)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*6)];

crap += gay;

targ[0+(crap)]=sauce[0+(SMALLFONTWIDTH*7)];
targ[1+(crap)]=sauce[1+(SMALLFONTWIDTH*7)];
targ[2+(crap)]=sauce[2+(SMALLFONTWIDTH*7)];
targ[3+(crap)]=sauce[3+(SMALLFONTWIDTH*7)];
targ[4+(crap)]=sauce[4+(SMALLFONTWIDTH*7)];
targ[5+(crap)]=sauce[5+(SMALLFONTWIDTH*7)];
targ[6+(crap)]=sauce[6+(SMALLFONTWIDTH*7)];
targ[7+(crap)]=sauce[7+(SMALLFONTWIDTH*7)];

targ += 8;
}
}

//***************
//* TIMING *
//***************

float GetGameTime()
{
UINT64 ticks;
float time;

QueryPerformanceCounter((LARGE_INTEGER *)&ticks);
//ticks = (UINT64)timeGetTime();

time = (float)(__int64)ticks/(float)(__int64)ticksPerSecond;

time -= timeAtGameStart;

return time;
}

void InitGameTime()
{
if( !QueryPerformanceFrequency((LARGE_INTEGER *)&ticksPerSecond) )
ticksPerSecond = 1000;

timeAtGameStart = 0;
timeAtGameStart = GetGameTime();
}

void UpdateFPS()
{
numFrames++;
float currentUpdate = GetGameTime();
if ( (currentUpdate - lastUpdate) > fpsUpdateInterval )
{
fps = numFrames / (currentUpdate - lastUpdate);
lastUpdate = currentUpdate;
numFrames = 0;
}
}

//*****************************
//** HIGH LEVEL BULLSHIT **
//*****************************

// aka HANDLE is a synonym
// for I FUCK DONKEYS

void EraseDesc (void)
{
memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
ddsd.dwSize = sizeof(DDSURFACEDESC2);
}

void DirectDrawRelease (void)
{
if (lpdd7)
{
lpdd7->Release();
lpdd7 = NULL;
}
if(back)
{
back->Release();
back = NULL;
}
if (lpPrimary)
{
lpPrimary->Release();
lpPrimary = NULL;
}
}

void DirectDrawInit (void)
{
long rval;

rval = DirectDrawCreate(NULL, &lpdd, NULL);

if (rval != DD_OK)
{
MessageBox(hwnd, "Failed to create the DirectDraw object", "Error", MB_OK);
quit = true;
}

rval = lpdd->QueryInterface(IID_IDirectDraw7, (LPVOID*)&lpdd7);

if (rval != DD_OK)
{
MessageBox(hwnd, "Failed to query interface for DirectDraw7", "Error", MB_OK);
quit = true;
}

if (lpdd)
{
lpdd->Release();
lpdd = NULL;
}

rval = lpdd7->SetCooperativeLevel(hwnd, DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE|DDSCL_ALLOWREBOOT);

if (rval != DD_OK)
{
MessageBox(hwnd, "Failed to set DirectDraw cooperative level", "Error", MB_OK);
quit = true;
}

rval = lpdd7->SetDisplayMode(swidth, sheight, sbpp, 0, 0);

if (rval != DD_OK)
{
MessageBox(hwnd, "Failed to set display mode", "Error", MB_OK);
quit = true;
}

EraseDesc();

ddsd.dwFlags = DDSD_CAPS|DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = 1;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_COMPLEX|DDSCAPS_FLIP;

rval = lpdd7->CreateSurface(&ddsd, &lpPrimary, NULL);
if(rval != DD_OK)
exit(1); // Falied to create the Primary surface

ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

rval = lpPrimary->GetAttachedSurface(&ddsd.ddsCaps, &back);
if(rval != DD_OK)
exit(1); // Failed to create and attach the Back Buffer

}

void ClearSurface(LPDIRECTDRAWSURFACE7 surface, int r, int g, int b)
{
DDBLTFX fx;

memset(&fx, 0, sizeof(fx));
fx.dwSize = sizeof(fx);
fx.dwFillColor = _16BIT(r, g, b);

surface->Blt(NULL, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &fx);
}

void LockSurface (LPDIRECTDRAWSURFACE7 surface)
{
EraseDesc();

if ((surface->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL)) != DD_OK)
MessageBox(hwnd, "Failed to lock the surface", "Surface Error", MB_OK);

lpitch = (int)ddsd.lPitch;
lpscreen = (ushort*)ddsd.lpSurface;
}

void UnlockSurface (LPDIRECTDRAWSURFACE7 surface)
{
surface->Unlock(NULL);

lpitch = 0;
lpscreen = NULL;
}

void Pixel (int x, int y, ushort color)
{
lpscreen[x + y * (lpitch >> 1)] = color;
}

//*=====================
// The event handler
//*=====================

LRESULT CALLBACK WinProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch(msg)
{
case WM_CLOSE:
{
PostQuitMessage(0);
break;
}
case WM_CREATE:
{
SetTimer(hwnd, 1, 10, NULL);
xrot = 0;
yrot = 0;
zrot = 0;
skale = 0.5;
skalemod = 0.01;
break;
}
case WM_DESTROY:
{
KillTimer(hwnd, 1);
break;
}
case WM_TIMER:
{
skale = skale + skalemod;
if (skale >= 0.9)
skalemod = -0.0002;
if (skale <= 0.01)
skalemod = 0.0002;
xrot++;
zrot++;
yrot = yrot + TOFMMAXX;
if (xrot > TEXTWIDTH)
xrot = 0;
if (zrot > 360)
zrot = 0;
if (yrot >= (TOFMMAXX*TOFMMAXY*2))
yrot = 0;
break;
}
}
return DefWindowProc(hwnd, msg, wparam, lparam);
}

//*=====================
// WinMain
//*=====================

int WINAPI WinMain(HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int nshowcmd)
{
MSG msg;
WNDCLASSEX ex;

ex.cbSize = sizeof(WNDCLASSEX);
ex.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
ex.lpfnWndProc = WinProc;
ex.cbClsExtra = 0;
ex.cbWndExtra = 0;
ex.hInstance = hinstance;
ex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
ex.hCursor = LoadCursor(NULL, IDC_ARROW);
ex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
ex.lpszMenuName = NULL;
ex.lpszClassName = WNDCLASSNAME;
ex.hIconSm = NULL;

RegisterClassEx(&ex);

// Create the window

hwnd = CreateWindowEx(0,
WNDCLASSNAME,
"Balls",
WS_POPUP,
0, 0,
300, 300,
NULL,
NULL,
hinstance,
0);

ShowWindow(hwnd, SW_SHOW);
UpdateWindow(hwnd);

DirectDrawInit();
InitGameTime();

LoadTehWurld(&tehwurld);
LoadConChars(&QuakeChars);
//PrintoutPlz();
MakeTehRotTables();
InitToffs();
//InitBasicCoordConversionTables();
// The message loop

while(!quit)
{
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if(msg.message == WM_QUIT || GetAsyncKeyState(VK_ESCAPE))
quit = true;

TranslateMessage(&msg);
DispatchMessage(&msg);
}

//DrawItFlidboi();
//DoSomeCrap(xrot);
UpdateFPS();
ClearSurface(back, 0, 0, 0);
LockSurface(back);
Lols(xrot,yrot,zrot,200,200,skale);
DrawSmallFont(500,460,"Fps:");
DrawSmallFont(540,460,ftos(fps));
UnlockSurface(back);
lpPrimary->Flip(back, DDFLIP_WAIT);
}

DirectDrawRelease();

return msg.lParam;
}

//End main.cpp

A couple of comments about this:

TOFF_BORD has been chosen both to give the required extra when the start pos is rotted to the horizontal/vertical rather than the top left corner, and to pad TOFMMAXX to a power of 2 which is necessary when v is converted from fixedpoint (rather than having a mulu in the innerloop!) u and v can then happily be added after shifting to give the position on the table.
The table gives a jump to another table, this formatted by cylindrical coords and giving a value in spherical ones.
Right here's where I've fucked up. I've added the rotation along the screen horizontal where I should have done this in the overhead. The table returns a jump to the texture (spherical coords because it's a Mercator projection) and then adds the x-rotation - i should have done this in the overhead too. Fine if you want it disting (maybe this could provide a cheap way of getting perspective later but I think it's better if I fix it, it'll probably look crap and it would be messy then to reverse it to click it with the mouse).

The other variables were picked pretty whimsically and should all be changable although changing the relationship between say TOFMMAXX and TOFMMAXY (1/1) or TEXTFACEX and TEXTFACEY (1/1) will require some extra work.

Rotation has a resolution of 720 (round equator) 800 (pole to pole) and 360 (z-rot in the rotozoomer). Zooming has a resolution of I-don't-have-a-fucking-clue.

More comments soon :P

Shit to add:

Bitmap print function
//- half finished, on it's way as soon as I can get on the fucking box
- Clean it the fuck up.
- Add bounds check.
- Maybe curpos or similar?
- I realise this will have less use in the Java implementation but I reckon it could still be handy, although I guess you can do better :)

//FPS counter
//- just needs the print function hahah

Phong shading
- if we cheat liek hell I reckon we can get TRUE phong for only two lookups (and a pretty big table)

//Fix that line in the innerloop
//- Two adds can be killed by adding to pointers in the overhead but I've bollocked on about this for long enough

Fix the holes at teh poles
//- I'd totally fucking forgotten about this but TBH it needs fixing pretty badly! I think it's an issue with arccos but I'll have to piss about with it to be sure. Otherwise I can always hack the tables after generation.
- Not fixed but looks miles better, at least the little black holes are gone.

Add clipping

Add support for multiple balls
- Should be pretty easy, do you reckon I do a z-buffer (might be a little slow tho, four indexed movs a contitional and some overhead) or fuck it and sort by distance? TBH the objects should never intersect and they're all convex so far.

User selected zoom/rotation
- Right I realise the left mouseclick is pretty much reserved for selecting stuff. I had a thought.. if you right-click on the ball the part you clicked on follows your mouse until you release it. If you click off the ball OR the ball is big enough to fill the screen then up/down is zoom, left/right is rotation alond NS axis. The first part will require a little calculation, the second won't. What do you reckon?

Other system controls
- In a bit. What are you planning for these? I won't do this for a while but this is pretty much dependent on our design, I don't want to forge ahead without asking you (although I doubt I'll get onto this for a while).
- Sort of related - when you click a point on the sphere what the hell are you selecting anyway?

Atmospheric Effex
- Again a bit of a design thing. I loved that effect you managed to get with your photoshop pix (I guess you did too and that's why you did them).. I can alphablend over the top but I've no idea how to get the halo.

Texture offsets and offsets-to-texture-offsets should be separate structures. In fact they shouldn't even be structures. I was trying to be forward-looking :D

</lj-cut>

Errm.. btw there is utterly NO error checking so the texture needs to be in the same folder and in the right format. It DOES work with other textures tho (720*360*256 bmp, no compression). I'll stick a moon in in a bit :D

//If ye want the source in it's current unfit state give us a shout.

Ta mate.

assign vZ goto mov
mov:
scan relative 1
cmath v0 = ((SGN(#enemy_x - #x_pos) + 1 + (SGN(#enemy_y - #y_pos) + 1) * 3 + (#cur_head - 1) * 9) + ((#cur_ammo < 5) * -36)) * (#scan < 5) * -1 + ((#scan = 5) * -72)
cmath v1 = ((#scan = 1) OR (#scan = 3)) * -1 + ((((#enemy_y - #y_pos) ^ 2) < 4) * -3) + ((((#enemy_x - #x_pos) ^ 2) < 4) * -6)
goto m ~v1 ~v0

m 0 0:
move forward
~vZ
m 0 1:
goto dukeit
m 0 2:
move forward
~vZ
m 0 3:
turn left
~vZ
m 0 4:
self destruct
m 0 5:
turn right
~vZ
m 0 6:
turn left
~vZ
m 0 7:
turn left
goto eek
m 0 8:
turn right
~vZ
m 0 9:
turn left
~vZ
m 0 10:
move forward
turn left
~vZ
m 0 11:
move forward
~vZ
m 0 12:
turn left
goto eek
m 0 13:
self destruct
m 0 14:
goto dukeit
m 0 15:
turn right
~vZ
m 0 16:
move forward
turn right
~vZ
m 0 17:
move forward
~vZ
m 0 18:
turn right
~vZ
m 0 19:
turn left
goto eek
m 0 20:
turn left
~vZ
m 0 21:
move forward
turn right
~vZ
m 0 22:
self destruct
m 0 23:
move forward
turn right
~vZ
m 0 24:
move forward
~vZ
m 0 25:
goto dukeit
m 0 26:
move forward
~vZ
m 0 27:
move forward
~vZ
m 0 28:
move forward
turn right
~vZ
m 0 29:
turn right
~vZ
m 0 30:
goto dukeit
m 0 31:
self destruct
m 0 32:
turn left
goto eek
m 0 33:
move forward
~vZ
m 0 34:
move forward
turn right
~vZ
m 0 35:
turn left
~vZ
m 0 36:
turn right
~vZ
m 0 37:
turn left
goto eek
m 0 38:
turn left
~vZ
m 0 39:
move forward
~vZ
m 0 40:
self destruct
m 0 41:
move forward
~vZ
m 0 42:
move forward
~vZ
m 0 43:
turn right
goto eek
m 0 44:
move forward
~vZ
m 0 45:
move forward
~vZ
m 0 46:
move forward
turn left
~vZ
m 0 47:
turn right
~vZ
m 0 48:
turn right
goto eek
m 0 49:
self destruct
m 0 50:
turn left
goto eek
m 0 51:
move forward
~vZ
m 0 52:
move forward
turn left
~vZ
m 0 53:
turn right
~vZ
m 0 54:
move forward
~vZ
m 0 55:
turn right
goto eek
m 0 56:
move forward
~vZ
m 0 57:
move forward
turn left
~vZ
m 0 58:
self destruct
m 0 59:
move forward
turn left
~vZ
m 0 60:
turn left
~vZ
m 0 61:
turn left
goto eek
m 0 62:
turn right
~vZ
m 0 63:
turn left
~vZ
m 0 64:
move forward
turn left
~vZ
m 0 65:
move forward
~vZ
m 0 66:
turn left
goto eek
m 0 67:
self destruct
m 0 68:
turn right
goto eek
m 0 69:
turn right
~vZ
m 0 70:
move forward
turn left
~vZ
m 0 71:
move forward
m 0 72:
goto flagrout
~vZ
m 1 0:
turn left
~vZ
m 1 1:
turn right
goto eek
m 1 2:
turn right
~vZ
m 1 3:
turn left
~vZ
m 1 4:
self destruct
m 1 5:
turn right
~vZ
m 1 6:
turn left
~vZ
m 1 7:
turn left
goto eek
m 1 8:
turn right
~vZ
m 1 9:
turn left
~vZ
m 1 10:
move backward
turn left
~vZ
m 1 11:
turn left
~vZ
m 1 12:
turn left
goto eek
m 1 13:
self destruct
m 1 14:
turn right
goto eek
m 1 15:
turn right
~vZ
m 1 16:
move backward
turn right
~vZ
m 1 17:
turn right
~vZ
m 1 18:
turn right
~vZ
m 1 19:
turn left
goto eek
m 1 20:
turn left
~vZ
m 1 21:
move backward
turn right
~vZ
m 1 22:
self destruct
m 1 23:
move backward
turn right
~vZ
m 1 24:
turn right
~vZ
m 1 25:
turn right
goto eek
m 1 26:
turn left
~vZ
m 1 27:
turn right
~vZ
m 1 28:
move backward
turn right
~vZ
m 1 29:
turn right
~vZ
m 1 30:
turn right
goto eek
m 1 31:
self destruct
m 1 32:
turn left
goto eek
m 1 33:
turn left
~vZ
m 1 34:
move backward
turn right
~vZ
m 1 35:
turn left
~vZ
m 1 36:
turn right
~vZ
m 1 37:
turn left
goto eek
m 1 38:
turn left
~vZ
m 1 39:
turn left
~vZ
m 1 40:
self destruct
m 1 41:
turn left
~vZ
m 1 42:
turn right
~vZ
m 1 43:
turn right
goto eek
m 1 44:
turn left
~vZ
m 1 45:
turn right
~vZ
m 1 46:
move backward
turn left
~vZ
m 1 47:
turn right
~vZ
m 1 48:
turn right
goto eek
m 1 49:
self destruct
m 1 50:
turn left
goto eek
m 1 51:
turn left
~vZ
m 1 52:
move backward
turn left
~vZ
m 1 53:
turn right
~vZ
m 1 54:
turn left
~vZ
m 1 55:
turn right
goto eek
m 1 56:
turn right
~vZ
m 1 57:
move forward
turn left
~vZ
m 1 58:
self destruct
m 1 59:
move backward
turn left
~vZ
m 1 60:
turn left
~vZ
m 1 61:
turn left
goto eek
m 1 62:
turn right
~vZ
m 1 63:
turn left
~vZ
m 1 64:
move backward
turn left
~vZ
m 1 65:
turn left
~vZ
m 1 66:
turn left
goto eek
m 1 67:
self destruct
m 1 68:
turn right
goto eek
m 1 69:
turn right
~vZ
m 1 70:
move backward
turn right
~vZ
m 1 71:
turn right
~vZ
m 1 72:
goto flagrout
flagrout:
if value #cur_life > 0 then move forward
if value #cloakstatus = 1 then cloak off
scan relative 1
if value #scan <> 5 then ~vZ
scan relative 5
if value #scan = 0 then goto flag_1
scan relative 3
if value #scan = 0 then goto flag_2
scan relative 7
if value #scan = 0 then goto flag_3
if value #curlife = 0 then discharge energy
~vZ
flag_1:
move backward
if value #curlife = 0 then discharge energy
move forward
move forward
~vZ
flag_2:
turn right
move forward
move forward
if value #curlife = 0 then discharge energy
move backward
move backward
turn left
move forward
~vZ
flag_3:
turn left
move forward
move forward
if value #curlife = 0 then discharge energy
move backward
move backward
turn right
move forward
~vZ
m 3 0:
turn left
~vZ
m 3 1:
goto dukeit
m 3 2:
turn right
~vZ
m 3 3:
turn left
~vZ
m 3 4:
self destruct
m 3 5:
turn right
~vZ
m 3 6:
turn left
~vZ
m 3 7:
turn left
goto eek
m 3 8:
turn right
~vZ
m 3 9:
turn left
~vZ
m 3 10:
move forward
turn left
~vZ
m 3 11:
goto bomberer
m 3 12:
turn left
goto eek
m 3 13:
self destruct
m 3 14:
goto dukeit
m 3 15:
turn right
~vZ
m 3 16:
move forward
turn right
~vZ
m 3 17:
goto bomberer
m 3 18:
turn right
~vZ
m 3 19:
turn left
goto eek
m 3 20:
turn left
~vZ
m 3 21:
move forward
turn right
~vZ
m 3 22:
self destruct
m 3 23:
move forward
turn right
~vZ
m 3 24:
turn right
~vZ
m 3 25:
goto dukeit
m 3 26:
turn left
~vZ
m 3 27:
goto bomberer
m 3 28:
move forward
turn right
~vZ
m 3 29:
turn right
~vZ
m 3 30:
goto dukeit
~vZ
m 3 31:
self destruct
m 3 32:
turn left
goto eek
~vZ
m 3 33:
goto bomberer
m 3 34:
move forward
turn right
~vZ
m 3 35:
turn left
~vZ
m 3 36:
turn right
~vZ
m 3 37:
turn left
goto eek
~vZ
m 3 38:
turn left
~vZ
m 3 39:
move forward
~vZ
m 3 40:
self destruct
m 3 41:
move forward
~vZ
m 3 42:
move forward
~vZ
m 3 43:
turn right
goto eek
m 3 44:
move forward
~vZ
m 3 45:
move forward
~vZ
m 3 46:
move forward
turn left
~vZ
m 3 47:
turn right
~vZ
m 3 48:
turn right
goto eek
m 3 49:
self destruct
m 3 50:
turn left
goto eek
m 3 51:
move forward
~vZ
m 3 52:
move forward
turn left
~vZ
m 3 53:
turn right
~vZ
m 3 54:
move forward
~vZ
m 3 55:
turn right
goto eek
m 3 56:
move forward
~vZ
m 3 57:
move forward
turn left
~vZ
m 3 58:
self destruct
m 3 59:
move forward
turn left
~vZ
m 3 60:
turn left
~vZ
m 3 61:
turn left
goto eek
m 3 62:
turn right
~vZ
m 3 63:
turn left
~vZ
m 3 64:
move forward
turn left
~vZ
m 3 65:
move forward
~vZ
m 3 66:
turn left
goto eek
m 3 67:
self destruct
m 3 68:
turn right
goto eek
m 3 69:
turn right
~vZ
m 3 70:
move forward
turn left
~vZ
m 3 71:
move forward
~vZ
m 3 72:
goto flagrout
m 4 0:
move backward
turn left
~vZ
m 4 1:
turn right
goto eek
m 4 2:
move backward
turn right
~vZ
m 4 3:
turn left
~vZ
m 4 4:
self destruct
m 4 5:
turn right
~vZ
m 4 6:
turn left
~vZ
m 4 7:
turn left
goto eek
m 4 8:
turn right
~vZ
m 4 9:
turn left
~vZ
m 4 10:
move backward
turn left
~vZ
m 4 11:
move backward
turn left
~vZ
m 4 12:
turn left
goto eek
m 4 13:
self destruct
m 4 14:
turn right
goto eek
m 4 15:
turn right
~vZ
m 4 16:
move backward
turn right
~vZ
m 4 17:
turn right
move backward
~vZ
m 4 18:
turn right
~vZ
m 4 19:
turn left
goto eek
m 4 20:
turn left
~vZ
m 4 21:
move backward
turn right
~vZ
m 4 22:
self destruct
m 4 23:
move backward
turn right
~vZ
m 4 24:
move backward
turn right
~vZ
m 4 25:
turn right
goto eek
m 4 26:
move backward
turn left
~vZ
m 4 27:
move backward
turn right
~vZ
m 4 28:
move backward
turn right
~vZ
m 4 29:
turn right
~vZ
m 4 30:
turn right
goto eek
m 4 31:
self destruct
m 4 32:
turn left
goto eek
m 4 33:
move backward
turn left
~vZ
m 4 34:
move backward
turn right
~vZ
m 4 35:
turn left
~vZ
m 4 36:
turn right
~vZ
m 4 37:
turn left
goto eek
m 4 38:
turn left
~vZ
m 4 39:
turn left
~vZ
m 4 40:
self destruct
m 4 41:
turn left
~vZ
m 4 42:
turn right
~vZ
m 4 43:
turn right
goto eek
m 4 44:
turn left
~vZ
m 4 45:
turn right
~vZ
m 4 46:
move backward
turn left
~vZ
m 4 47:
turn right
~vZ
m 4 48:
turn right
goto eek
m 4 49:
self destruct
m 4 50:
turn left
goto eek
m 4 51:
turn left
~vZ
m 4 52:
move backward
turn left
~vZ
m 4 53:
turn right
~vZ
m 4 54:
turn left
~vZ
m 4 55:
turn right
goto eek
m 4 56:
turn right
~vZ
m 4 57:
move forward
turn left
~vZ
m 4 58:
self destruct
m 4 59:
move backward
turn left
~vZ
m 4 60:
turn left
~vZ
m 4 61:
turn left
goto eek
m 4 62:
turn right
~vZ
m 4 63:
turn left
~vZ
m 4 64:
move backward
turn left
~vZ
m 4 65:
turn left
~vZ
m 4 66:
turn left
goto eek
m 4 67:
self destruct
m 4 68:
turn right
goto eek
m 4 69:
turn right
~vZ
m 4 70:
move backward
turn right
~vZ
m 4 71:
turn right
~vZ
m 4 72:
goto flagrout
m 6 0:
goto bomberer
m 6 1:
goto dukeit
m 6 2:
goto bomberer
m 6 3:
turn left
~vZ
m 6 4:
self destruct
m 6 5:
turn right
~vZ
m 6 6:
turn left
~vZ
m 6 7:
turn left
goto eek
~vZ
m 6 8:
turn right
~vZ
m 6 9:
turn left
~vZ
m 6 10:
move forward
turn left
~vZ
m 6 11:
turn left
~vZ
m 6 12:
turn left
goto eek
m 6 13:
self destruct
m 6 14:
goto dukeit
~vZ
m 6 15:
turn right
~vZ
m 6 16:
move forward
turn right
~vZ
m 6 17:
turn right
~vZ
m 6 18:
turn right
~vZ
m 6 19:
turn left
goto eek
m 6 20:
turn left
~vZ
m 6 21:
move forward
turn right
~vZ
m 6 22:
self destruct
m 6 23:
move forward
turn right
~vZ
m 6 24:
goto bomberer
m 6 25:
goto dukeit
m 6 26:
goto bomberer
m 6 27:
turn right
~vZ
m 6 28:
move forward
turn right
~vZ
m 6 29:
turn right
~vZ
m 6 30:
goto dukeit
m 6 31:
self destruct
m 6 32:
turn left
goto eek
m 6 33:
turn left
~vZ
m 6 34:
move forward
turn left
~vZ
m 6 35:
turn left
~vZ
m 6 36:
turn right
~vZ
m 6 37:
turn left
goto eek
m 6 38:
turn left
~vZ
m 6 39:
move forward
~vZ
m 6 40:
self destruct
m 6 41:
move forward
~vZ
m 6 42:
move forward
~vZ
m 6 43:
turn right
goto eek
m 6 44:
move forward
~vZ
m 6 45:
move forward
~vZ
m 6 46:
move forward
turn left
~vZ
m 6 47:
turn right
~vZ
m 6 48:
turn right
goto eek
m 6 49:
self destruct
m 6 50:
turn left
goto eek
m 6 51:
move forward
~vZ
m 6 52:
move forward
turn left
~vZ
m 6 53:
turn right
~vZ
m 6 54:
move forward
~vZ
m 6 55:
turn right
goto eek
m 6 56:
move forward
~vZ
m 6 57:
move forward
turn left
~vZ
m 6 58:
self destruct
m 6 59:
move forward
turn left
~vZ
m 6 60:
turn left
~vZ
m 6 61:
turn left
goto eek
m 6 62:
turn right
~vZ
m 6 63:
turn left
~vZ
m 6 64:
move forward
turn left
~vZ
m 6 65:
move forward
~vZ
m 6 66:
turn left
goto eek
~vZ
m 6 67:
self destruct
m 6 68:
turn right
goto eek
m 6 69:
turn right
~vZ
m 6 70:
move forward
turn left
~vZ
m 6 71:
move forward
~vZ
m 6 72:
goto flagrout
m 7 0:
move backward
turn left
~vZ
m 7 1:
turn right
goto eek
m 7 2:
move backward
turn right
~vZ
m 7 3:
turn left
~vZ
m 7 4:
self destruct
m 7 5:
turn right
~vZ
m 7 6:
turn left
~vZ
m 7 7:
turn left
goto eek
m 7 8:
turn right
~vZ
m 7 9:
turn left
~vZ
m 7 10:
move backward
turn left
~vZ
m 7 11:
move backward
turn left
~vZ
m 7 12:
self destruct
~vZ
m 7 13:
self destruct
m 7 14:
turn right
;goto eek
m 7 15:
turn right
~vZ
m 7 16:
move backward
turn right
~vZ
m 7 17:
move backward
turn right
~vZ
m 7 18:
turn right
~vZ
m 7 19:
turn left
goto eek
m 7 20:
turn left
~vZ
m 7 21:
move backward
turn right
~vZ
m 7 22:
self destruct
m 7 23:
move backward
turn right
~vZ
m 7 24:
move backward
turn right
~vZ
m 7 25:
turn right
goto eek
~vZ
m 7 26:
move backward
turn left
~vZ
m 7 27:
move backward
turn right
~vZ
m 7 28:
move backward
turn right
~vZ
m 7 29:
move backward
turn right
~vZ
m 7 30:
turn right
goto eek
m 7 31:
self destruct
m 7 32:
turn left
goto eek
m 7 33:
turn left
~vZ
m 7 34:
move backward
turn left
~vZ
m 7 35:
turn left
~vZ
m 7 36:
turn right
~vZ
m 7 37:
turn left
goto eek
m 7 38:
turn left
~vZ
m 7 39:
turn left
~vZ
m 7 40:
self destruct
m 7 41:
turn left
~vZ
m 7 42:
turn right
~vZ
m 7 43:
turn right
goto eek
m 7 44:
turn left
~vZ
m 7 45:
turn right
~vZ
m 7 46:
move backward
turn left
~vZ
m 7 47:
turn right
~vZ
m 7 48:
turn right
goto eek
m 7 49:
self destruct
m 7 50:
turn left
goto eek
m 7 51:
turn left
~vZ
m 7 52:
move backward
turn left
~vZ
m 7 53:
turn right
~vZ
m 7 54:
turn left
~vZ
m 7 55:
turn right
goto eek
m 7 56:
turn right
~vZ
m 7 57:
move backward
turn left
~vZ
m 7 58:
self destruct
m 7 59:
move backward
turn left
~vZ
m 7 60:
turn left
~vZ
m 7 61:
turn left
goto eek
m 7 62:
turn right
~vZ
m 7 63:
turn left
~vZ
m 7 64:
move backward
turn left
~vZ
m 7 65:
turn left
~vZ
m 7 66:
turn left
goto eek
m 7 67:
self destruct
m 7 68:
turn right
goto eek
m 7 69:
turn right
~vZ
m 7 70:
move backward
turn right
~vZ
m 7 71:
turn right
~vZ
m 7 72:
goto flagrout
toast:
if value #cloakstatus = 1 then cloak off
cmath vT = ((#cur_life > 6) AND (#enemy_d < 8)) OR ((#cur_fuel < #burn) AND (#cur_ammo < 10))
if value ~vT <> 0 then self destruct
discharge energy
scan perimeter
if scan found enemy then goto toast
if scan found flag then goto toastgrab
~vZ
toastgrab:
assign vT 0
grabtoast:
scan relative 1
if scan found flag then move forward
if scan found flag then ~vZ
scan relative 2
if scan found flag then move forward
if scan found flag then turn right
if scan found flag then move forward
if scan found flag then ~vZ
turn right
cmath vT = ~vT + 1
if value ~vT < 4 then goto grabtoast
~vZ
m 9 0:
goto toast
m 9 1:
goto toast
m 9 2:
goto toast
m 9 3:
goto toast
m 9 4:
goto toast
m 9 5:
goto toast
m 9 6:
goto toast
m 9 7:
goto toast
m 9 8:
goto toast
m 9 9:
goto toast
m 9 10:
goto toast
m 9 11:
goto toast
m 9 12:
goto toast
m 9 13:
goto toast
m 9 14:
goto toast
m 9 15:
goto toast
m 9 16:
goto toast
m 9 17:
goto toast
m 9 18:
goto toast
m 9 19:
goto toast
m 9 20:
goto toast
m 9 21:
goto toast
m 9 22:
goto toast
m 9 23:
goto toast
m 9 24:
goto toast
m 9 25:
goto toast
m 9 26:
goto toast
m 9 27:
goto toast
m 9 28:
goto toast
m 9 29:
goto toast
m 9 30:
goto toast
m 9 31:
goto toast
m 9 32:
goto toast
m 9 33:
goto toast
m 9 34:
goto toast
m 9 35:
goto toast
m 9 36:
goto toast
m 9 37:
goto toast
m 9 38:
goto toast
m 9 39:
goto toast
m 9 40:
goto toast
m 9 41:
goto toast
m 9 42:
goto toast
m 9 43:
goto toast
m 9 44:
goto toast
m 9 45:
goto toast
m 9 46:
goto toast
m 9 47:
goto toast
m 9 48:
goto toast
m 9 49:
goto toast
m 9 50:
goto toast
m 9 51:
goto toast
m 9 52:
goto toast
m 9 53:
goto toast
m 9 54:
goto toast
m 9 55:
goto toast
m 9 56:
goto toast
m 9 57:
goto toast
m 9 58:
goto toast
m 9 59:
goto toast
m 9 60:
goto toast
m 9 61:
goto toast
m 9 62:
goto toast
m 9 63:
goto toast
m 9 64:
goto toast
m 9 65:
goto toast
m 9 66:
goto toast
m 9 67:
goto toast
m 9 68:
goto toast
m 9 69:
goto toast
m 9 70:
goto toast
m 9 71:
goto toast
m 9 72:
goto toast
m 10 0:
goto toast
m 10 1:
goto toast
m 10 2:
goto toast
m 10 3:
goto toast
m 10 4:
goto toast
m 10 5:
goto toast
m 10 6:
goto toast
m 10 7:
goto toast
m 10 8:
goto toast
m 10 9:
goto toast
m 10 10:
goto toast
m 10 11:
goto toast
m 10 12:
goto toast
m 10 13:
goto toast
m 10 14:
goto toast
m 10 15:
goto toast
m 10 16:
goto toast
m 10 17:
goto toast
m 10 18:
goto toast
m 10 19:
goto toast
m 10 20:
goto toast
m 10 21:
goto toast
m 10 22:
goto toast
m 10 23:
goto toast
m 10 24:
goto toast
m 10 25:
goto toast
m 10 26:
goto toast
m 10 27:
goto toast
m 10 28:
goto toast
m 10 29:
goto toast
m 10 30:
goto toast
m 10 31:
goto toast
m 10 32:
goto toast
m 10 33:
goto toast
m 10 34:
goto toast
m 10 35:
goto toast
m 10 36:
goto toast
m 10 37:
goto toast
m 10 38:
goto toast
m 10 39:
goto toast
m 10 40:
goto toast
m 10 41:
goto toast
m 10 42:
goto toast
m 10 43:
goto toast
m 10 44:
goto toast
m 10 45:
goto toast
m 10 46:
goto toast
m 10 47:
goto toast
m 10 48:
goto toast
m 10 49:
goto toast
m 10 50:
goto toast
m 10 51:
goto toast
m 10 52:
goto toast
m 10 53:
goto toast
m 10 54:
goto toast
m 10 55:
goto toast
m 10 56:
goto toast
m 10 57:
goto toast
m 10 58:
goto toast
m 10 59:
goto toast
m 10 60:
goto toast
m 10 61:
goto toast
m 10 62:
goto toast
m 10 63:
goto toast
m 10 64:
goto toast
m 10 65:
goto toast
m 10 66:
goto toast
m 10 67:
goto toast
m 10 68:
goto toast
m 10 69:
goto toast
m 10 70:
goto toast
m 10 71:
goto toast
m 10 72:
goto toast

; TEH END
; HOORAY!

0 0 0 1 0 0 1 0 0 19
0 1 1 0 0 1 0 1 0 20

rofl

Hamsoft Trivia #30739: Mark is a teribel codar!

I will post some REAL CODE soon, just fannying around with Directdraw which has no relevance to Hamwars at all but there's no point sending it ya if it doesn't work!

Hamsoft Internal Communique
For eyes of Hamsoft High Council members ONLY

CAUTION: Contains subliminal texts. Anyone not of the above descrition who reads this will kill in their sleep and probably start listening to Genesis

Sorry dude, tried to Gmail this to ya but it was being gay, and I didn't want to resend so I didn't end up filling yr inbox with this shit!!
(Yes I know I could have just checked but it was being clunky and hey, you made a community for this, might as well go here)
This is of course RE: hamwars v1.doc, which was a VARY good doc I must say!

Dude that totally rules! Thanks for sending that man, sorry I've only just been able to get it because Gmail was being ginger.

If you want my opinions on your musings in the doc here's my initial ideas.

Intarface:
Argh. I really really so don't know. I guess the important thing is to see what information possibly ever needs to be exchanged. Could the whole client end be one java app which changes it's behaviour based on the messages from the server? I guess then we could keep it menu based until we've got the backend working if we wanted to, and work from there!

Movement between systems etc:
Yeah, I think the sector idea is a very good one. Maybe when you dispatch a fleet you give them a target, and if you want to you specify a route you can, otherwise it generates the quickest, and then the route info is saved as a string in the fleet structure. With space being 3d maybe we could do one of those free-rotating 'stalk' diagrams like in Elite? I don't think it would take too much bandwidth because you'd only see what your scanners could pick up (you request the info, the server does a search for all your fleets and then searches round them). You could set agression for your ships, or even maybe 'missions' with limited options, and if they pass a ship in the overnight simulation 'turn' which is in range they engage and destroy! This is for FLT travel and interplanetary travel but maybe you could later develop hyperdrives which asks the question should we alow combat in hyperspace?? WTF does hyperspace even look like? Maybe a transform function of real 3d space onto a 2d grid, hahah, I'll get my maths notes out, there must be something cool we can do so hyperspace looks 'weird' yet everything is close together if you don't just want hyperspace to be a 'jump'.

Server:
ARGH. I don't know. I have a P200 box here which isn't being used, maybe we could use that and hopefully when it becomes an issue we'll have sponsorship, hahah.
I had a really fucked up thought, maybe we could use a C/C++ backend? I really don't have a fucking clue how to get it talking to a Java server, I'll have a look. It's a totally messed up idea but I can actually write C, and we'd be able to do more with it w. speed issues. Plus I could get my rocks off with some ASM optimisations, lol. Your call as always man, and probably even if we entertain this idea it'd be something for a backend upgrade.

Feral Colonies:
I totally see what you mean, we'd need millions more techs and unit types, and it would be boring for most people (tho the truly hardcore would want to build everything from scratch.) Maybe we could leave room for it and add it in as an option later, I can see possible benefits for the player (if you did it from scratch your empire might turn out more harmonious and efficient for instance, or maybe we give them some bonus techs and units for being hardcore). Or we could not, haha.
Maybe for the future we could have 3 (or more) startup modes:

Colonic: You start off as a colony of 'settler's, one hyperspace or FLT ship but you have to research to get more.

Turbo Thrash: You start off as rebels, someone else's rebel colony no less (we keep a list and hand them out 'blind' on request) For people who want a quick and bloody war, probably, or good gamers who want to give evryone else a disadvantage.

Feral World Expansion: You start off as a tribe of feral hamsters on a sandbox world, and develop a civilisation from scratch, whizing thru different eras and developing space travel after a month or two RL time. By this time you've already got alliances and trade set up, and maybe a Space Exploration initiative with your neighbouring states to speed up research and shit. It sounds gay but this mode would lead to interesting nations (did you ever play Megolomania? Roman soldiers in biplanes, boiling oil and nuclear missiles etc.. like a 'what if' scenario if things had developed at different rates than they did.)

Next: A load of "FUCK yeah"s for some really cool writings, hahah. Good work man :D

Alliances/Police:
Dude that's a damn cool idea, personally I think there's room for it even if it would be hard to implement. Would it also have a list of 'banned' activities, like genocide and biological warfare? Then you'd have to hide your concentration camps, or could report other people's (everyone could have a 'reputation' with the Feds, if you report someone and they find nothing your reputation goes down a bit, if you report them and they find something their reputation goes down a lot, if rep gets too low they impose sanctions or invade, if rep gets high they ask you to help or something gay etc)

Each habitation unit has plug in units etc: Fuck yeah!

Localised or Planetary resources: Maybe they could be done fractally by the backend, and saved with the habitation unit once it's built?

Will it revert to low-level unit: I was thinking it could have a % health and % population. A low % health would have poor production and unhappy people, a low % population would have poor production and would be 'abandoned' etc. When the % pop grows near 100% you want to upgrade or it gets overpopulated, unhappy and inefficient and may rebel (should we have an 'auto-upgrade' flag if you're confident you have enough construction crews? Things like that could be shifted automatically by your merchant fleet - we'd need an algorithm to work out shipping anyway)

Organic Units: Yeah! Dude how about eugenics? I know it's a horrible fucking concept but then they could build concentration camps etc (or maybe the concentration camps could just be for dissidents, hahah) It also opens the path for gene-specific bioweapons, which would be a cool feature if a bit powerful.

Weapons: Yeah man, I agree it would be hard. I was thinking a weird roster system for the military would be cool; you define a squad w. weapons and the backend simulates it for effectiveness. Like, you define building blocks (and you're only alowed a few so it doesn't get messy) then your barracks recruits the men and your factories build the weapons.
Also what about logistics? I know it sounds really gay but it could be done largely automatically, and I like the thought of a bloody frontline with columns of trucks and helicopters carting in food and ammo and carting back hundreds of slain and wounded because I'm strange like that. What do you reckon? It would set it up nicely for trench warfare and attacks on supply lines I guess, and add some nice elements to warfare (and a new AI option), plus a nice dilemma for players who could either storm in or hold back til their logistics are sorted out. Might be a little tricky to get to grips with though, so:

I was thinking for the sandbox that we could put in a hardcoded tribe to subjugate right away, and walk the player through the first turn (as soon as they set up a colony or feral tribe). Like a choreographed first encounter to get them sorted, with maybe a choice at the end to get them into it (not a 'yes/no' type thing, a bit freer, like 'do I sack the place or subjugate them'). Obviously it would look a little different for everyone, but we could ensure it happens pretty much the same. Obviously there would probably be more little conflicts like this to keep it interesting for the first few days, but if we could make sure the first one is the same we could make a nice tutorialy thingy. Also it would work with the feral guys to if we ever do that, just with different starting unit types.

Argh, I've digressed from the point I wanted to make. Right; with the building block system which is sort of ripped off Supremacy but more refined you wouldn't have billions of different weapons floating about anyway, it'd be a lot neater, so you could afford to add some modified ones to your production roster. So if you wanted to develop a new sniper rifle you could put £10,000 into research and get an extra 1% accuracy. Then, if you wanted a better model you'd put in £100,000, and get another 1% accuracy. With a logarithmic scale we could get people to spend billions just to have the best in the galaxy, far beyond the point where it becomes useful at all to make them better :) Benefits of course is that everyone would buy their rifles. What would happen when you buy gear? I reckon it needs to be localised; that way when you take a town you can loot it!
Hmm, I guess it gets a bit tricky in other ways though, like you said. Maybe have a global list of weapons, with type, stats, ammo type and producer?
Of course selling production and export rights, reverse engineering and espionage should be possible. Maybe with research facilities you can either designate wht their doing manually or add them to a pool where research would be delegated. This could be applied to factories too!

I've talked far more bollocks for much longer than I intended there man, sorry!

Argh, this shit I'm doing with Josh's dad (the lift thing) has to be my priority at the moment, but it's cool because I'm learning a fuckload. Hopefully I might know enough to get into this soon, if you still want my help! Like I said regardless of how much of this shit you want to use I'd be more than happy to help if you can find a use for me. Also I'll get working on some C/pseudocode for some of the backend shit if you want just to illustrate some of my stupid ideas.

Cheers man, fucking nice one with the docs!
- Mark

Okay i've stuck the screenshot on the website, i am planning on sticking a few more on later.

I've also put a couple of links to infomation regarding star and planetary types. makes for interesting reading.

Currently working on a system generation program which will encompass this infomation. Within a couple of weeks i hope to have a working server app running on a machine which will allow users to explore the 3d universe it is dynamically creating.

I guess you'll have to wait and see :)

greetings troops. Yes it's finally here the very first screenshot from Hamwars:

good news peeps

google now lists the hamwars site when searched for: H A M W A R Z