507 lines
15 KiB
C
507 lines
15 KiB
C
#include <malloc.h>
|
|
#include <math.h>
|
|
|
|
#include "log.h"
|
|
#include "physics.h"
|
|
#include "rng.h"
|
|
#include "pack.h"
|
|
#include "space.h"
|
|
#include "faction.h"
|
|
#include "xml.h"
|
|
#include "pause.h"
|
|
#include "player.h"
|
|
|
|
#define XML_PLANET_ID "Planets"
|
|
#define XML_PLANET_TAG "planet"
|
|
|
|
#define XML_SYSTEM_ID "Systems"
|
|
#define XML_SYSTEM_TAG "ssys"
|
|
|
|
#define PLANET_DATA "../dat/planet.xml"
|
|
#define SYSTEM_DATA "../dat/ssys.xml"
|
|
|
|
#define PLANET_GFX_SPACE "../gfx/planet/space/"
|
|
#define PLANET_GFX_EXTERIOR "../gfx/planet/exterior/"
|
|
|
|
#define PLANET_GFX_EXTERIOR_W 400
|
|
#define PLANET_GFX_EXTERIOR_H 400
|
|
|
|
// Overcome warning due to zero value.
|
|
|
|
#define FLAG_XSET (1<<0)
|
|
#define FLAG_YSET (1<<1)
|
|
#define FLAG_ASTEROIDSSET (1<<2)
|
|
#define FLAG_INTEFERENCESET (1<<3)
|
|
|
|
static StarSystem* systems = NULL;
|
|
static int nsystems = 0;
|
|
StarSystem* cur_system = NULL; // Current star system.
|
|
|
|
// Current stardate in nice format.
|
|
char* stardate = "Stardate";
|
|
unsigned int date = 0; // time since epoch.
|
|
|
|
#define STAR_BUF 100 // Area to leave around screen, more = less repitition.
|
|
typedef struct {
|
|
double x, y; // Position. It is simpler ligher to use two doubles than the physics.
|
|
double brightness;
|
|
} Star;
|
|
|
|
static Star* stars = NULL; // Star array.
|
|
static int nstars = 0; // Total stars.
|
|
|
|
// Intern
|
|
static Planet* planet_get(const char* name);
|
|
static StarSystem* system_parse(const xmlNodePtr parent);
|
|
static PlanetClass planetclass_get(const char a);
|
|
// Extern.
|
|
extern void player_message(const char* fmt, ...);
|
|
|
|
// Draw the planet. Used in planet.c
|
|
// Matrix mode is already displaced to center of the minimap.
|
|
#define PIXEL(x,y) if((shape == RADAR_RECT && ABS(x)<w/2. && ABS(y)<h/2.) || \
|
|
(shape == RADAR_CIRCLE && (((x)*(x)+(y)*(y)) < rc))) glVertex2i((x),(y))
|
|
void planets_minimap(const double res, const double w, const double h, const RadarShape shape) {
|
|
int i;
|
|
int cx, cy, x, y, r, rc;
|
|
double p;
|
|
|
|
if(shape == RADAR_CIRCLE) rc = (int)(w*w);
|
|
|
|
glBegin(GL_POINTS);
|
|
glMatrixMode(GL_PROJECTION);
|
|
for(i = 0; i < cur_system->nplanets; i++) {
|
|
r = (int)(cur_system->planets[i].gfx_space->sw / res);
|
|
cx = (int)((cur_system->planets[i].pos.x - player->solid->pos.x) / res);
|
|
cy = (int)((cur_system->planets[i].pos.y - player->solid->pos.y) / res);
|
|
|
|
x = 0;
|
|
y = r;
|
|
p = (5. - (double)(r*3)) / 4.;
|
|
|
|
PIXEL(cx, cy+y);
|
|
PIXEL(cx, cy-y);
|
|
PIXEL(cx+y, cy);
|
|
PIXEL(cx-y, cy);
|
|
|
|
while(x < y) {
|
|
x++;
|
|
if(p < 0) p += 2*(double)(x)+1;
|
|
else p += 2*(double)(x-(--y))+1;
|
|
|
|
if(x == 0) {
|
|
PIXEL(cx, cy+y);
|
|
PIXEL(cx, cy-y);
|
|
PIXEL(cx+y, cy);
|
|
PIXEL(cx-y, cy);
|
|
} else
|
|
if(x == y) {
|
|
PIXEL(cx+x, cy+y);
|
|
PIXEL(cx-x, cy+y);
|
|
PIXEL(cx+x, cy-y);
|
|
PIXEL(cx-x, cy-y);
|
|
} else
|
|
if(x < y) {
|
|
PIXEL(cx+x, cy+y);
|
|
PIXEL(cx-x, cy+y);
|
|
PIXEL(cx+x, cy-y);
|
|
PIXEL(cx-x, cy-y);
|
|
PIXEL(cx+y, cy+x);
|
|
PIXEL(cx-y, cy+x);
|
|
PIXEL(cx+y, cy-x);
|
|
PIXEL(cx-y, cy-x);
|
|
}
|
|
}
|
|
}
|
|
if(ABS(x) < w/2. && ABS(y) < h/2.) {}
|
|
glEnd();
|
|
}
|
|
#undef PIXEL
|
|
|
|
static PlanetClass planetclass_get(const char a) {
|
|
switch(a) {
|
|
case 'A': return PLANET_CLASS_A;
|
|
case 'B': return PLANET_CLASS_B;
|
|
case 'C': return PLANET_CLASS_C;
|
|
case 'D': return PLANET_CLASS_D;
|
|
case 'E': return PLANET_CLASS_E;
|
|
case 'F': return PLANET_CLASS_F;
|
|
case 'G': return PLANET_CLASS_G;
|
|
case 'H': return PLANET_CLASS_H;
|
|
case 'I': return PLANET_CLASS_I;
|
|
case 'J': return PLANET_CLASS_J;
|
|
case 'K': return PLANET_CLASS_K;
|
|
case 'L': return PLANET_CLASS_L;
|
|
case 'M': return PLANET_CLASS_M;
|
|
case 'N': return PLANET_CLASS_N;
|
|
case 'O': return PLANET_CLASS_O;
|
|
case 'P': return PLANET_CLASS_P;
|
|
case 'Q': return PLANET_CLASS_Q;
|
|
case 'R': return PLANET_CLASS_R;
|
|
case 'S': return PLANET_CLASS_S;
|
|
case 'T': return PLANET_CLASS_T;
|
|
case 'X': return PLANET_CLASS_X;
|
|
case 'Y': return PLANET_CLASS_Y;
|
|
case 'Z': return PLANET_CLASS_Z;
|
|
|
|
default: return PLANET_CLASS_NULL;
|
|
};
|
|
}
|
|
|
|
// Hyperspaces, return 0 if entering hyperspace, or distance otherwise.
|
|
int space_hyperspace(Pilot* p) {
|
|
int i;
|
|
double d;
|
|
for(i = 0; i < cur_system->nplanets; i++) {
|
|
d = vect_dist(&p->solid->pos, &cur_system->planets[i].pos);
|
|
if(d < MIN_HYPERSPACE_DIST)
|
|
return (int)(MIN_HYPERSPACE_DIST - d);
|
|
}
|
|
// Too fast.
|
|
if(VMOD(p->solid->vel) > MAX_HYPERSPACE_VEL) return -1;
|
|
|
|
// TODO: All hyperspace worky work.
|
|
if(p == player) {
|
|
// Player crap.
|
|
} else {
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Init the system.
|
|
void space_init(const char* sysname) {
|
|
int i, j;
|
|
Vec2 v, vn;
|
|
|
|
for(i = 0; i < nsystems; i++)
|
|
if(strcmp(sysname, systems[i].name)==0)
|
|
break;
|
|
if(i == nsystems) ERR("System %s not found in stack", sysname);
|
|
cur_system = systems+i;
|
|
|
|
player_message("Entering System %s on %s", sysname, stardate);
|
|
|
|
// Set up stars.
|
|
nstars = (cur_system->stars*gl_screen.w*gl_screen.h+STAR_BUF*STAR_BUF)/(800*640);
|
|
stars = realloc(stars, sizeof(Star)*nstars); // Should realloc this, not malloc.
|
|
for(i = 0; i < nstars; i++) {
|
|
stars[i].brightness = (double)RNG(50, 200)/256.;
|
|
stars[i].x = (double)RNG(-STAR_BUF, gl_screen.w + STAR_BUF);
|
|
stars[i].y = (double)RNG(-STAR_BUF, gl_screen.h + STAR_BUF);
|
|
}
|
|
// Set up fleets -> pilots.
|
|
vectnull(&vn);
|
|
for(i = 0; i < cur_system->nfleets; i++)
|
|
if(RNG(0,100) <= cur_system->fleets[i].chance) {// Check fleet.
|
|
// Simulate ships coming from hyperspace.
|
|
vect_pset(&v, 2*RNG(MIN_HYPERSPACE_DIST/2, MIN_HYPERSPACE_DIST), RNG(0, 360)*M_PI/180.);
|
|
|
|
for(j = 0; j < cur_system->fleets[i].fleet->npilots; j++)
|
|
if(RNG(0,100) <= cur_system->fleets[i].fleet->pilots[j].chance) {
|
|
// Other ships in the fleet should start split up.
|
|
vect_cadd(&v, RNG(50, 150) * (RNG(0,1) ? 1 : -1),
|
|
RNG(50, 150) * (RNG(0,1) ? 1 : -1));
|
|
pilot_create(cur_system->fleets[i].fleet->pilots[j].ship,
|
|
cur_system->fleets[i].fleet->pilots[j].name,
|
|
cur_system->fleets[i].fleet->faction,
|
|
cur_system->fleets[i].fleet->ai,
|
|
vect_angle(&v,&vn),
|
|
&v,
|
|
NULL,
|
|
0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Load the planets of name 'name'.
|
|
static Planet* planet_get(const char* name) {
|
|
Planet* tmp = NULL;
|
|
|
|
char str[PATH_MAX] = "\0";
|
|
char* tstr;
|
|
|
|
uint32_t flags = 0;
|
|
|
|
uint32_t bufsize;
|
|
char* buf = pack_readfile(DATA, PLANET_DATA, &bufsize);
|
|
|
|
xmlNodePtr node, cur;
|
|
xmlDocPtr doc = xmlParseMemory(buf, bufsize);
|
|
|
|
node = doc->xmlChildrenNode;
|
|
if(strcmp((char*)node->name, XML_PLANET_ID)) {
|
|
ERR("Malformed "PLANET_DATA" file: missing root element '"XML_PLANET_ID"'");
|
|
return NULL;
|
|
}
|
|
|
|
node = node->xmlChildrenNode; // First system node.
|
|
if(node == NULL) {
|
|
ERR("Malformed "PLANET_DATA" file: does not contain elements");
|
|
return NULL;
|
|
}
|
|
|
|
do {
|
|
if(xml_isNode(node, XML_PLANET_TAG)) {
|
|
tstr = xml_nodeProp(node, "name");
|
|
if(strcmp(tstr, name)==0) { // Found.
|
|
tmp = CALLOC_L(Planet);
|
|
tmp->name = tstr;
|
|
|
|
node = node->xmlChildrenNode;
|
|
|
|
do {
|
|
if(xml_isNode(node, "GFX")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "space")) {
|
|
// Load space gfx.
|
|
snprintf(str, strlen(xml_get(cur))+sizeof(PLANET_GFX_SPACE),
|
|
PLANET_GFX_SPACE"%s", xml_get(cur));
|
|
tmp->gfx_space = gl_newImage(str);
|
|
}
|
|
else if(xml_isNode(cur, "exterior")) {
|
|
// Load land gfx.
|
|
snprintf(str, strlen(xml_get(cur))+sizeof(PLANET_GFX_EXTERIOR),
|
|
PLANET_GFX_EXTERIOR"%s", xml_get(cur));
|
|
tmp->gfx_exterior = gl_newImage(str);
|
|
}
|
|
} while((cur = cur->next));
|
|
}
|
|
else if(xml_isNode(node, "pos")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "x")) {
|
|
flags |= FLAG_XSET;
|
|
tmp->pos.x = xml_getFloat(cur);
|
|
}
|
|
else if(xml_isNode(cur, "y")) {
|
|
flags |= FLAG_YSET;
|
|
tmp->pos.y = xml_getFloat(cur);
|
|
}
|
|
} while((cur = cur->next));
|
|
}
|
|
else if(xml_isNode(node, "general")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "class"))
|
|
tmp->class = planetclass_get(cur->children->content[0]);
|
|
else if(xml_isNode(cur, "faction"))
|
|
tmp->faction = faction_get(xml_get(cur));
|
|
else if(xml_isNode(cur, "description"))
|
|
tmp->description = strdup(xml_get(cur));
|
|
} while((cur = cur->next));
|
|
}
|
|
} while((node = node->next));
|
|
break;
|
|
} else
|
|
free(tstr); // xmlGetProp mallocs the string.
|
|
}
|
|
} while((node = node->next));
|
|
|
|
xmlFreeDoc(doc);
|
|
free(buf);
|
|
xmlCleanupParser();
|
|
|
|
// Check elements.
|
|
if(tmp) {
|
|
#define MELEMENT(o,s) if((o) == 0) WARN("Planet '%s' missing '"s"' element", tmp->name)
|
|
MELEMENT(tmp->gfx_space, "GFX_space");
|
|
MELEMENT(tmp->gfx_exterior, "GFX_exterior");
|
|
MELEMENT(flags&FLAG_XSET, "x");
|
|
MELEMENT(flags&FLAG_YSET, "y");
|
|
MELEMENT(tmp->class, "class");
|
|
MELEMENT(tmp->faction, "faction");
|
|
#undef MELEMENT
|
|
} else
|
|
WARN("No planet found matching name '%s'", name);
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// Parse node 'parent' which should be the node of a system.
|
|
// Return the StarSystem fully loaded.
|
|
static StarSystem* system_parse(const xmlNodePtr parent) {
|
|
Planet* planet = NULL;
|
|
SystemFleet* fleet = NULL;
|
|
StarSystem* tmp = CALLOC_L(StarSystem);
|
|
char* ptrc;
|
|
xmlNodePtr cur, node;
|
|
|
|
uint32_t flags;
|
|
|
|
tmp->name = xml_nodeProp(parent, "name"); // Already mallocs.
|
|
|
|
node = parent->xmlChildrenNode;
|
|
|
|
do {
|
|
// Load all the things!
|
|
if(xml_isNode(node, "pos")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "x")) {
|
|
flags |= FLAG_XSET;
|
|
tmp->pos.x = xml_getFloat(cur);
|
|
}
|
|
if(xml_isNode(cur, "y")) {
|
|
flags |= FLAG_YSET;
|
|
tmp->pos.y = xml_getFloat(cur);
|
|
}
|
|
} while((cur = cur->next));
|
|
}
|
|
else if(xml_isNode(node, "general")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "stars")) // Non-zero.
|
|
tmp->stars = xml_getInt(cur);
|
|
else if(xml_isNode(cur, "asteroids")) {
|
|
flags |= FLAG_ASTEROIDSSET;
|
|
tmp->asteroids = xml_getInt(cur);
|
|
}
|
|
else if(xml_isNode(cur, "interference")) {
|
|
flags |= FLAG_INTEFERENCESET;
|
|
tmp->interference = xml_getFloat(cur)/100;
|
|
}
|
|
}while((cur = cur->next));
|
|
}
|
|
// Load all the planets.
|
|
else if(xml_isNode(node, "planets")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "planet")) {
|
|
planet = planet_get(xml_get(cur));
|
|
planet = planet_get((const char*)cur->children->content);
|
|
tmp->planets = realloc(tmp->planets, sizeof(Planet)*(++tmp->nplanets));
|
|
memcpy(tmp->planets+(tmp->nplanets-1), planet, sizeof(Planet));
|
|
free(planet);
|
|
}
|
|
} while((cur = cur->next));
|
|
}
|
|
// Load all the fleets.
|
|
else if(xml_isNode(node, "fleets")) {
|
|
cur = node->children;
|
|
do {
|
|
if(xml_isNode(cur, "fleet")) {
|
|
fleet = CALLOC_L(SystemFleet);
|
|
fleet->fleet = fleet_get(xml_get(cur));
|
|
if(fleet->fleet == NULL)
|
|
WARN("Fleet %s for Star System %s not found", xml_get(cur), tmp->name);
|
|
|
|
ptrc = xml_nodeProp(cur, "chance"); // Malloc ptrc.
|
|
fleet->chance = atoi(ptrc);
|
|
if(fleet->chance == 0)
|
|
WARN("Fleet %s for Star System %s has 0%% chance to appear",
|
|
fleet->fleet->name, tmp->name);
|
|
if(ptrc) free(ptrc); // Free the ptrc.
|
|
|
|
tmp->fleets = realloc(tmp->fleets, sizeof(SystemFleet)*(++tmp->nfleets));
|
|
memcpy(tmp->fleets+(tmp->nfleets-1), fleet, sizeof(SystemFleet));
|
|
free(fleet);
|
|
}
|
|
} while((cur = cur->next));
|
|
}
|
|
} while((node = node->next));
|
|
// Check elements.
|
|
#define MELEMENT(o,s) if((o) == 0) WARN("Star System '%s' missing '"s"' element", tmp->name)
|
|
MELEMENT(flags&FLAG_XSET, "x");
|
|
MELEMENT(flags&FLAG_YSET, "y");
|
|
MELEMENT(tmp->stars, "stars");
|
|
MELEMENT(flags&FLAG_ASTEROIDSSET, "asteroids"); // Can be 0.
|
|
MELEMENT(flags&FLAG_INTEFERENCESET, "inteference");
|
|
#undef MELEMENT
|
|
DEBUG("Loaded Star System '%s' with %d Planet%c", tmp->name, tmp->nplanets, (tmp->nplanets == 1) ? ' ' : 's');
|
|
|
|
return tmp;
|
|
}
|
|
|
|
// Load the ENTIRE universe into RAM. -- WOAH! -- Wasn't that bad. :P
|
|
int space_load(void) {
|
|
uint32_t bufsize;
|
|
char* buf = pack_readfile(DATA, SYSTEM_DATA, &bufsize);
|
|
|
|
StarSystem* tmp;
|
|
|
|
xmlNodePtr node;
|
|
xmlDocPtr doc = xmlParseMemory(buf, bufsize);
|
|
|
|
node = doc->xmlChildrenNode;
|
|
if(!xml_isNode(node, XML_SYSTEM_ID)) {
|
|
ERR("Malformed "SYSTEM_DATA" file: missing root element '"XML_SYSTEM_ID"'");
|
|
return -1;
|
|
}
|
|
node = node->xmlChildrenNode; // First system node.
|
|
if(node == NULL) {
|
|
ERR("Malformed "SYSTEM_DATA" file: does not contain elements");
|
|
return -1;
|
|
}
|
|
do {
|
|
if(xml_isNode(node, XML_SYSTEM_TAG)) {
|
|
tmp = system_parse(node);
|
|
systems = realloc(systems, sizeof(StarSystem)*(++nsystems));
|
|
memcpy(systems+nsystems-1, tmp, sizeof(StarSystem));
|
|
free(tmp);
|
|
}
|
|
} while((node = node->next));
|
|
|
|
xmlFreeDoc(doc);
|
|
free(buf);
|
|
xmlCleanupParser();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Render the system. -- Just playing god now.
|
|
void space_render(double dt) {
|
|
int i;
|
|
glBegin(GL_POINTS);
|
|
for(i = 0; i < nstars; i++) {
|
|
if(!paused) {
|
|
// Update the position.
|
|
stars[i].x -= VX(player->solid->vel)/(15.-10.*stars[i].brightness)*dt;
|
|
stars[i].y -= VY(player->solid->vel)/(15.-10.*stars[i].brightness)*dt;
|
|
// Scroll those stars bitch!
|
|
if(stars[i].x > gl_screen.w + STAR_BUF) stars[i].x = -STAR_BUF;
|
|
else if(stars[i].x < -STAR_BUF) stars[i].x = gl_screen.w + STAR_BUF;
|
|
if(stars[i].y > gl_screen.h + STAR_BUF) stars[i].y = -STAR_BUF;
|
|
else if(stars[i].y < -STAR_BUF) stars[i].y = gl_screen.h + STAR_BUF;
|
|
}
|
|
// Render.
|
|
glColor4d(1., 1., 1., stars[i].brightness);
|
|
glVertex2d(stars[i].x - (double)gl_screen.w/2.,
|
|
stars[i].y - (double)gl_screen.h/2.);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
// Render the planets.
|
|
void planets_render(void) {
|
|
int i;
|
|
for(i = 0; i < cur_system->nplanets; i++)
|
|
gl_blitSprite(cur_system->planets[i].gfx_space,
|
|
cur_system->planets[i].pos.x, cur_system->planets[i].pos.y, 0, 0, NULL);
|
|
}
|
|
|
|
// Clean up the system.
|
|
void space_exit(void) {
|
|
int i,j;
|
|
for(i = 0; i < nsystems; i++) {
|
|
free(systems[i].name);
|
|
if(systems[i].fleets)
|
|
free(systems[i].fleets);
|
|
for(j = 0; j < systems[i].nplanets; j++) {
|
|
free(systems[i].planets[j].name);
|
|
if(systems[i].planets[j].description)
|
|
free(systems[i].planets[j].description);
|
|
if(systems[i].planets[j].gfx_space)
|
|
gl_freeTexture(systems[i].planets[j].gfx_space);
|
|
if(systems[i].planets[j].gfx_exterior)
|
|
gl_freeTexture(systems[i].planets[j].gfx_exterior);
|
|
}
|
|
free(systems[i].planets);
|
|
}
|
|
free(systems);
|
|
if(stars) free(stars);
|
|
}
|
|
|