Used the "indent" C formatting program from GNU to do some clean ups

The command options used was:
-nbad -bap -sc -bl -blf -bli0 -cli4 -cbi0
-di5 -nbc -bls -ip2 -nut -ts4 -bap -i4 -sob -npsl

1 files changed, 88 insertions, 95 deletions

diff --git a/src/map/skill-pools.c b/src/map/skill-pools.c
index 177a6a2..d533ae3 100644
--- a/src/map/skill-pools.c
+++ b/src/map/skill-pools.c
@@ -24,142 +24,135 @@
 #include "memwatch.h"
 #endif
 
-int skill_pool_skills[MAX_POOL_SKILLS];
-int skill_pool_skills_size = 0;
+int  skill_pool_skills[MAX_POOL_SKILLS];
+int  skill_pool_skills_size = 0;
 
-extern void
-skill_pool_register(int id)
+extern void skill_pool_register (int id)
 {
-        if (skill_pool_skills_size + 1 >= MAX_POOL_SKILLS) {
-                fprintf(stderr, "Too many pool skills! Increase MAX_POOL_SKILLS and recompile.");
-                return;
-        }
-
-        skill_pool_skills[skill_pool_skills_size++] = id;
+    if (skill_pool_skills_size + 1 >= MAX_POOL_SKILLS)
+    {
+        fprintf (stderr,
+                 "Too many pool skills! Increase MAX_POOL_SKILLS and recompile.");
+        return;
+    }
+
+    skill_pool_skills[skill_pool_skills_size++] = id;
 }
 
-
-char *
-skill_name(int skill)
+char *skill_name (int skill)
 {
-        if (skill > 0 && skill < MAX_SKILL_DB)
-                return skill_names[skill].desc;
-        else
-                return NULL;
+    if (skill > 0 && skill < MAX_SKILL_DB)
+        return skill_names[skill].desc;
+    else
+        return NULL;
 }
 
-int
-skill_pool(struct map_session_data *sd, int *skills)
+int skill_pool (struct map_session_data *sd, int *skills)
 {
-        int i, count = 0;
-
-        for (i = 0; count < MAX_SKILL_POOL && i < skill_pool_skills_size; i++) {
-                int skill_id = skill_pool_skills[i];
-                if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED) {
-                        if (skills)
-                                skills[count] = skill_id;
-                        ++count;
-                }
+    int  i, count = 0;
+
+    for (i = 0; count < MAX_SKILL_POOL && i < skill_pool_skills_size; i++)
+    {
+        int  skill_id = skill_pool_skills[i];
+        if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
+        {
+            if (skills)
+                skills[count] = skill_id;
+            ++count;
         }
+    }
 
-        return count;
+    return count;
 }
 
-void
-skill_pool_empty(struct map_session_data *sd)
+void skill_pool_empty (struct map_session_data *sd)
 {
-        int i;
+    int  i;
 
-        for (i = 0; i < skill_pool_skills_size; i++) {
-                int skill_id = skill_pool_skills[i];
-                sd->status.skill[skill_id].flags = 0;
-        }
+    for (i = 0; i < skill_pool_skills_size; i++)
+    {
+        int  skill_id = skill_pool_skills[i];
+        sd->status.skill[skill_id].flags = 0;
+    }
 }
 
-int skill_pool_size(struct map_session_data *sd)
+int skill_pool_size (struct map_session_data *sd)
 {
-        return skill_pool(sd, NULL);
+    return skill_pool (sd, NULL);
 }
 
-int
-skill_pool_max(struct map_session_data *sd)
+int skill_pool_max (struct map_session_data *sd)
 {
-        return sd->status.skill[TMW_SKILLPOOL].lv;
+    return sd->status.skill[TMW_SKILLPOOL].lv;
 }
 
