From 8b1b6e2af0dc0ecf58ed9eecaf2f540c816daede Mon Sep 17 00:00:00 2001 From: Allanis Date: Wed, 11 Dec 2013 22:19:06 +0000 Subject: [PATCH] [Add] Implemented fleet addition and removal! --- src/space.c | 69 ++++++++++++++++++++++++++++++++++++++++++--------- src/space.h | 4 +++ src/unidiff.c | 31 ++++++++++++++++++----- 3 files changed, 86 insertions(+), 18 deletions(-) diff --git a/src/space.c b/src/space.c index 4deb7e4..658638d 100644 --- a/src/space.c +++ b/src/space.c @@ -819,11 +819,57 @@ int system_rmPlanet(StarSystem* sys, char* planetname) { return 0; } +/** + * @fn int system_addFleet(StarSystem* sys, SystemFleet* fleet) + * + * @brief Add a fleet to a star system. + * @param sys Star system to add fleet to. + * @param fleet Fleet to add. + * @return 0 on success. + */ +int system_addFleet(StarSystem* sys, SystemFleet* fleet) { + if(sys == NULL) + return -1; + + sys->fleets = realloc(sys->fleets, sizeof(SystemFleet) * (++sys->nfleets)); + memcpy(sys->fleets+(sys->nfleets-1), fleet, sizeof(SystemFleet)); + + return 0; +} + +/** + * @fn int system_rmFleet(StarSystem* sys, SystemFleet* fleet) + * + * @brief Remove a fleet from a star system. + * @param sys Star System to remove fleet from. + * @param fleet Fleet to remove. + * @return 0 on success. + */ +int system_rmFleet(StarSystem* sys, SystemFleet* fleet) { + int i; + + /* Find a matching fleet (will grab first since can be duplicates). */ + for(i = 0; i < sys->nfleets; i++) + if((fleet->fleet == sys->fleets[i].fleet) && + (fleet->chance == sys->fleets[i].chance)) + break; + + /* Not found. */ + if(i >= sys->nfleets) + return -1; + + sys->nfleets--; + memmove(&sys->fleets[i], &sys->fleets[i+1], sizeof(SystemFleet) * (sys->nfleets - i)); + sys->fleets = realloc(sys->fleets, sizeof(SystemFleet) * sys->nfleets); + + return 0; +} + /* Parse node 'parent' which should be the node of a system. */ /* Return the StarSystem fully loaded. */ static StarSystem* system_parse(StarSystem* sys, const xmlNodePtr parent) { Planet* planet; - SystemFleet* fleet; + SystemFleet fleet; char* ptrc; xmlNodePtr cur, node; @@ -833,7 +879,6 @@ static StarSystem* system_parse(StarSystem* sys, const xmlNodePtr parent) { /* Clear memory for sane defaults. */ memset(sys, 0, sizeof(StarSystem)); planet = NULL; - fleet = NULL; size = 0; sys->name = xml_nodeProp(parent, "name"); /* Already mallocs. */ @@ -891,21 +936,21 @@ static StarSystem* system_parse(StarSystem* sys, const xmlNodePtr parent) { 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) + memset(&fleet, 0, sizeof(SystemFleet)); + + fleet.fleet = fleet_get(xml_get(cur)); + if(fleet.fleet == NULL) WARN("Fleet %s for Star System %s not found", xml_get(cur), sys->name); - ptrc = xml_nodeProp(cur, "chance"); /* Malloc ptrc. */ - fleet->chance = atoi(ptrc); - if(fleet->chance == 0) + xmlr_attr(cur, "chance", ptrc); /* mallocs ptrc. */ + if(ptrc == NULL) fleet.chance = 0; /* Gives warning. */ + else fleet.chance = atoi(ptrc); + if(fleet.chance == 0) WARN("Fleet %s for Star System %s has 0%% chance to appear", - fleet->fleet->name, sys->name); + fleet.fleet->name, sys->name); if(ptrc) free(ptrc); /* Free the ptrc. */ - sys->fleets = realloc(sys->fleets, sizeof(SystemFleet)*(++sys->nfleets)); - memcpy(sys->fleets+(sys->nfleets-1), fleet, sizeof(SystemFleet)); - free(fleet); + system_addFleet(sys, &fleet); } } while(xml_nextNode(cur)); } diff --git a/src/space.h b/src/space.h index 598f203..2a9f54d 100644 --- a/src/space.h +++ b/src/space.h @@ -142,8 +142,12 @@ void space_exit(void); char* planet_getSystem(char* planetname); Planet* planet_get(char* planetname); char planet_getClass(Planet* p); + +/* System adding/removing stuff. */ int system_addPlanet(StarSystem* sys, char* planetname); int system_rmPlanet(StarSystem* sys, char* planetname); +int system_addFleet(StarSystem* sys, SystemFleet* fleet); +int system_rmFleet(StarSystem* sys, SystemFleet* fleet); /* Render. */ void space_render(const double dt); diff --git a/src/unidiff.c b/src/unidiff.c index 34469bf..492364d 100644 --- a/src/unidiff.c +++ b/src/unidiff.c @@ -68,6 +68,7 @@ typedef struct UniHunk_ { UniHunkType_t type; /**< Type of hunk it is. */ union { char* name; + SystemFleet fleet; } u; /* Actual data to patch. */ } UniHunk_t; @@ -241,8 +242,13 @@ static int diff_patch(xmlNodePtr parent) { hunk.target.type = base.target.type; hunk.target.u.name = strdup(base.target.u.name); - /* Get the planet to modify. */ - xmlr_attr(cur, "name", hunk.u.name); + /* Get the fleet properties. */ + xmlr_attr(cur, "name", buf); + hunk.u.fleet.fleet = fleet_get(buf); + free(buf); + xmlr_attr(cur, "chance", buf); + hunk.u.fleet.chance = atoi(buf); + free(buf); /* Get the type. */ buf = xml_get(cur); @@ -285,10 +291,14 @@ static int diff_patchHunk(UniHunk_t* hunk) { case HUNK_TYPE_PLANET_REMOVE: return system_rmPlanet(system_get(hunk->target.u.name), hunk->u.name); + /* Adding a fleet. */ case HUNK_TYPE_FLEET_ADD: - break; + return system_addFleet(system_get(hunk->target.u.name), &hunk->u.fleet); + + /* Removing a fleet. */ case HUNK_TYPE_FLEET_REMOVE: - break; + return system_rmFleet(system_get(hunk->target.u.name), &hunk->u.fleet); + default: WARN("Unkown hunk type '%d'.", hunk->type); break; @@ -463,8 +473,17 @@ static void diff_cleanup(UniDiff_t* diff) { static void diff_cleanupHunk(UniHunk_t* hunk) { if(hunk->target.u.name != NULL) free(hunk->target.u.name); - if(hunk->u.name != NULL) - free(hunk->u.name); + + switch(hunk->type) { + case HUNK_TYPE_PLANET_ADD: + case HUNK_TYPE_PLANET_REMOVE: + if(hunk->u.name != NULL) + free(hunk->u.name); + break; + default: + break; + } + memset(hunk, 0, sizeof(UniHunk_t)); }