#include #include #include #include "xml.h" #include "lephisto.h" #include "opengl.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 "weapon.h" #include "toolkit.h" #include "spfx.h" #include "ltime.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) #define FLAG_SERVICESET (1<<4) #define FLAG_TECHSET (1<<5) #define FLAG_FACTIONSET (1<<6) /* Planet <-> system name stack. */ static char** planetname_stack = NULL; static char** systemname_stack = NULL; static int spacename_nstack = 0; /* Star system stack and co. */ StarSystem* systems_stack = NULL; /* Star system stack. */ int systems_nstack = 0; /* Number of star systems. */ static int nplanets = 0; /* Total number of loaded planets - A little silly. */ StarSystem* cur_system = NULL; /* Current star system. */ /* Fleet spawn rate. */ unsigned int spawn_timer = 0; /* Controls spawn rate. */ /* Star stack and co. */ #define STAR_BUF 100 /* Area to leave around screen, more = less repitition. */ typedef struct Star_ { 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. */ static int mstars = 0; /* Memory stars are taking. */ /* Intern. */ static StarSystem* system_get(const char* sysname); static Planet* planet_pull(const char* name); static void space_addFleet(Fleet* fleet); static StarSystem* system_parse(const xmlNodePtr parent); static void system_parseJumps(const xmlNodePtr parent); static PlanetClass planetclass_get(const char a); /* Extern. */ extern void player_message(const char* fmt, ...); void planets_minimap(const double res, const double w, const double h, const RadarShape shape); /* 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)nplanets; i++) { if(areEnemies(player->faction, cur_system->planets[i].faction)) COLOUR(cHostile); else if(areAllies(player->faction, cur_system->planets[i].faction)) COLOUR(cFriend); else COLOUR(cNeutral); 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); } } } glEnd(); } #undef PIXEL /* A* Algorithm fo shortest path finding. */ /* The node struct. */ typedef struct SysNode_ { struct SysNode_* next, *gnext; struct SysNode_* parent; StarSystem* sys; double r; /* Ranking. */ int g; /* Step. */ } SysNode; static SysNode* A_gc; /* Prototypes. */ static SysNode* A_newNode(StarSystem* sys, SysNode* parent); static double A_h(StarSystem* n, StarSystem* g); static double A_g(SysNode* n); static SysNode* A_add(SysNode* first, SysNode* cur); static SysNode* A_rm(SysNode* first, StarSystem* cur); static SysNode* A_in(SysNode* first, StarSystem* cur); static SysNode* A_lowest(SysNode* first); static void A_freeList(SysNode* first); /* Creates a new node link to star system. */ static SysNode* A_newNode(StarSystem* sys, SysNode* parent) { SysNode* n; n = malloc(sizeof(SysNode)); n->next = NULL; n->parent = parent; n->sys = sys; n->r = DBL_MAX; n->g = 0.; n->gnext = A_gc; A_gc = n; return n; } static double A_h(StarSystem* n, StarSystem* g) { (void)n; (void)g; /* Euclidean distance. */ /*return sqrt(pow2(n->pos.x - g->pos.x) + pow2(n->pos.y - g->pos.y))/100.; */ return 0.; } /* Get the g from a node. */ static double A_g(SysNode* n) { return n->g; } /* Add a node to the linkes list. */ static SysNode* A_add(SysNode* first, SysNode* cur) { SysNode* n; if(first == NULL) return cur; n = first; while(n->next != NULL) n = n->next; n->next = cur; return first; } /* Remove a node from a linked list. */ static SysNode* A_rm(SysNode* first, StarSystem* cur) { SysNode* n, *p; if(first->sys == cur) { n = first->next; first->next = NULL; return n; } p = first; n = p->next; do { if(n->sys == cur) { n->next = NULL; p->next = n->next; break; } } while((n=n->next) != NULL); return first; } /* Check if node is in linked list. */ static SysNode* A_in(SysNode* first, StarSystem* cur) { SysNode* n; if(first == NULL) return NULL; n = first; do { if(n->sys == cur) return n; } while((n=n->next) != NULL); return NULL; } /* Return the lowest ranking node from a linked list of nodes. */ static SysNode* A_lowest(SysNode* first) { SysNode* lowest, *n; if(first == NULL) return NULL; n = first; lowest = n; do { if(n->r < lowest->r) lowest = n; } while((n=n->next) != NULL); return lowest; } /* Free a linked list. */ static void A_freeList(SysNode* first) { SysNode* p, *n; if(first == NULL) return; p = NULL; n = first; do { if(p != NULL) free(p); p = n; } while((n=n->gnext) != NULL); free(p); } StarSystem** system_getJumpPath(int* njumps, char* sysstart, char* sysend) { int i, cost; StarSystem* sys, *ssys, *esys, **res; SysNode* cur, *neighbour; SysNode* open, *closed; SysNode* ocost, *ccost; A_gc = NULL; /* Initial and target systems. */ ssys = system_get(sysstart); /* Start. */ esys = system_get(sysend); /* End. */ /* Start the linked lists. */ open = closed = NULL; cur = A_newNode(ssys, NULL); open = A_add(open, cur); /* Initial open node is the start system. */ while((cur = A_lowest(open))->sys != esys) { /* Get best from open and toss to closed. */ open = A_rm(open, cur->sys); closed = A_add(closed, cur); cost = A_g(cur) + 1; for(i = 0; i < cur->sys->njumps; i++) { sys = &systems_stack[cur->sys->jumps[i]]; neighbour = A_newNode(sys, NULL); ocost = A_in(open, sys); if((ocost != NULL) && (cost < ocost->g)) { open = A_rm(open, sys); /* New path is better. */ } ccost = A_in(closed, sys); if(ccost != NULL) { closed = A_rm(closed, sys); /* Shouldn't happen. */ } if((ocost == NULL) && (ccost == NULL)) { neighbour->g = cost; neighbour->r = A_g(neighbour) + A_h(cur->sys, sys); neighbour->parent = cur; open = A_add(open, neighbour); } } } /* Build the path backwards. */ (*njumps) = A_g(cur); res = malloc(sizeof(StarSystem*) * (*njumps)); for(i = 0; i < (*njumps); i++) { res[(*njumps)-i-1] = cur->sys; cur = cur->parent; } /* Free the linked list. */ A_freeList(A_gc); return res; } static PlanetClass planetclass_get(const char a) { switch(a) { /* Planets use letters. */ 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; /* Stations use numbers as there isn't as many. */ case '0' : return STATION_CLASS_A; case '1' : return STATION_CLASS_B; case '2' : return STATION_CLASS_C; case '3' : return STATION_CLASS_D; default: return PLANET_CLASS_NULL; }; } /* Check distance to ensure we can go into hyperspace. */ int space_canHyperspace(Pilot* p) { int i; double d; if(p->fuel < HYPERSPACE_FUEL) return 0; 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 0; } return 1; } /* Hyperspace, returns 0 if entering hyperspace, or the distance if not. */ int space_hyperspace(Pilot* p) { if(p->fuel < HYPERSPACE_FUEL) return -3; if(!space_canHyperspace(p)) return -1; /* Pilot is now going to get automatically ready for hyperspace. */ pilot_setFlag(p, PILOT_HYP_PREP); return 0; } /* Return the name of all the planets that belong to factions. */ char** space_getFactionPlanet(int* nplanets, int* factions, int nfactions) { int i, j, k; Planet* planet; char** tmp; int ntmp; int mtmp; ntmp = 0; mtmp = 25; tmp = malloc(sizeof(char*) * mtmp); for(i = 0; i < systems_nstack; i++) for(j = 0; j < systems_stack[i].nplanets; j++) { planet = &systems_stack[i].planets[j]; for(k = 0; k < nfactions; k++) if((faction_isFaction(factions[k]) && (planet->faction == factions[k])) || (faction_isAlliance(factions[k]) && faction_ofAlliance(planet->faction, factions[k]))) { ntmp++; if(ntmp > mtmp) { mtmp += 25; tmp = realloc(tmp, sizeof(char*) * mtmp); } tmp[ntmp-1] = planet->name; break; /* No need to check all factions. */ } } (*nplanets) = ntmp; return tmp; } /* Return the name of a random planet. */ char* space_getRndPlanet(void) { int i, j; char** tmp; int ntmp; int mtmp; char* res; ntmp = 0; mtmp = 25; tmp = malloc(sizeof(char)*mtmp); for(i = 0; i < systems_nstack; i++) for(j = 0; j < systems_stack[i].nplanets; j++) { ntmp++; if(ntmp > mtmp) { mtmp += 25; tmp = realloc(tmp, sizeof(char*) * mtmp); } tmp[ntmp-1] = systems_stack[i].planets[j].name; } res = tmp[RNG(0, ntmp-1)]; free(tmp); return res; } /* Get the system from it's name. */ static StarSystem* system_get(const char* sysname) { int i; for(i = 0; i < systems_nstack; i++) if(strcmp(sysname, systems_stack[i].name)==0) return &systems_stack[i]; DEBUG("System '%s' not found in stack", sysname); return NULL; } /* Get the name of a system from a planetname. */ char* planet_getSystem(char* planetname) { int i; for(i = 0; i < spacename_nstack; i++) if(strcmp(planetname_stack[i], planetname)==0) return systemname_stack[i]; DEBUG("Planet '%s' not found in planetname stack", planetname); return NULL; } /* Get a planet based on it's name. */ Planet* planet_get(char* planetname) { int i; char* sys; StarSystem* system; sys = planet_getSystem(planetname); system = system_get(sys); for(i = 0; i < system->nplanets; i++) if(strcmp(planetname, system->planets[i].name)==0) return &system->planets[i]; DEBUG("Planet '%s' not found in the universe", planetname); return NULL; } /* Basically used for spawning fleets. */ void space_update(const double dt) { unsigned int t; int i, j, f; (void)dt; /* Don't need it right now. */ if(cur_system == NULL) return; /* Can't update a null system. */ t = SDL_GetTicks(); if(cur_system->nfleets == 0) /* Please stop checking that there are no fleets. */ spawn_timer = t + 300000; if(spawn_timer < t) { /* Time to possibly spawn. */ /* Spawn chance is based on overall percentage. */ f = RNG(0, 100*cur_system->nfleets); j = 0; for(i = 0; i < cur_system->nfleets; i++) { j += cur_system->fleets[i].chance; if(f < j) { /* Add one fleet. */ space_addFleet(cur_system->fleets[i].fleet); break; } } spawn_timer = t + 60000./(float)cur_system->nfleets; } } /* Crate a fleet. */ static void space_addFleet(Fleet* fleet) { int i; double a; Vec2 vv, vp, vn; /* Simulate them coming from hyperspace. */ vect_pset(&vp, RNG(MIN_HYPERSPACE_DIST, MIN_HYPERSPACE_DIST*3), RNG(0, 360)*M_PI/180.); vectnull(&vn); for(i = 0; i < fleet->npilots; i++) if(RNG(0, 100) <= fleet->pilots[i].chance) { vect_cadd(&vp, RNG(75, 150) * (RNG(0,1) ? 1 : -1), RNG(75, 150) * (RNG(0,1) ? 1 : -1)); a = vect_angle(&vp, &vn); vect_pset(&vv, fleet->pilots[i].ship->speed * 2., a); pilot_create(fleet->pilots[i].ship, fleet->pilots[i].name, fleet->faction, fleet->ai, a, &vp, &vv, 0); } } /* Init the system. */ void space_init(const char* sysname) { char* lt; int i; /* Cleanup some stuff. */ player_clear(); /* Clears targets. */ pilots_clean(); /* Destroy all the current pilots, exept player. */ weapon_clear(); /* Get rid of all the weapons. */ spfx_clear(); /* Remove of explosions. */ if((sysname == NULL) && (cur_system == NULL)) ERR("Cannot reinit system if there is no system previously loaded"); else if(sysname != NULL) { for(i = 0; i < systems_nstack; i++) if(strcmp(sysname, systems_stack[i].name)==0) break; if(i == systems_nstack) ERR("System %s not found in stack", sysname); cur_system = systems_stack+i; lt = ltime_pretty(0); player_message("Entering System %s on %s", sysname, lt); free(lt); /* Set up stars. */ nstars = (cur_system->stars*SCREEN_W*SCREEN_H+STAR_BUF*STAR_BUF)/(800*640); if(mstars < nstars) stars = realloc(stars, sizeof(Star)*nstars); /* should realloc not malloc. */ for(i = 0; i < nstars; i++) { stars[i].brightness = (double)RNG(50, 200)/256.; stars[i].x = (double)RNG(-STAR_BUF, SCREEN_W + STAR_BUF); stars[i].y = (double)RNG(-STAR_BUF, SCREEN_H + STAR_BUF); } } /* Set up fleets -> pilots. */ for(i = 0; i < cur_system->nfleets; i++) if(RNG(0,100) <= (cur_system->fleets[i].chance/2)) /* Fleet check (50% chance). */ space_addFleet(cur_system->fleets[i].fleet); /* Start the spawn timer. */ spawn_timer = SDL_GetTicks() + 120000./(float)(cur_system->nfleets+1); } /* Load the planets of name 'name'. */ static Planet* planet_pull(const char* name) { int i; 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, ccur; 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(xml_nextNode(cur)); } 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(xml_nextNode(cur)); } 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")) { flags |= FLAG_FACTIONSET; tmp->faction = faction_get(xml_get(cur)); } else if(xml_isNode(cur, "description")) tmp->description = strdup(xml_get(cur)); else if(xml_isNode(cur, "bar")) tmp->bar_description = strdup(xml_get(cur)); else if(xml_isNode(cur, "services")) { flags |= FLAG_SERVICESET; tmp->services = xml_getInt(cur); } else if(xml_isNode(cur, "tech")) { ccur = cur->children; do { if(xml_isNode(ccur, "main")) { flags |= FLAG_TECHSET; tmp->tech[0] = xml_getInt(ccur); } else if(xml_isNode(ccur, "special")) { for(i = 1; i < PLANET_TECH_MAX; i++) if(tmp->tech[i]==0) { tmp->tech[i] = xml_getInt(ccur); break; } if(i == PLANET_TECH_MAX) WARN("Planet '%s' has too many" "'special tech' entries", tmp->name); } } while(xml_nextNode(ccur)); } else if(xml_isNode(cur, "commodities")) { ccur = cur->children; do { if(xml_isNode(ccur, "commodity")) { tmp->commodities = realloc(tmp->commodities, (tmp->ncommodities+1) * sizeof(Commodity*)); tmp->commodities[tmp->ncommodities] = commodity_get(xml_get(ccur)); tmp->ncommodities++; } } while(xml_nextNode(ccur)); } } while(xml_nextNode(cur)); } } while(xml_nextNode(node)); break; } else free(tstr); /* xmlGetProp mallocs the string. */ } } while(xml_nextNode(node)); xmlFreeDoc(doc); free(buf); xmlCleanupParser(); /* Check elements. */ if(tmp) { #define MELEMENT(o,s) if(o) WARN("Planet '%s' missing '"s"' element", tmp->name) MELEMENT(tmp->gfx_space==NULL, "GFX_space"); MELEMENT(planet_hasService(tmp, PLANET_SERVICE_LAND) && tmp->gfx_exterior==NULL, "GFX exterior"); MELEMENT((flags&FLAG_XSET)==0, "x"); MELEMENT((flags&FLAG_YSET)==0, "y"); MELEMENT(tmp->class==PLANET_CLASS_NULL, "class"); MELEMENT(planet_hasService(tmp, PLANET_SERVICE_LAND) && tmp->description==NULL, "description"); MELEMENT(planet_hasService(tmp, PLANET_SERVICE_BASIC) && tmp->bar_description==NULL, "bar"); MELEMENT(planet_hasService(tmp, PLANET_SERVICE_BASIC) && (flags & FLAG_FACTIONSET)==0, "faction"); MELEMENT((flags&FLAG_SERVICESET)==0, "services"); MELEMENT((planet_hasService(tmp, PLANET_SERVICE_OUTFITS) || planet_hasService(tmp, PLANET_SERVICE_SHIPYARD)) && (flags&FLAG_TECHSET)==0, "tech"); MELEMENT(planet_hasService(tmp, PLANET_SERVICE_COMMODITY) && (tmp->ncommodities==0), "commodity"); #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(xml_nextNode(cur)); } 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(xml_nextNode(cur)); } /* Load all the planets. */ else if(xml_isNode(node, "planets")) { cur = node->children; do { if(cur && xml_isNode(cur, "planet")) { /* Add planet to system. */ nplanets++; /* Increase planet counter. */ planet = planet_pull(xml_get(cur)); tmp->planets = realloc(tmp->planets, sizeof(Planet)*(++tmp->nplanets)); memcpy(tmp->planets+(tmp->nplanets-1), planet, sizeof(Planet)); /* Add planet <-> star system to name stack. */ spacename_nstack++; planetname_stack = realloc(planetname_stack, sizeof(char*)*spacename_nstack); systemname_stack = realloc(systemname_stack, sizeof(char*)*spacename_nstack); planetname_stack[spacename_nstack-1] = planet->name; systemname_stack[spacename_nstack-1] = tmp->name; free(planet); } } while(xml_nextNode(cur)); } /* Load all the fleets. */ else if(xml_isNode(node, "fleets")) { cur = node->children; do { if(cur && 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(xml_nextNode(cur)); } } while(xml_nextNode(node)); /* 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 /* Post processing. */ if(tmp->nplanets > 0) /* TODO: Make dependant on overall planet faction. */ tmp->faction = tmp->planets[0].faction; return tmp; } /* Load the jumps into a system. */ static void system_parseJumps(const xmlNodePtr parent) { int i; StarSystem* system; char* name; xmlNodePtr cur, node; name = xml_nodeProp(parent, "name"); /* Already mallocs. */ for(i = 0; i < systems_nstack; i++) if(strcmp(systems_stack[i].name, name)==0) { system = &systems_stack[i]; break; } if(i == systems_nstack) WARN("System '%s' was not found in the stack for some reason", name); free(name); /* No need for it now. */ node = parent->xmlChildrenNode; do { /* Load the data. */ if(xml_isNode(node, "jumps")) { cur = node->children; do { if(xml_isNode(cur, "jump")) { for(i = 0; i < systems_nstack; i++) if(strcmp(systems_stack[i].name, xml_get(cur))==0) { system->njumps++; system->jumps = realloc(system->jumps, system->njumps*sizeof(int)); system->jumps[system->njumps-1] = i; break; } if(i == systems_nstack) WARN("System '%s' not found for jump linking", xml_get(cur)); } } while(xml_nextNode(cur)); } } while(xml_nextNode(node)); } /* Load the ENTIRE universe into RAM. -- WOAH! */ /* -- Used a two system pass to first load the star systems_stack and then set jump routes. */ 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; } /* Fist pass - Load all the star systems_stack. */ do { if(xml_isNode(node, XML_SYSTEM_TAG)) { tmp = system_parse(node); systems_stack = realloc(systems_stack, sizeof(StarSystem)*(++systems_nstack)); memcpy(systems_stack+systems_nstack-1, tmp, sizeof(StarSystem)); free(tmp); } } while(xml_nextNode(node)); /* Second pass - Load all the jump routes. */ node = doc->xmlChildrenNode->xmlChildrenNode; do { if(xml_isNode(node, XML_SYSTEM_TAG)) system_parseJumps(node); /* Automatically load the jumps into the system. */ } while(xml_nextNode(node)); /* Cleanup. */ xmlFreeDoc(doc); free(buf); xmlCleanupParser(); DEBUG("Loaded %d star system%s with %d planet%s", systems_nstack, (systems_nstack==1) ? "" : "s", nplanets, (nplanets==1) ? "" : "s"); return 0; } /* Render the system. -- Just playing god now. */ void space_render(double dt) { int i; unsigned int t, timer; double x, y, m, b; glMatrixMode(GL_MODELVIEW); glPushMatrix(); /* Translation matrix. */ glTranslated(-(double)SCREEN_W/2., -(double)SCREEN_H/2., 0); t = SDL_GetTicks(); if(!player_isFlag(PLAYER_DESTROYED) && !player_isFlag(PLAYER_CREATING) && pilot_isFlag(player, PILOT_HYPERSPACE) && /* Hyperspace fancy effect. */ !paused && (player->ptimer-HYPERSPACE_STARS_BLUR < t)) { timer = player->ptimer - HYPERSPACE_STARS_BLUR; /* Fancy hyperspace effects. */ glShadeModel(GL_SMOOTH); glBegin(GL_LINES); /* Lines will be based on velocity. */ m = HYPERSPACE_STARS_LENGTH * (double)(t-timer) / (HYPERSPACE_STARS_BLUR); x = m*cos(VANGLE(player->solid->vel)+M_PI); y = m*sin(VANGLE(player->solid->vel)+M_PI); for(i = 0; i < nstars; i++) { glColor4d(1., 1., 1., stars[i].brightness); glVertex2d(stars[i].x, stars[i].y); glColor4d(1., 1., 1., 0.); glVertex2d(stars[i].x+x*stars[i].brightness,stars[i].y+y*stars[i].brightness); } glEnd(); glShadeModel(GL_FLAT); } else { glBegin(GL_POINTS); /* Normal rendering. */ if(!paused && !player_isFlag(PLAYER_DESTROYED) && !player_isFlag(PLAYER_CREATING)) { /* Update position. */ for(i = 0; i < nstars; i++) { b = 13.-10.*stars[i].brightness; stars[i].x -= player->solid->vel.x/b*dt; stars[i].y -= player->solid->vel.y/b*dt; /* Check for boundaries. */ if(stars[i].x > SCREEN_W + STAR_BUF) stars[i].x = -STAR_BUF; else if(stars[i].x < -STAR_BUF) stars[i].x = SCREEN_W + STAR_BUF; if(stars[i].y > SCREEN_H + STAR_BUF) stars[i].y = -STAR_BUF; else if(stars[i].y < -STAR_BUF) stars[i].y = SCREEN_H + STAR_BUF; /* Render. */ if((stars[i].x < SCREEN_W) && (stars[i].x > 0) && (stars[i].y < SCREEN_H) && (stars[i].y > 0)) { glColor4d(1., 1., 1., stars[i].brightness); glVertex2d(stars[i].x, stars[i].y); } } } else { /* Just render. */ for(i = 0; i < nstars; i++) { if((stars[i].x < SCREEN_W) && (stars[i].x > 0) && (stars[i].y < SCREEN_H) && (stars[i].y > 0)) { glColor4d(1., 1., 1., stars[i].brightness); glVertex2d(stars[i].x, stars[i].y); } } } glEnd(); /* GL_POINTS */ } glPopMatrix(); /* Translation matrix. */ } /* Render the planets. */ void planets_render(void) { if(cur_system == NULL) return; 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; /* Free the names. */ /*if(planetname_stack) free(planetname_stack); */ /*if(systemname_stack) free(systemname_stack); */ if(planetname_stack) { free(planetname_stack); planetname_stack = NULL; } if(systemname_stack) { free(systemname_stack); systemname_stack = NULL; } spacename_nstack = 0; /* Free the systems. */ for(i = 0; i < systems_nstack; i++) { free(systems_stack[i].name); if(systems_stack[i].fleets) free(systems_stack[i].fleets); if(systems_stack[i].jumps) free(systems_stack[i].jumps); /* Free some planets. */ for(j = 0; j < systems_stack[i].nplanets; j++) { free(systems_stack[i].planets[j].name); if(systems_stack[i].planets[j].description) free(systems_stack[i].planets[j].description); if(systems_stack[i].planets[j].bar_description) free(systems_stack[i].planets[j].bar_description); /* Graphics. */ if(systems_stack[i].planets[j].gfx_space) gl_freeTexture(systems_stack[i].planets[j].gfx_space); if(systems_stack[i].planets[j].gfx_exterior) gl_freeTexture(systems_stack[i].planets[j].gfx_exterior); /* Commodities. */ free(systems_stack[i].planets[j].commodities); } free(systems_stack[i].planets); } free(systems_stack); systems_stack = NULL; systems_nstack = 0; /* Stars must be set free too. */ if(stars) free(stars); stars = NULL; nstars = 0; }