[Add] Implemented fleet addition and removal!

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);
+          memset(&fleet, 0, sizeof(SystemFleet));
-          fleet->fleet = fleet_get(xml_get(cur));
+
-          if(fleet->fleet == NULL)
+          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. */
+          xmlr_attr(cur, "chance", ptrc); /* mallocs ptrc. */
-          fleet->chance = atoi(ptrc);
+          if(ptrc == NULL) fleet.chance = 0; /* Gives warning. */
-          if(fleet->chance == 0)
+          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));
+          system_addFleet(sys, &fleet);
-          memcpy(sys->fleets+(sys->nfleets-1), fleet, sizeof(SystemFleet));
-          free(fleet);
         }
       } while(xml_nextNode(cur));
     }

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);

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. */
+          /* Get the fleet properties. */
-          xmlr_attr(cur, "name", hunk.u.name);
+          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);
+  
+  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));
 }