-
-int
-skill_pool_activate(struct map_session_data *sd, int skill_id)
+int skill_pool_activate (struct map_session_data *sd, int skill_id)
 {
-        if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
-                return 0; // Already there
-        else if (sd->status.skill[skill_id].id == skill_id // knows the skill
-                 && (skill_pool_size(sd) < skill_pool_max(sd))) {
-                sd->status.skill[skill_id].flags |= SKILL_POOL_ACTIVATED;
-                pc_calcstatus(sd, 0);
-                MAP_LOG_PC(sd, "SKILL-ACTIVATE %d %d %d", skill_id, sd->status.skill[skill_id].lv, skill_power(sd, skill_id));
-                return 0;
-        }
-
-        return 1; // failed
+    if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
+        return 0;               // Already there
+    else if (sd->status.skill[skill_id].id == skill_id  // knows the skill
+             && (skill_pool_size (sd) < skill_pool_max (sd)))
+    {
+        sd->status.skill[skill_id].flags |= SKILL_POOL_ACTIVATED;
+        pc_calcstatus (sd, 0);
+        MAP_LOG_PC (sd, "SKILL-ACTIVATE %d %d %d", skill_id,
+                    sd->status.skill[skill_id].lv, skill_power (sd,
+                                                                skill_id));
+        return 0;
+    }
+
+    return 1;                   // failed
 }
 
-int
-skill_pool_is_activated(struct map_session_data *sd, int skill_id)
+int skill_pool_is_activated (struct map_session_data *sd, int skill_id)
 {
-        return sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED;
+    return sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED;
 }
 
-int
-skill_pool_deactivate(struct map_session_data *sd, int skill_id)
+int skill_pool_deactivate (struct map_session_data *sd, int skill_id)
 {
-        if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED) {
-                sd->status.skill[skill_id].flags &= ~SKILL_POOL_ACTIVATED;
-                MAP_LOG_PC(sd, "SKILL-DEACTIVATE %d", skill_id);
-                pc_calcstatus(sd, 0);
-                return 0;
-        }
-
-        return 1;
+    if (sd->status.skill[skill_id].flags & SKILL_POOL_ACTIVATED)
+    {
+        sd->status.skill[skill_id].flags &= ~SKILL_POOL_ACTIVATED;
+        MAP_LOG_PC (sd, "SKILL-DEACTIVATE %d", skill_id);
+        pc_calcstatus (sd, 0);
+        return 0;
+    }
+
+    return 1;
 }
 
-
-int
-skill_stat(int skill_id)
+int skill_stat (int skill_id)
 {
-        return skill_db[skill_id].stat;
+    return skill_db[skill_id].stat;
 }
 
-int
-skill_power(struct map_session_data *sd, int skill_id)
+int skill_power (struct map_session_data *sd, int skill_id)
 {
-        int stat = skill_stat(skill_id);
-        int stat_value, skill_value;
-        int result;
+    int  stat = skill_stat (skill_id);
+    int  stat_value, skill_value;
+    int  result;
 
-        if (stat == 0
-            || !skill_pool_is_activated(sd, skill_id))
-                return 0;
+    if (stat == 0 || !skill_pool_is_activated (sd, skill_id))
+        return 0;
 
-        stat_value = battle_get_stat(stat, &(sd->bl));
-        skill_value = sd->status.skill[skill_id].lv;
+    stat_value = battle_get_stat (stat, &(sd->bl));
+    skill_value = sd->status.skill[skill_id].lv;
 
-        if ((skill_value * 10) - 1 > stat_value)
-                skill_value += (stat_value / 10);
-        else
-                skill_value *= 2;
+    if ((skill_value * 10) - 1 > stat_value)
+        skill_value += (stat_value / 10);
+    else
+        skill_value *= 2;
 
-        result = (skill_value * stat_value) / 10;
+    result = (skill_value * stat_value) / 10;
 
-        return result;
+    return result;
 }
 
-
-int
-skill_power_bl(struct block_list *bl, int skill)
+int skill_power_bl (struct block_list *bl, int skill)
 {
-        if (bl->type == BL_PC)
-                return skill_power((struct map_session_data *) bl, skill);
-        else
-                return 0;
+    if (bl->type == BL_PC)
+        return skill_power ((struct map_session_data *) bl, skill);
+    else
+        return 0;
 }