Some formatting fixes before I go insane

Also delete the French translation from ladmin.

1 files changed, 393 insertions, 393 deletions

diff --git a/src/map/magic-stmt.cpp b/src/map/magic-stmt.cpp
index 2fcf60c..b98130e 100644
--- a/src/map/magic-stmt.cpp
+++ b/src/map/magic-stmt.cpp
@@ -8,85 +8,85 @@
 //#define DEBUG
 
 #ifdef DEBUG
-static void print_val (val_t * v)
+static void print_val(val_t * v)
 {
     switch (v->ty)
     {
         case TY_UNDEF:
-            fprintf (stderr, "UNDEF");
+            fprintf(stderr, "UNDEF");
             break;
         case TY_INT:
-            fprintf (stderr, "%d", v->v.v_int);
+            fprintf(stderr, "%d", v->v.v_int);
             break;
         case TY_DIR:
-            fprintf (stderr, "dir%d", v->v.v_int);
+            fprintf(stderr, "dir%d", v->v.v_int);
             break;
         case TY_STRING:
-            fprintf (stderr, "`%s'", v->v.v_string);
+            fprintf(stderr, "`%s'", v->v.v_string);
             break;
         default:
-            fprintf (stderr, "ty%d", v->ty);
+            fprintf(stderr, "ty%d", v->ty);
             break;
     }
 }
 
-static void dump_env (env_t * env)
+static void dump_env(env_t * env)
 {
-    int  i;
+    int i;
     for (i = 0; i < env->base_env->vars_nr; i++)
     {
         val_t *v = &env->vars[i];
         val_t *bv = &env->base_env->vars[i];
 
-        fprintf (stderr, "%02x %30s ", i, env->base_env->var_name[i]);
-        print_val (v);
-        fprintf (stderr, "\t(");
-        print_val (bv);
-        fprintf (stderr, ")\n");
+        fprintf(stderr, "%02x %30s ", i, env->base_env->var_name[i]);
+        print_val(v);
+        fprintf(stderr, "\t(");
+        print_val(bv);
+        fprintf(stderr, ")\n");
     }
 }
 #endif
 
-static void clear_activation_record (cont_activation_record_t * ar)
+static void clear_activation_record(cont_activation_record_t * ar)
 {
     switch (ar->ty)
     {
         case CONT_STACK_FOREACH:
-            free (ar->c.c_foreach.entities);
+            free(ar->c.c_foreach.entities);
             break;
         case CONT_STACK_PROC:
-            free (ar->c.c_proc.old_actuals);
+            free(ar->c.c_proc.old_actuals);
             break;
     }
 }
 
 static void
-invocation_timer_callback (timer_id UNUSED, tick_t UNUSED, custom_id_t id, custom_data_t data)
+invocation_timer_callback(timer_id UNUSED, tick_t UNUSED, custom_id_t id, custom_data_t data)
 {
-    invocation_t *invocation = (invocation_t *) map_id2bl (id);
+    invocation_t *invocation = (invocation_t *) map_id2bl(id);
 
     if (invocation)
     {
         invocation->timer = 0;
-        spell_execute (invocation);
+        spell_execute(invocation);
     }
 }
 
-static void clear_stack (invocation_t * invocation)
+static void clear_stack(invocation_t * invocation)
 {
-    int  i;
+    int i;
 
     for (i = 0; i < invocation->stack_size; i++)
-        clear_activation_record (&invocation->stack[i]);
+        clear_activation_record(&invocation->stack[i]);
 
     invocation->stack_size = 0;
 }
 
-void spell_free_invocation (invocation_t * invocation)
+void spell_free_invocation(invocation_t * invocation)
 {
     if (invocation->status_change_refs)
     {
-        free (invocation->status_change_refs);
+        free(invocation->status_change_refs);
         /* The following cleanup shouldn't be necessary, but I've added it to help tracking a certain bug */
         invocation->status_change_refs = NULL;
         invocation->status_change_refs_nr = 0;
@@ -94,25 +94,25 @@ void spell_free_invocation (invocation_t * invocation)
 
     if (invocation->flags & INVOCATION_FLAG_BOUND)
     {
-        entity_t *e = map_id2bl (invocation->subject);
+        entity_t *e = map_id2bl(invocation->subject);
         if (e && e->type == BL_PC)
-            spell_unbind ((character_t *) e, invocation);
+            spell_unbind((character_t *) e, invocation);
     }
 
-    clear_stack (invocation);
+    clear_stack(invocation);
 
     if (invocation->timer)
-        delete_timer (invocation->timer, invocation_timer_callback);
+        delete_timer(invocation->timer, invocation_timer_callback);
 
-    magic_free_env (invocation->env);
+    magic_free_env(invocation->env);
 
-    map_delblock (&invocation->bl);
-    map_delobject (invocation->bl.id, BL_SPELL);    // also frees the object
+    map_delblock(&invocation->bl);
+    map_delobject(invocation->bl.id, BL_SPELL);    // also frees the object
 //        free(invocation);
 }
 
 static void
-char_set_weapon_icon (character_t * subject, int count, int icon, int look)
+char_set_weapon_icon(character_t * subject, int count, int icon, int look)
 {
     const int old_icon = subject->attack_spell_icon_override;
 
@@ -120,163 +120,163 @@ char_set_weapon_icon (character_t * subject, int count, int icon, int look)
     subject->attack_spell_look_override = look;
 
     if (old_icon && old_icon != icon)
-        clif_status_change (&subject->bl, old_icon, 0);
+        clif_status_change(&subject->bl, old_icon, 0);
 
-    clif_fixpcpos (subject);
+    clif_fixpcpos(subject);
     if (count)
     {
-        clif_changelook (&subject->bl, LOOK_WEAPON, look);
+        clif_changelook(&subject->bl, LOOK_WEAPON, look);
         if (icon)
-            clif_status_change (&subject->bl, icon, 1);
+            clif_status_change(&subject->bl, icon, 1);
     }
     else
     {
         /* Set it to `normal' */
-        clif_changelook (&subject->bl, LOOK_WEAPON, subject->status.weapon);
+        clif_changelook(&subject->bl, LOOK_WEAPON, subject->status.weapon);
     }
 }
 
-static void char_set_attack_info (character_t * subject, int speed, int range)
+static void char_set_attack_info(character_t * subject, int speed, int range)
 {
     subject->attack_spell_delay = speed;
     subject->attack_spell_range = range;
 
     if (speed == 0)
     {
-        pc_calcstatus (subject, 1);
-        clif_updatestatus (subject, SP_ASPD);
-        clif_updatestatus (subject, SP_ATTACKRANGE);
+        pc_calcstatus(subject, 1);
+        clif_updatestatus(subject, SP_ASPD);
+        clif_updatestatus(subject, SP_ATTACKRANGE);
     }
     else
     {
         subject->aspd = speed;
-        clif_updatestatus (subject, SP_ASPD);
-        clif_updatestatus (subject, SP_ATTACKRANGE);
+        clif_updatestatus(subject, SP_ASPD);
+        clif_updatestatus(subject, SP_ATTACKRANGE);
     }
 }
 
-void magic_stop_completely (character_t * c)
+void magic_stop_completely(character_t * c)
 {
-    int  i;
+    int i;
     // Zap all status change references to spells
     for (i = 0; i < MAX_STATUSCHANGE; i++)
         c->sc_data[i].spell_invocation = 0;
 
     while (c->active_spells)
-        spell_free_invocation (c->active_spells);
+        spell_free_invocation(c->active_spells);
 
     if (c->attack_spell_override)
     {
         invocation_t *attack_spell =
-            (invocation_t *) map_id2bl (c->attack_spell_override);
+            (invocation_t *) map_id2bl(c->attack_spell_override);
         if (attack_spell)
-            spell_free_invocation (attack_spell);
+            spell_free_invocation(attack_spell);
         c->attack_spell_override = 0;
-        char_set_weapon_icon (c, 0, 0, 0);
-        char_set_attack_info (c, 0, 0);
+        char_set_weapon_icon(c, 0, 0, 0);
+        char_set_attack_info(c, 0, 0);
     }
 }
 
 /* Spell execution has finished normally or we have been notified by a finished skill timer */
-static void try_to_finish_invocation (invocation_t * invocation)
+static void try_to_finish_invocation(invocation_t * invocation)
 {
     if (invocation->status_change_refs_nr == 0 && !invocation->current_effect)
     {
         if (invocation->end_effect)
         {
-            clear_stack (invocation);
+            clear_stack(invocation);
             invocation->current_effect = invocation->end_effect;
             invocation->end_effect = NULL;
-            spell_execute (invocation);
+            spell_execute(invocation);
         }
         else
-            spell_free_invocation (invocation);
+            spell_free_invocation(invocation);
     }
 }
 
-static int trigger_spell (int subject, int spell)
+static int trigger_spell(int subject, int spell)
 {
-    invocation_t *invocation = (invocation_t *) map_id2bl (spell);
+    invocation_t *invocation = (invocation_t *) map_id2bl(spell);
 
     if (!invocation)
         return 0;
 
-    invocation = spell_clone_effect (invocation);
+    invocation = spell_clone_effect(invocation);
 
-    spell_bind ((character_t *) map_id2bl (subject), invocation);
-    magic_clear_var (&invocation->env->vars[VAR_CASTER]);
+    spell_bind((character_t *) map_id2bl(subject), invocation);
+    magic_clear_var(&invocation->env->vars[VAR_CASTER]);
     invocation->env->vars[VAR_CASTER].ty = TY_ENTITY;
     invocation->env->vars[VAR_CASTER].v.v_int = subject;
 
     return invocation->bl.id;
 }
 
-static void entity_warp (entity_t * target, int destm, int destx, int desty);
+static void entity_warp(entity_t * target, int destm, int destx, int desty);
 
-static void char_update (character_t * character)
+static void char_update(character_t * character)
 {
-    entity_warp ((entity_t *) character, character->bl.m, character->bl.x,
+    entity_warp((entity_t *) character, character->bl.m, character->bl.x,
                  character->bl.y);
 }
 
-static void timer_callback_effect (timer_id UNUSED, tick_t UNUSED, custom_id_t id, custom_data_t data)
+static void timer_callback_effect(timer_id UNUSED, tick_t UNUSED, custom_id_t id, custom_data_t data)
 {
-    entity_t *target = map_id2bl (id);
+    entity_t *target = map_id2bl(id);
     if (target)
-        clif_misceffect (target, data);
+        clif_misceffect(target, data);
 }
 
-static void entity_effect (entity_t * entity, int effect_nr, int delay)
+static void entity_effect(entity_t * entity, int effect_nr, int delay)
 {
-    add_timer (gettick () + delay,
+    add_timer(gettick() + delay,
                &timer_callback_effect, entity->id, effect_nr);
 }
 
-void magic_unshroud (character_t * other_char)
+void magic_unshroud(character_t * other_char)
 {
     other_char->state.shroud_active = 0;
     // Now warp the caster out of and back into here to refresh everyone's display
-    char_update (other_char);
-    clif_displaymessage (other_char->fd, "Your shroud has been dispelled!");
+    char_update(other_char);
+    clif_displaymessage(other_char->fd, "Your shroud has been dispelled!");
 //        entity_effect(&other_char->bl, MAGIC_EFFECT_REVEAL);
 }
 
 static void
-timer_callback_effect_npc_delete (timer_id UNUSED, tick_t odelay,
+timer_callback_effect_npc_delete(timer_id UNUSED, tick_t odelay,
                                   custom_id_t npc_id, custom_data_t UNUSED)
 {
-    struct npc_data *effect_npc = (struct npc_data *) map_id2bl (npc_id);
-    npc_free (effect_npc);
+    struct npc_data *effect_npc = (struct npc_data *) map_id2bl(npc_id);
+    npc_free(effect_npc);
 }
 
-static struct npc_data *local_spell_effect (int m, int x, int y, int effect,
+static struct npc_data *local_spell_effect(int m, int x, int y, int effect,
                                             int tdelay)
 {
-    int  delay = 30000;         /* 1 minute should be enough for all interesting spell effects, I hope */
-    struct npc_data *effect_npc = npc_spawn_text (m, x, y,
+    int delay = 30000;         /* 1 minute should be enough for all interesting spell effects, I hope */
+    struct npc_data *effect_npc = npc_spawn_text(m, x, y,
                                                   INVISIBLE_NPC, "", "?");
-    int  effect_npc_id = effect_npc->bl.id;
+    int effect_npc_id = effect_npc->bl.id;
 
-    entity_effect (&effect_npc->bl, effect, tdelay);
-    add_timer (gettick () + delay,
+    entity_effect(&effect_npc->bl, effect, tdelay);
+    add_timer(gettick() + delay,
                timer_callback_effect_npc_delete, effect_npc_id, 0);
 
     return effect_npc;
 }
 
-static int op_sfx (env_t * env, int args_nr, val_t * args)
+static int op_sfx(env_t * env, int args_nr, val_t * args)
 {
-    int  delay = ARGINT (2);
+    int delay = ARGINT(2);
 
-    if (TY (0) == TY_ENTITY)
+    if (TY(0) == TY_ENTITY)
     {
-        entity_effect (ARGENTITY (0), ARGINT (1), delay);
+        entity_effect(ARGENTITY(0), ARGINT(1), delay);
     }
-    else if (TY (0) == TY_LOCATION)
+    else if (TY(0) == TY_LOCATION)
     {
-        local_spell_effect (ARGLOCATION (0).m,
-                            ARGLOCATION (0).x,
-                            ARGLOCATION (0).y, ARGINT (1), delay);
+        local_spell_effect(ARGLOCATION(0).m,
+                            ARGLOCATION(0).x,
+                            ARGLOCATION(0).y, ARGINT(1), delay);
     }
     else
         return 1;
@@ -284,11 +284,11 @@ static int op_sfx (env_t * env, int args_nr, val_t * args)
     return 0;
 }
 
-static int op_instaheal (env_t * env, int args_nr, val_t * args)
+static int op_instaheal(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *caster = (VAR (VAR_CASTER).ty == TY_ENTITY)
-        ? map_id2bl (VAR (VAR_CASTER).v.v_int) : NULL;
-    entity_t *subject = ARGENTITY (0);
+    entity_t *caster = (VAR(VAR_CASTER).ty == TY_ENTITY)
+        ? map_id2bl(VAR(VAR_CASTER).v.v_int) : NULL;
+    entity_t *subject = ARGENTITY(0);
     if (!caster)
         caster = subject;
 
@@ -296,38 +296,38 @@ static int op_instaheal (env_t * env, int args_nr, val_t * args)
     {
         character_t *caster_pc = (character_t *) caster;
         character_t *subject_pc = (character_t *) subject;
-        MAP_LOG_PC (caster_pc, "SPELLHEAL-INSTA PC%d FOR %d",
-                    subject_pc->status.char_id, ARGINT (1));
+        MAP_LOG_PC(caster_pc, "SPELLHEAL-INSTA PC%d FOR %d",
+                    subject_pc->status.char_id, ARGINT(1));
     }
 
-    battle_heal (caster, subject, ARGINT (1), ARGINT (2), 0);
+    battle_heal(caster, subject, ARGINT(1), ARGINT(2), 0);
     return 0;
 }
 
-static int op_itemheal (env_t * env, int args_nr, val_t * args)
+static int op_itemheal(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
+    entity_t *subject = ARGENTITY(0);
     if (subject->type == BL_PC)
     {
-        pc_itemheal ((struct map_session_data *) subject,
-                     ARGINT (1), ARGINT (2));
+        pc_itemheal((struct map_session_data *) subject,
+                     ARGINT(1), ARGINT(2));
     }
     else
-        return op_instaheal (env, args_nr, args);
+        return op_instaheal(env, args_nr, args);
 
     return 0;
 }
 
-#define SHROUD_HIDE_NAME_TALKING_FLAG	(1 << 0)
-#define SHROUD_DISAPPEAR_ON_PICKUP_FLAG	(1 << 1)
-#define SHROUD_DISAPPEAR_ON_TALK_FLAG	(1 << 2)
+#define SHROUD_HIDE_NAME_TALKING_FLAG   (1 << 0)
+#define SHROUD_DISAPPEAR_ON_PICKUP_FLAG (1 << 1)
+#define SHROUD_DISAPPEAR_ON_TALK_FLAG   (1 << 2)
 
 #define ARGCHAR(n) (ARGENTITY(n)->type == BL_PC) ? (character_t *)(ARGENTITY(n)) : NULL
 
-static int op_shroud (env_t * env, int args_nr, val_t * args)
+static int op_shroud(env_t * env, int args_nr, val_t * args)
 {
-    character_t *subject = ARGCHAR (0);
-    int  arg = ARGINT (1);
+    character_t *subject = ARGCHAR(0);
+    int arg = ARGINT(1);
 
     if (!subject)
         return 0;
@@ -342,50 +342,50 @@ static int op_shroud (env_t * env, int args_nr, val_t * args)
     return 0;
 }
 
-static int op_reveal (env_t * env, int args_nr, val_t * args)
+static int op_reveal(env_t * env, int args_nr, val_t * args)
 {
-    character_t *subject = ARGCHAR (0);
+    character_t *subject = ARGCHAR(0);
 
     if (subject && subject->state.shroud_active)
-        magic_unshroud (subject);
+        magic_unshroud(subject);
 
     return 0;
 }
 
-static int op_message (env_t * env, int args_nr, val_t * args)
+static int op_message(env_t * env, int args_nr, val_t * args)
 {
-    character_t *subject = ARGCHAR (0);
+    character_t *subject = ARGCHAR(0);
 
     if (subject)
-        clif_displaymessage (subject->fd, ARGSTR (1));
+        clif_displaymessage(subject->fd, ARGSTR(1));
 
     return 0;
 }
 
 static void
-timer_callback_kill_npc (timer_id UNUSED, tick_t odelay, custom_id_t npc_id,
+timer_callback_kill_npc(timer_id UNUSED, tick_t odelay, custom_id_t npc_id,
                          custom_data_t data)
 {
-    struct npc_data *npc = (struct npc_data *) map_id2bl (npc_id);
+    struct npc_data *npc = (struct npc_data *) map_id2bl(npc_id);
     if (npc)
-        npc_free (npc);
+        npc_free(npc);
 }
 
-static int op_messenger_npc (env_t * env, int args_nr, val_t * args)
+static int op_messenger_npc(env_t * env, int args_nr, val_t * args)
 {
     struct npc_data *npc;
-    location_t *loc = &ARGLOCATION (0);
+    location_t *loc = &ARGLOCATION(0);
 
-    npc = npc_spawn_text (loc->m, loc->x, loc->y,
-                          ARGINT (1), ARGSTR (2), ARGSTR (3));
+    npc = npc_spawn_text(loc->m, loc->x, loc->y,
+                          ARGINT(1), ARGSTR(2), ARGSTR(3));
 
-    add_timer (gettick () + ARGINT (4),
+    add_timer(gettick() + ARGINT(4),
                &timer_callback_kill_npc, npc->bl.id, 0);
 
     return 0;
 }
 
-static void entity_warp (entity_t * target, int destm, int destx, int desty)
+static void entity_warp(entity_t * target, int destm, int destx, int desty)
 {
     if (target->type == BL_PC || target->type == BL_MOB)
     {
@@ -396,21 +396,21 @@ static void entity_warp (entity_t * target, int destm, int destx, int desty)
             {
                 character_t *character = (character_t *) target;
                 char *map_name;
-                clif_clearchar_area (&character->bl, 3);
-                map_delblock (&character->bl);
+                clif_clearchar_area(&character->bl, 3);
+                map_delblock(&character->bl);
                 character->bl.x = destx;
                 character->bl.y = desty;
                 character->bl.m = destm;
 
-                pc_touch_all_relevant_npcs (character);
+                pc_touch_all_relevant_npcs(character);
 
                 // Note that touching NPCs may have triggered warping and thereby updated x and y:
                 map_name = map[character->bl.m].name;
 
                 // Warp part #1: update relevant data, interrupt trading etc.:
-                pc_setpos (character, map_name, character->bl.x, character->bl.y, 0);
+                pc_setpos(character, map_name, character->bl.x, character->bl.y, 0);
                 // Warp part #2: now notify the client
-                clif_changemap (character, map_name,
+                clif_changemap(character, map_name,
                                 character->bl.x, character->bl.y);
                 break;
             }
@@ -418,58 +418,58 @@ static void entity_warp (entity_t * target, int destm, int destx, int desty)
                 target->x = destx;
                 target->y = desty;
                 target->m = destm;
-                clif_fixmobpos ((struct mob_data *) target);
+                clif_fixmobpos((struct mob_data *) target);
                 break;
         }
     }
 }
 
-static int op_move (env_t * env, int args_nr, val_t * args)
+static int op_move(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
-    int  dir = ARGDIR (1);
+    entity_t *subject = ARGENTITY(0);
+    int dir = ARGDIR(1);
 
-    int  newx = subject->x + heading_x[dir];
-    int  newy = subject->y + heading_y[dir];
+    int newx = subject->x + heading_x[dir];
+    int newy = subject->y + heading_y[dir];
 
-    if (!map_is_solid (subject->m, newx, newy))
-        entity_warp (subject, subject->m, newx, newy);
+    if (!map_is_solid(subject->m, newx, newy))
+        entity_warp(subject, subject->m, newx, newy);
 
     return 0;
 }
 
-static int op_warp (env_t * env, int args_nr, val_t * args)
+static int op_warp(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
-    location_t *loc = &ARGLOCATION (1);
+    entity_t *subject = ARGENTITY(0);
+    location_t *loc = &ARGLOCATION(1);
 
-    entity_warp (subject, loc->m, loc->x, loc->y);
+    entity_warp(subject, loc->m, loc->x, loc->y);
 
     return 0;
 }
 
-static int op_banish (env_t * env, int args_nr, val_t * args)
+static int op_banish(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
+    entity_t *subject = ARGENTITY(0);
 
     if (subject->type == BL_MOB)
     {
         struct mob_data *mob = (struct mob_data *) subject;
 
         if (mob->mode & MOB_MODE_SUMMONED)
-            mob_catch_delete (mob, 3);
+            mob_catch_delete(mob, 3);
     }
 
     return 0;
 }
 
 static void
-record_status_change (invocation_t * invocation, int bl_id, int sc_id)
+record_status_change(invocation_t * invocation, int bl_id, int sc_id)
 {
-    int  index = invocation->status_change_refs_nr++;
+    int index = invocation->status_change_refs_nr++;
     status_change_ref_t *cr;
 
-    RECREATE (invocation->status_change_refs, status_change_ref_t, invocation->status_change_refs_nr);
+    RECREATE(invocation->status_change_refs, status_change_ref_t, invocation->status_change_refs_nr);
 
     cr = &invocation->status_change_refs[index];
 
@@ -477,41 +477,41 @@ record_status_change (invocation_t * invocation, int bl_id, int sc_id)
     cr->bl_id = bl_id;
 }
 
-static int op_status_change (env_t * env, int args_nr, val_t * args)
+static int op_status_change(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
-    int  invocation_id = VAR (VAR_INVOCATION).ty == TY_INVOCATION
-        ? VAR (VAR_INVOCATION).v.v_int : 0;
-    invocation_t *invocation = (invocation_t *) map_id2bl (invocation_id);
+    entity_t *subject = ARGENTITY(0);
+    int invocation_id = VAR(VAR_INVOCATION).ty == TY_INVOCATION
+        ? VAR(VAR_INVOCATION).v.v_int : 0;
+    invocation_t *invocation = (invocation_t *) map_id2bl(invocation_id);
 
-    skill_status_effect (subject, ARGINT (1), ARGINT (2), ARGINT (3),
-                         ARGINT (4), ARGINT (5), ARGINT (6), 0,
+    skill_status_effect(subject, ARGINT(1), ARGINT(2), ARGINT(3),
+                         ARGINT(4), ARGINT(5), ARGINT(6), 0,
                          invocation_id);
 
     if (invocation && subject->type == BL_PC)
-        record_status_change (invocation, subject->id, ARGINT (1));
+        record_status_change(invocation, subject->id, ARGINT(1));
 
     return 0;
 }
 
-static int op_stop_status_change (env_t * env, int args_nr, val_t * args)
+static int op_stop_status_change(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *subject = ARGENTITY (0);
+    entity_t *subject = ARGENTITY(0);
 
-    skill_status_change_end (subject, ARGINT (1), -1);
+    skill_status_change_end(subject, ARGINT(1), -1);
 
     return 0;
 }
 
-static int op_override_attack (env_t * env, int args_nr, val_t * args)
+static int op_override_attack(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *psubject = ARGENTITY (0);
-    int  charges = ARGINT (1);
-    int  attack_delay = ARGINT (2);
-    int  attack_range = ARGINT (3);
-    int  icon = ARGINT (4);
-    int  look = ARGINT (5);
-    int  stopattack = ARGINT (6);
+    entity_t *psubject = ARGENTITY(0);
+    int charges = ARGINT(1);
+    int attack_delay = ARGINT(2);
+    int attack_range = ARGINT(3);
+    int icon = ARGINT(4);
+    int look = ARGINT(5);
+    int stopattack = ARGINT(6);
     character_t *subject;
 
     if (psubject->type != BL_PC)
@@ -522,36 +522,36 @@ static int op_override_attack (env_t * env, int args_nr, val_t * args)
     if (subject->attack_spell_override)
     {
         invocation_t *old_invocation =
-            (invocation_t *) map_id2bl (subject->attack_spell_override);
+            (invocation_t *) map_id2bl(subject->attack_spell_override);
         if (old_invocation)
-            spell_free_invocation (old_invocation);
+            spell_free_invocation(old_invocation);
     }
 
     subject->attack_spell_override =
-        trigger_spell (subject->bl.id, VAR (VAR_INVOCATION).v.v_int);
+        trigger_spell(subject->bl.id, VAR(VAR_INVOCATION).v.v_int);
     subject->attack_spell_charges = charges;
 
     if (subject->attack_spell_override)
     {
         invocation_t *attack_spell =
-            (invocation_t *) map_id2bl (subject->attack_spell_override);
+            (invocation_t *) map_id2bl(subject->attack_spell_override);
         if (attack_spell && stopattack)
             attack_spell->flags |= INVOCATION_FLAG_STOPATTACK;
 
-        char_set_weapon_icon (subject, charges, icon, look);
-        char_set_attack_info (subject, attack_delay, attack_range);
+        char_set_weapon_icon(subject, charges, icon, look);
+        char_set_attack_info(subject, attack_delay, attack_range);
     }
 
     return 0;
 }
 
-static int op_create_item (env_t * env, int args_nr, val_t * args)
+static int op_create_item(env_t * env, int args_nr, val_t * args)
 {
     struct item item;
-    entity_t *entity = ARGENTITY (0);
+    entity_t *entity = ARGENTITY(0);
     character_t *subject;
-    int  stackable;
-    int  count = ARGINT (2);
+    int stackable;
+    int count = ARGINT(2);
     if (count <= 0)
         return 0;
 
@@ -560,25 +560,25 @@ static int op_create_item (env_t * env, int args_nr, val_t * args)
     else
         return 0;
 
-    GET_ARG_ITEM (1, item, stackable);
+    GET_ARG_ITEM(1, item, stackable);
 
     if (!stackable)
         while (count--)
-            pc_additem (subject, &item, 1);
+            pc_additem(subject, &item, 1);
     else
-        pc_additem (subject, &item, count);
+        pc_additem(subject, &item, count);
 
     return 0;
 }
 
-#define AGGRAVATION_MODE_ATTACKS_CASTER(n) 	((n) == 0 || (n) == 2)
-#define AGGRAVATION_MODE_MAKES_AGGRESSIVE(n)	((n) > 0)
+#define AGGRAVATION_MODE_ATTACKS_CASTER(n)      ((n) == 0 || (n) == 2)
+#define AGGRAVATION_MODE_MAKES_AGGRESSIVE(n)    ((n) > 0)
 
-static int op_aggravate (env_t * env, int args_nr, val_t * args)
+static int op_aggravate(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *victim = ARGENTITY (2);
-    int  mode = ARGINT (1);
-    entity_t *target = ARGENTITY (0);
+    entity_t *victim = ARGENTITY(2);
+    int mode = ARGINT(1);
+    entity_t *target = ARGENTITY(0);
     struct mob_data *other;
 
     if (target->type == BL_MOB)
@@ -586,12 +586,12 @@ static int op_aggravate (env_t * env, int args_nr, val_t * args)
     else
         return 0;
 
-    mob_target (other, victim, battle_get_range (victim));
+    mob_target(other, victim, battle_get_range(victim));
 
-    if (AGGRAVATION_MODE_MAKES_AGGRESSIVE (mode))
+    if (AGGRAVATION_MODE_MAKES_AGGRESSIVE(mode))
         other->mode = 0x85 | (other->mode & MOB_SENSIBLE_MASK); /* war */
 
-    if (AGGRAVATION_MODE_ATTACKS_CASTER (mode))
+    if (AGGRAVATION_MODE_ATTACKS_CASTER(mode))
     {
         other->target_id = victim->id;
         other->attacked_id = victim->id;
@@ -600,20 +600,20 @@ static int op_aggravate (env_t * env, int args_nr, val_t * args)
     return 0;
 }
 
-#define MONSTER_ATTITUDE_HOSTILE	0
-#define MONSTER_ATTITUDE_FRIENDLY	1
-#define MONSTER_ATTITUDE_SERVANT	2
-#define MONSTER_ATTITUDE_FROZEN		3
+#define MONSTER_ATTITUDE_HOSTILE        0
+#define MONSTER_ATTITUDE_FRIENDLY       1
+#define MONSTER_ATTITUDE_SERVANT        2
+#define MONSTER_ATTITUDE_FROZEN         3
 
-static int op_spawn (env_t * env, int args_nr, val_t * args)
+static int op_spawn(env_t * env, int args_nr, val_t * args)
 {
-    area_t *area = ARGAREA (0);
-    entity_t *owner_e = ARGENTITY (1);
-    int  monster_id = ARGINT (2);
-    int  monster_attitude = ARGINT (3);
-    int  monster_count = ARGINT (4);
-    int  monster_lifetime = ARGINT (5);
-    int  i;
+    area_t *area = ARGAREA(0);
+    entity_t *owner_e = ARGENTITY(1);
+    int monster_id = ARGINT(2);
+    int monster_attitude = ARGINT(3);
+    int monster_count = ARGINT(4);
+    int monster_lifetime = ARGINT(5);
+    int i;
 
     character_t *owner = (monster_attitude == MONSTER_ATTITUDE_SERVANT
                           && owner_e->type ==
@@ -622,15 +622,15 @@ static int op_spawn (env_t * env, int args_nr, val_t * args)
     for (i = 0; i < monster_count; i++)
     {
         location_t loc;
-        magic_random_location (&loc, area);
+        magic_random_location(&loc, area);
 
-        int  mob_id;
+        int mob_id;
         struct mob_data *mob;
 
-        mob_id = mob_once_spawn (owner, map[loc.m].name, loc.x, loc.y, "--ja--",    // Is that needed?
+        mob_id = mob_once_spawn(owner, map[loc.m].name, loc.x, loc.y, "--ja--",    // Is that needed?
                                  monster_id, 1, "");
 
-        mob = (struct mob_data *) map_id2bl (mob_id);
+        mob = (struct mob_data *) map_id2bl(mob_id);
 
         if (mob)
         {
@@ -665,7 +665,7 @@ static int op_spawn (env_t * env, int args_nr, val_t * args)
             mob->mode |=
                 MOB_MODE_SUMMONED | MOB_MODE_TURNS_AGAINST_BAD_MASTER;
 
-            mob->deletetimer = add_timer (gettick () + monster_lifetime,
+            mob->deletetimer = add_timer(gettick() + monster_lifetime,
                                           mob_timer_delete, mob_id, 0);
 
             if (owner)
@@ -680,13 +680,13 @@ static int op_spawn (env_t * env, int args_nr, val_t * args)
 }
 
 static
-const char *get_invocation_name (env_t * env)
+const char *get_invocation_name(env_t * env)
 {
     invocation_t *invocation;
 
-    if (VAR (VAR_INVOCATION).ty != TY_INVOCATION)
+    if (VAR(VAR_INVOCATION).ty != TY_INVOCATION)
         return "?";
-    invocation = (invocation_t *) map_id2bl (VAR (VAR_INVOCATION).v.v_int);
+    invocation = (invocation_t *) map_id2bl(VAR(VAR_INVOCATION).v.v_int);
 
     if (invocation)
         return invocation->spell->name;
@@ -694,14 +694,14 @@ const char *get_invocation_name (env_t * env)
         return "??";
 }
 
-static int op_injure (env_t * env, int args_nr, val_t * args)
+static int op_injure(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *caster = ARGENTITY (0);
-    entity_t *target = ARGENTITY (1);
-    int  damage_caused = ARGINT (2);
-    int  mp_damage = ARGINT (3);
-    int  target_hp = battle_get_hp (target);
-    int  mdef = battle_get_mdef (target);
+    entity_t *caster = ARGENTITY(0);
+    entity_t *target = ARGENTITY(1);
+    int damage_caused = ARGINT(2);
+    int mp_damage = ARGINT(3);
+    int target_hp = battle_get_hp(target);
+    int mdef = battle_get_mdef(target);
 
     if (target->type == BL_PC && !map[target->m].flag.pvp && !((character_t *) target)->special_state.killable && (caster->type != BL_PC || !((character_t *) caster)->special_state.killer))
         return 0;               /* Cannot damage other players outside of pvp */
@@ -719,7 +719,7 @@ static int op_injure (env_t * env, int args_nr, val_t * args)
         damage_caused = 0;
 
     // display damage first, because dealing damage may deallocate the target.
-    clif_damage (caster, target, gettick (), 0, 0, damage_caused, 0, 0, 0);
+    clif_damage(caster, target, gettick(), 0, 0, damage_caused, 0, 0, 0);
 
     if (caster->type == BL_PC)
     {
@@ -728,57 +728,57 @@ static int op_injure (env_t * env, int args_nr, val_t * args)
         {
             struct mob_data *mob = (struct mob_data *) target;
 
-            MAP_LOG_PC (caster_pc, "SPELLDMG MOB%d %d FOR %d BY %s",
+            MAP_LOG_PC(caster_pc, "SPELLDMG MOB%d %d FOR %d BY %s",
                         mob->bl.id, mob->mob_class, damage_caused,
-                        get_invocation_name (env));
+                        get_invocation_name(env));
         }
     }
-    battle_damage (caster, target, damage_caused, mp_damage);
+    battle_damage(caster, target, damage_caused, mp_damage);
 
     return 0;
 }
 
-static int op_emote (env_t * env, int args_nr, val_t * args)
+static int op_emote(env_t * env, int args_nr, val_t * args)
 {
-    entity_t *victim = ARGENTITY (0);
-    int  emotion = ARGINT (1);
-    clif_emotion (victim, emotion);
+    entity_t *victim = ARGENTITY(0);
+    int emotion = ARGINT(1);
+    clif_emotion(victim, emotion);
 
     return 0;
 }
 
-static int op_set_script_variable (env_t * env, int args_nr, val_t * args)
+static int op_set_script_variable(env_t * env, int args_nr, val_t * args)
 {
-    character_t *c = (ETY (0) == BL_PC) ? ARGPC (0) : NULL;
+    character_t *c = (ETY(0) == BL_PC) ? ARGPC(0) : NULL;
 
     if (!c)
         return 1;
 
-    pc_setglobalreg (c, ARGSTR (1), ARGINT (2));
+    pc_setglobalreg(c, ARGSTR(1), ARGINT(2));
 
     return 0;
 }
 
-static int op_set_hair_colour (env_t * env, int args_nr, val_t * args)
+static int op_set_hair_colour(env_t * env, int args_nr, val_t * args)
 {
-    character_t *c = (ETY (0) == BL_PC) ? ARGPC (0) : NULL;
+    character_t *c = (ETY(0) == BL_PC) ? ARGPC(0) : NULL;
 
     if (!c)
         return 1;
 
-    pc_changelook (c, LOOK_HAIR_COLOR, ARGINT (1));
+    pc_changelook(c, LOOK_HAIR_COLOR, ARGINT(1));
 
     return 0;
 }
 
-static int op_set_hair_style (env_t * env, int args_nr, val_t * args)
+static int op_set_hair_style(env_t * env, int args_nr, val_t * args)
 {
-    character_t *c = (ETY (0) == BL_PC) ? ARGPC (0) : NULL;
+    character_t *c = (ETY(0) == BL_PC) ? ARGPC(0) : NULL;
 
     if (!c)
         return 1;
 
-    pc_changelook (c, LOOK_HAIR, ARGINT (1));
+    pc_changelook(c, LOOK_HAIR, ARGINT(1));
 
     return 0;
 }
@@ -786,36 +786,36 @@ static int op_set_hair_style (env_t * env, int args_nr, val_t * args)
 static int op_drop_item_for (env_t * env, int args_nr, val_t * args)
 {
     struct item item;
-    int  stackable;
-    location_t *loc = &ARGLOCATION (0);
-    int  count = ARGINT (2);
-    int  time = ARGINT (3);
-    character_t *c = ((args_nr > 4) && (ETY (4) == BL_PC)) ? ARGPC (4) : NULL;
-    int  delay = (args_nr > 5) ? ARGINT (5) : 0;
-    int  delaytime[3] = { delay, delay, delay };
+    int stackable;
+    location_t *loc = &ARGLOCATION(0);
+    int count = ARGINT(2);
+    int time = ARGINT(3);
+    character_t *c = ((args_nr > 4) && (ETY(4) == BL_PC)) ? ARGPC(4) : NULL;
+    int delay = (args_nr > 5) ? ARGINT(5) : 0;
+    int delaytime[3] = { delay, delay, delay };
     character_t *owners[3] = { c, NULL, NULL };
 
-    GET_ARG_ITEM (1, item, stackable);
+    GET_ARG_ITEM(1, item, stackable);
 
     if (stackable)
-        map_addflooritem_any (&item, count, loc->m, loc->x, loc->y,
+        map_addflooritem_any(&item, count, loc->m, loc->x, loc->y,
                               owners, delaytime, time, 0);
     else
         while (count-- > 0)
-            map_addflooritem_any (&item, 1, loc->m, loc->x, loc->y,
+            map_addflooritem_any(&item, 1, loc->m, loc->x, loc->y,
                                   owners, delaytime, time, 0);
 
     return 0;
 }
 
-static int op_gain_exp (env_t * env, int args_nr, val_t * args)
+static int op_gain_exp(env_t * env, int args_nr, val_t * args)
 {
-    character_t *c = (ETY (0) == BL_PC) ? ARGPC (0) : NULL;
+    character_t *c = (ETY(0) == BL_PC) ? ARGPC(0) : NULL;
 
     if (!c)
         return 1;
 
-    pc_gainexp_reason (c, ARGINT (1), ARGINT (2), ARGINT (3));
+    pc_gainexp_reason(c, ARGINT(1), ARGINT(2), ARGINT(3));
     return 0;
 }
 
@@ -851,12 +851,12 @@ static int operations_sorted = 0;
 static int operation_count;
 
 static
-int compare_operations (const void *lhs, const void *rhs)
+int compare_operations(const void *lhs, const void *rhs)
 {
-    return strcmp (((op_t *) lhs)->name, ((op_t *) rhs)->name);
+    return strcmp(((op_t *) lhs)->name, ((op_t *) rhs)->name);
 }
 
-op_t *magic_get_op (char *name, int *index)
+op_t *magic_get_op(char *name, int *index)
 {
     op_t key;
 
@@ -869,13 +869,13 @@ op_t *magic_get_op (char *name, int *index)
 
         operation_count = opc - operations;
 
-        qsort (operations, operation_count, sizeof (op_t),
+        qsort(operations, operation_count, sizeof(op_t),
                compare_operations);
         operations_sorted = 1;
     }
 
     key.name = name;
-    op_t *op = (op_t *)bsearch (&key, operations, operation_count, sizeof (op_t),
+    op_t *op = (op_t *)bsearch(&key, operations, operation_count, sizeof(op_t),
                         compare_operations);
 
     if (op && index)
@@ -885,12 +885,12 @@ op_t *magic_get_op (char *name, int *index)
 }
 
 void
-spell_effect_report_termination (int invocation_id, int bl_id, int sc_id,
+spell_effect_report_termination(int invocation_id, int bl_id, int sc_id,
                                  int supplanted)
 {
-    int  i;
-    int  index = -1;
-    invocation_t *invocation = (invocation_t *) map_id2bl (invocation_id);
+    int i;
+    int index = -1;
+    invocation_t *invocation = (invocation_t *) map_id2bl(invocation_id);
 
     if (!invocation || invocation->bl.type != BL_SPELL)
         return;
@@ -907,9 +907,9 @@ spell_effect_report_termination (int invocation_id, int bl_id, int sc_id,
 
     if (index == -1)
     {
-        entity_t *entity = map_id2bl (bl_id);
+        entity_t *entity = map_id2bl(bl_id);
         if (entity->type == BL_PC)
-            fprintf (stderr,
+            fprintf(stderr,
                      "[magic] INTERNAL ERROR: spell-effect-report-termination:  tried to terminate on unexpected bl %d, sc %d\n",
                      bl_id, sc_id);
         return;
@@ -922,10 +922,10 @@ spell_effect_report_termination (int invocation_id, int bl_id, int sc_id,
             invocation->
             status_change_refs[--invocation->status_change_refs_nr];
 
-    try_to_finish_invocation (invocation);
+    try_to_finish_invocation(invocation);
 }
 
-static effect_t *return_to_stack (invocation_t * invocation)
+static effect_t *return_to_stack(invocation_t * invocation)
 {
     if (!invocation->stack_size)
         return NULL;
@@ -939,17 +939,17 @@ static effect_t *return_to_stack (invocation_t * invocation)
             case CONT_STACK_PROC:
             {
                 effect_t *ret = ar->return_location;
-                int  i;
+                int i;
 
                 for (i = 0; i < ar->c.c_proc.args_nr; i++)
                 {
                     val_t *var =
                         &invocation->env->vars[ar->c.c_proc.formals[i]];
-                    magic_clear_var (var);
+                    magic_clear_var(var);
                     *var = ar->c.c_proc.old_actuals[i];
                 }
 
-                clear_activation_record (ar);
+                clear_activation_record(ar);
                 --invocation->stack_size;
 
                 return ret;
@@ -957,7 +957,7 @@ static effect_t *return_to_stack (invocation_t * invocation)
 
             case CONT_STACK_FOREACH:
             {
-                int  entity_id;
+                int entity_id;
                 val_t *var = &invocation->env->vars[ar->c.c_foreach.id];
 
                 do
@@ -965,7 +965,7 @@ static effect_t *return_to_stack (invocation_t * invocation)
                     if (ar->c.c_foreach.index >= ar->c.c_foreach.entities_nr)
                     {
                         effect_t *ret = ar->return_location;
-                        clear_activation_record (ar);
+                        clear_activation_record(ar);
                         --invocation->stack_size;
                         return ret;
                     }
@@ -973,9 +973,9 @@ static effect_t *return_to_stack (invocation_t * invocation)
                     entity_id =
                         ar->c.c_foreach.entities[ar->c.c_foreach.index++];
                 }
-                while (!entity_id || !map_id2bl (entity_id));
+                while (!entity_id || !map_id2bl(entity_id));
 
-                magic_clear_var (var);
+                magic_clear_var(var);
                 var->ty = ar->c.c_foreach.ty;
                 var->v.v_int = entity_id;
 
@@ -986,12 +986,12 @@ static effect_t *return_to_stack (invocation_t * invocation)
                 if (ar->c.c_for.current > ar->c.c_for.stop)
                 {
                     effect_t *ret = ar->return_location;
-                    clear_activation_record (ar);
+                    clear_activation_record(ar);
                     --invocation->stack_size;
                     return ret;
                 }
 
-                magic_clear_var (&invocation->env->vars[ar->c.c_for.id]);
+                magic_clear_var(&invocation->env->vars[ar->c.c_for.id]);
                 invocation->env->vars[ar->c.c_for.id].ty = TY_INT;
                 invocation->env->vars[ar->c.c_for.id].v.v_int =
                     ar->c.c_for.current++;
@@ -999,7 +999,7 @@ static effect_t *return_to_stack (invocation_t * invocation)
                 return ar->c.c_for.body;
 
             default:
-                fprintf (stderr,
+                fprintf(stderr,
                          "[magic] INTERNAL ERROR: While executing spell `%s':  stack corruption\n",
                          invocation->spell->name);
                 return NULL;
@@ -1007,7 +1007,7 @@ static effect_t *return_to_stack (invocation_t * invocation)
     }
 }
 
-static cont_activation_record_t *add_stack_entry (invocation_t * invocation,
+static cont_activation_record_t *add_stack_entry(invocation_t * invocation,
                                                   int ty,
                                                   effect_t * return_location)
 {
@@ -1015,7 +1015,7 @@ static cont_activation_record_t *add_stack_entry (invocation_t * invocation,
         invocation->stack + invocation->stack_size++;
     if (invocation->stack_size >= MAX_STACK_SIZE)
     {
-        fprintf (stderr,
+        fprintf(stderr,
                  "[magic] Execution stack size exceeded in spell `%s'; truncating effect\n",
                  invocation->spell->name);
         invocation->stack_size--;
@@ -1028,19 +1028,19 @@ static cont_activation_record_t *add_stack_entry (invocation_t * invocation,
 }
 
 static
-void find_entities_in_area_c (entity_t * target, va_list va)
+void find_entities_in_area_c(entity_t * target, va_list va)
 {
-    int *entities_allocd_p = va_arg (va, int *);
-    int *entities_nr_p = va_arg (va, int *);
-    int **entities_p = va_arg (va, int **);
-    int  filter = va_arg (va, int);
+    int *entities_allocd_p = va_arg(va, int *);
+    int *entities_nr_p = va_arg(va, int *);
+    int **entities_p = va_arg(va, int **);
+    int filter = va_arg(va, int);
 
 /* The following macro adds an entity to the result list: */
 #define ADD_ENTITY(e)                                                   \
         if (*entities_nr_p == *entities_allocd_p) {                     \
                 /* Need more space */                                   \
                 (*entities_allocd_p) += 32;                             \
-                RECREATE (*entities_p, int, *entities_allocd_p); \
+                RECREATE(*entities_p, int, *entities_allocd_p); \
         }                                                               \
         (*entities_p)[(*entities_nr_p)++] = e;
 
@@ -1060,7 +1060,7 @@ void find_entities_in_area_c (entity_t * target, va_list va)
 
                 while (invoc)
                 {
-                    ADD_ENTITY (invoc->bl.id);
+                    ADD_ENTITY(invoc->bl.id);
                     invoc = invoc->next_invocation;
                 }
             }
@@ -1079,7 +1079,7 @@ void find_entities_in_area_c (entity_t * target, va_list va)
             {
                 invocation_t *invocation = (invocation_t *) target;
 
-                /* Check whether the spell is `bound'-- if so, we'll consider it iff we see the caster (case BL_PC). */
+                /* Check whether the spell is `bound'-- if so, we'll consider it iff we see the caster(case BL_PC). */
                 if (invocation->flags & INVOCATION_FLAG_BOUND)
                     return;
                 else
@@ -1098,28 +1098,28 @@ void find_entities_in_area_c (entity_t * target, va_list va)
             return;
     }
 
-    ADD_ENTITY (target->id);
+    ADD_ENTITY(target->id);
 #undef ADD_ENTITY
 }
 
 static void
-find_entities_in_area (area_t * area, int *entities_allocd_p,
+find_entities_in_area(area_t * area, int *entities_allocd_p,
                        int *entities_nr_p, int **entities_p, int filter)
 {
     switch (area->ty)
     {
         case AREA_UNION:
-            find_entities_in_area (area->a.a_union[0], entities_allocd_p,
+            find_entities_in_area(area->a.a_union[0], entities_allocd_p,
                                    entities_nr_p, entities_p, filter);
-            find_entities_in_area (area->a.a_union[1], entities_allocd_p,
+            find_entities_in_area(area->a.a_union[1], entities_allocd_p,
                                    entities_nr_p, entities_p, filter);
             break;
 
         default:
         {
-            int  m, x, y, width, height;
-            magic_area_rect (&m, &x, &y, &width, &height, area);
-            map_foreachinarea (find_entities_in_area_c,
+            int m, x, y, width, height;
+            magic_area_rect(&m, &x, &y, &width, &height, area);
+            map_foreachinarea(find_entities_in_area_c,
                                m, x, y, x + width, y + height,
                                0 /* filter elsewhere */ ,
                                entities_allocd_p, entities_nr_p, entities_p,
@@ -1128,20 +1128,20 @@ find_entities_in_area (area_t * area, int *entities_allocd_p,
     }
 }
 
-static effect_t *run_foreach (invocation_t * invocation, effect_t * foreach,
+static effect_t *run_foreach(invocation_t * invocation, effect_t * foreach,
                               effect_t * return_location)
 {
     val_t area;
-    int  filter = foreach->e.e_foreach.filter;
-    int  id = foreach->e.e_foreach.id;
+    int filter = foreach->e.e_foreach.filter;
+    int id = foreach->e.e_foreach.id;
     effect_t *body = foreach->e.e_foreach.body;
 
-    magic_eval (invocation->env, &area, foreach->e.e_foreach.area);
+    magic_eval(invocation->env, &area, foreach->e.e_foreach.area);
 
     if (area.ty != TY_AREA)
     {
-        magic_clear_var (&area);
-        fprintf (stderr,
+        magic_clear_var(&area);
+        fprintf(stderr,
                  "[magic] Error in spell `%s':  FOREACH loop over non-area\n",
                  invocation->spell->name);
         return return_location;
@@ -1149,37 +1149,37 @@ static effect_t *run_foreach (invocation_t * invocation, effect_t * foreach,
     else
     {
         cont_activation_record_t *ar =
-            add_stack_entry (invocation, CONT_STACK_FOREACH, return_location);
-        int  entities_allocd = 64;
+            add_stack_entry(invocation, CONT_STACK_FOREACH, return_location);
+        int entities_allocd = 64;
         int *entities_collect;
         int *entities;
         int *shuffle_board;
-        int  entities_nr = 0;
-        int  i;
+        int entities_nr = 0;
+        int i;
 
         if (!ar)
             return return_location;
 
-        CREATE (entities_collect, int, entities_allocd);
+        CREATE(entities_collect, int, entities_allocd);
 
-        find_entities_in_area (area.v.v_area, &entities_allocd, &entities_nr,
+        find_entities_in_area(area.v.v_area, &entities_allocd, &entities_nr,
                                &entities_collect, filter);
 
         /* Now shuffle */
-        CREATE (shuffle_board, int, entities_nr);
-        CREATE (entities, int, entities_nr);
+        CREATE(shuffle_board, int, entities_nr);
+        CREATE(entities, int, entities_nr);
         for (i = 0; i < entities_nr; i++)
             shuffle_board[i] = i;
 
         for (i = entities_nr - 1; i >= 0; i--)
         {
-            int  random_index = rand () % (i + 1);
+            int random_index = rand() % (i + 1);
             entities[i] = entities_collect[shuffle_board[random_index]];
             shuffle_board[random_index] = shuffle_board[i]; // thus, we are guaranteed only to use unused indices
         }
 
-        free (entities_collect);
-        free (shuffle_board);
+        free(entities_collect);
+        free(shuffle_board);
         /* Done shuffling */
 
         ar->c.c_foreach.id = id;
@@ -1190,9 +1190,9 @@ static effect_t *run_foreach (invocation_t * invocation, effect_t * foreach,
         ar->c.c_foreach.ty =
             (filter == FOREACH_FILTER_SPELL) ? TY_INVOCATION : TY_ENTITY;
 
-        magic_clear_var (&area);
+        magic_clear_var(&area);
 
-        return return_to_stack (invocation);
+        return return_to_stack(invocation);
     }
 }
 
@@ -1200,24 +1200,24 @@ static effect_t *run_for (invocation_t * invocation, effect_t * for_,
                           effect_t * return_location)
 {
     cont_activation_record_t *ar;
-    int  id = for_->e.e_for.id;
+    int id = for_->e.e_for.id;
     val_t start;
     val_t stop;
 
-    magic_eval (invocation->env, &start, for_->e.e_for.start);
-    magic_eval (invocation->env, &stop, for_->e.e_for.stop);
+    magic_eval(invocation->env, &start, for_->e.e_for.start);
+    magic_eval(invocation->env, &stop, for_->e.e_for.stop);
 
     if (start.ty != TY_INT || stop.ty != TY_INT)
     {
-        magic_clear_var (&start);
-        magic_clear_var (&stop);
-        fprintf (stderr,
+        magic_clear_var(&start);
+        magic_clear_var(&stop);
+        fprintf(stderr,
                  "[magic] Error in spell `%s':  FOR loop start or stop point is not an integer\n",
                  invocation->spell->name);
         return return_location;
     }
 
-    ar = add_stack_entry (invocation, CONT_STACK_FOR, return_location);
+    ar = add_stack_entry(invocation, CONT_STACK_FOR, return_location);
 
     if (!ar)
         return return_location;
@@ -1227,21 +1227,21 @@ static effect_t *run_for (invocation_t * invocation, effect_t * for_,
     ar->c.c_for.stop = stop.v.v_int;
     ar->c.c_for.body = for_->e.e_for.body;
 
-    return return_to_stack (invocation);
+    return return_to_stack(invocation);
 }
 
-static effect_t *run_call (invocation_t * invocation,
+static effect_t *run_call(invocation_t * invocation,
                            effect_t * return_location)
 {
     effect_t *current = invocation->current_effect;
     cont_activation_record_t *ar;
-    int  args_nr = current->e.e_call.args_nr;
+    int args_nr = current->e.e_call.args_nr;
     int *formals = current->e.e_call.formals;
     val_t *old_actuals;
-    CREATE (old_actuals, val_t, args_nr);
-    int  i;
+    CREATE(old_actuals, val_t, args_nr);
+    int i;
 
-    ar = add_stack_entry (invocation, CONT_STACK_PROC, return_location);
+    ar = add_stack_entry(invocation, CONT_STACK_PROC, return_location);
     ar->c.c_proc.args_nr = args_nr;
     ar->c.c_proc.formals = formals;
     ar->c.c_proc.old_actuals = old_actuals;
@@ -1249,8 +1249,8 @@ static effect_t *run_call (invocation_t * invocation,
     {
         val_t *env_val = &invocation->env->vars[formals[i]];
         val_t result;
-        magic_copy_var (&old_actuals[i], env_val);
-        magic_eval (invocation->env, &result, current->e.e_call.actuals[i]);
+        magic_copy_var(&old_actuals[i], env_val);
+        magic_eval(invocation->env, &result, current->e.e_call.actuals[i]);
         *env_val = result;
     }
 
@@ -1258,67 +1258,67 @@ static effect_t *run_call (invocation_t * invocation,
 }
 
 #ifdef DEBUG
-static void print_cfg (int i, effect_t * e)
+static void print_cfg(int i, effect_t * e)
 {
-    int  j;
+    int j;
     for (j = 0; j < i; j++)
-        printf ("    ");
+        printf("    ");
 
-    printf ("%p: ", e);
+    printf("%p: ", e);
 
     if (!e)
     {
-        puts (" -- end --");
+        puts(" -- end --");
         return;
     }
 
     switch (e->ty)
     {
         case EFFECT_SKIP:
-            puts ("SKIP");
+            puts("SKIP");
             break;
         case EFFECT_END:
-            puts ("END");
+            puts("END");
             break;
         case EFFECT_ABORT:
-            puts ("ABORT");
+            puts("ABORT");
             break;
         case EFFECT_ASSIGN:
-            puts ("ASSIGN");
+            puts("ASSIGN");
             break;
         case EFFECT_FOREACH:
-            puts ("FOREACH");
-            print_cfg (i + 1, e->e.e_foreach.body);
+            puts("FOREACH");
+            print_cfg(i + 1, e->e.e_foreach.body);
             break;
         case EFFECT_FOR:
-            puts ("FOR");
-            print_cfg (i + 1, e->e.e_for.body);
+            puts("FOR");
+            print_cfg(i + 1, e->e.e_for.body);
             break;
         case EFFECT_IF:
-            puts ("IF");
+            puts("IF");
             for (j = 0; j < i; j++)
-                printf ("    ");
-            puts ("THEN");
-            print_cfg (i + 1, e->e.e_if.true_branch);
+                printf("    ");
+            puts("THEN");
+            print_cfg(i + 1, e->e.e_if.true_branch);
             for (j = 0; j < i; j++)
-                printf ("    ");
-            puts ("ELSE");
-            print_cfg (i + 1, e->e.e_if.false_branch);
+                printf("    ");
+            puts("ELSE");
+            print_cfg(i + 1, e->e.e_if.false_branch);
             break;
         case EFFECT_SLEEP:
-            puts ("SLEEP");
+            puts("SLEEP");
             break;
         case EFFECT_SCRIPT:
-            puts ("SCRIPT");
+            puts("SCRIPT");
             break;
         case EFFECT_BREAK:
-            puts ("BREAK");
+            puts("BREAK");
             break;
         case EFFECT_OP:
-            puts ("OP");
+            puts("OP");
             break;
     }
-    print_cfg (i, e->next);
+    print_cfg(i, e->next);
 }
 #endif
 
@@ -1331,25 +1331,25 @@ static void print_cfg (int i, effect_t * e)
  *          >1 if we hit `sleep'; the result is the number of ticks we should sleep for.
  *          -1 if we paused to wait for a user action (via script interaction)
  */
-static int spell_run (invocation_t * invocation, int allow_delete)
+static int spell_run(invocation_t * invocation, int allow_delete)
 {
     const int invocation_id = invocation->bl.id;
 #define REFRESH_INVOCATION invocation = (invocation_t *) map_id2bl(invocation_id); if (!invocation) return 0;
 
 #ifdef DEBUG
-    fprintf (stderr, "Resuming execution:  invocation of `%s'\n",
+    fprintf(stderr, "Resuming execution:  invocation of `%s'\n",
              invocation->spell->name);
-    print_cfg (1, invocation->current_effect);
+    print_cfg(1, invocation->current_effect);
 #endif
     while (invocation->current_effect)
     {
         effect_t *e = invocation->current_effect;
         effect_t *next = e->next;
-        int  i;
+        int i;
 
 #ifdef DEBUG
-        fprintf (stderr, "Next step of type %d\n", e->ty);
-        dump_env (invocation->env);
+        fprintf(stderr, "Next step of type %d\n", e->ty);
+        dump_env(invocation->env);
 #endif
 
         switch (e->ty)
@@ -1361,18 +1361,18 @@ static int spell_run (invocation_t * invocation, int allow_delete)
                 invocation->flags |= INVOCATION_FLAG_ABORTED;
                 invocation->end_effect = NULL;
             case EFFECT_END:
-                clear_stack (invocation);
+                clear_stack(invocation);
                 next = NULL;
                 break;
 
             case EFFECT_ASSIGN:
-                magic_eval (invocation->env,
+                magic_eval(invocation->env,
                             &invocation->env->vars[e->e.e_assign.id],
                             e->e.e_assign.expr);
                 break;
 
             case EFFECT_FOREACH:
-                next = run_foreach (invocation, e, next);
+                next = run_foreach(invocation, e, next);
                 break;
 
             case EFFECT_FOR:
@@ -1380,7 +1380,7 @@ static int spell_run (invocation_t * invocation, int allow_delete)
                 break;
 
             case EFFECT_IF:
-                if (magic_eval_int (invocation->env, e->e.e_if.cond))
+                if (magic_eval_int(invocation->env, e->e.e_if.cond))
                     next = e->e.e_if.true_branch;
                 else
                     next = e->e.e_if.false_branch;
@@ -1388,8 +1388,8 @@ static int spell_run (invocation_t * invocation, int allow_delete)
 
             case EFFECT_SLEEP:
             {
-                int  sleeptime =
-                    magic_eval_int (invocation->env, e->e.e_sleep);
+                int sleeptime =
+                    magic_eval_int(invocation->env, e->e.e_sleep);
                 invocation->current_effect = next;
                 if (sleeptime > 0)
                     return sleeptime;
@@ -1399,37 +1399,37 @@ static int spell_run (invocation_t * invocation, int allow_delete)
             case EFFECT_SCRIPT:
             {
                 character_t *caster =
-                    (character_t *) map_id2bl (invocation->caster);
+                    (character_t *) map_id2bl(invocation->caster);
                 if (caster)
                 {
                     env_t *env = invocation->env;
                     argrec_t arg[] = { {"@target",
-                                        VAR (VAR_TARGET).ty ==
-                                        TY_ENTITY ? 0 : VAR (VAR_TARGET).
+                                        VAR(VAR_TARGET).ty ==
+                                        TY_ENTITY ? 0 : VAR(VAR_TARGET).
                                         v.v_int}
                     ,
                     {"@caster", invocation->caster}
                     ,
                     {"@caster_name$", caster ? caster->status.name : ""}
                     };
-                    int  message_recipient =
-                        VAR (VAR_SCRIPTTARGET).ty ==
-                        TY_ENTITY ? VAR (VAR_SCRIPTTARGET).
+                    int message_recipient =
+                        VAR(VAR_SCRIPTTARGET).ty ==
+                        TY_ENTITY ? VAR(VAR_SCRIPTTARGET).
                         v.v_int : invocation->caster;
                     character_t *recipient =
-                        (character_t *) map_id2bl (message_recipient);
+                        (character_t *) map_id2bl(message_recipient);
 
                     if (recipient->npc_id
                         && recipient->npc_id != invocation->bl.id)
                         break;  /* Don't send multiple message boxes at once */
 
                     if (!invocation->script_pos)    // first time running this script?
-                        clif_spawn_fake_npc_for_player (recipient,
+                        clif_spawn_fake_npc_for_player(recipient,
                                                         invocation->bl.id);
                     // We have to do this or otherwise the client won't think that it's
                     // dealing with an NPC
 
-                    int  newpos = run_script_l (e->e.e_script,
+                    int newpos = run_script_l(e->e.e_script,
                                                 invocation->script_pos,
                                                 message_recipient,
                                                 invocation->bl.id,
@@ -1444,14 +1444,14 @@ static int spell_run (invocation_t * invocation, int allow_delete)
                     }
                     else
                         invocation->script_pos = 0;
-                    clif_clearchar_id (invocation->bl.id, 1, caster->fd);
+                    clif_clearchar_id(invocation->bl.id, 1, caster->fd);
                 }
                 REFRESH_INVOCATION; // Script may have killed the caster
                 break;
             }
 
             case EFFECT_BREAK:
-                next = return_to_stack (invocation);
+                next = return_to_stack(invocation);
                 break;
 
             case EFFECT_OP:
@@ -1460,111 +1460,111 @@ static int spell_run (invocation_t * invocation, int allow_delete)
                 val_t args[MAX_ARGS];
 
                 for (i = 0; i < e->e.e_op.args_nr; i++)
-                    magic_eval (invocation->env, &args[i], e->e.e_op.args[i]);
+                    magic_eval(invocation->env, &args[i], e->e.e_op.args[i]);
 
-                if (!magic_signature_check ("effect", op->name, op->signature,
+                if (!magic_signature_check("effect", op->name, op->signature,
                                             e->e.e_op.args_nr, args,
                                             e->e.e_op.line_nr,
                                             e->e.e_op.column))
-                    op->op (invocation->env, e->e.e_op.args_nr, args);
+                    op->op(invocation->env, e->e.e_op.args_nr, args);
 
                 for (i = 0; i < e->e.e_op.args_nr; i++)
-                    magic_clear_var (&args[i]);
+                    magic_clear_var(&args[i]);
 
                 REFRESH_INVOCATION; // Effect may have killed the caster
                 break;
             }
 
             case EFFECT_CALL:
-                next = run_call (invocation, next);
+                next = run_call(invocation, next);
                 break;
 
             default:
-                fprintf (stderr,
+                fprintf(stderr,
                          "[magic] INTERNAL ERROR: Unknown effect %d\n",
                          e->ty);
         }
 
         if (!next)
-            next = return_to_stack (invocation);
+            next = return_to_stack(invocation);
 
         invocation->current_effect = next;
     }
 
     if (allow_delete)
-        try_to_finish_invocation (invocation);
+        try_to_finish_invocation(invocation);
     return 0;
 #undef REFRESH_INVOCATION
 }
 
 static
-void spell_execute_d (invocation_t * invocation, int allow_deletion)
+void spell_execute_d(invocation_t * invocation, int allow_deletion)
 {
-    int  delta;
+    int delta;
 
-    spell_update_location (invocation);
-    delta = spell_run (invocation, allow_deletion);
+    spell_update_location(invocation);
+    delta = spell_run(invocation, allow_deletion);
 
     if (delta > 0)
     {
         if (invocation->timer)
         {
-            fprintf (stderr,
+            fprintf(stderr,
                      "[magic] FATAL ERROR: Trying to add multiple timers to the same spell! Already had timer: %d\n",
                      invocation->timer);
             /* *((int *)0x0) = 0; */
         }
-        invocation->timer = add_timer (gettick () + delta,
+        invocation->timer = add_timer(gettick() + delta,
                                        &invocation_timer_callback,
                                        invocation->bl.id, 0);
     }
 
-    /* If 0, the script cleaned itself.  If -1 (wait-for-script), we must wait for the user. */
+    /* If 0, the script cleaned itself.  If -1(wait-for-script), we must wait for the user. */
 }
 
-void spell_execute (invocation_t * invocation)
+void spell_execute(invocation_t * invocation)
 {
-    spell_execute_d (invocation, 1);
+    spell_execute_d(invocation, 1);
 }
 
-void spell_execute_script (invocation_t * invocation)
+void spell_execute_script(invocation_t * invocation)
 {
     if (invocation->script_pos)
-        spell_execute_d (invocation, 1);
+        spell_execute_d(invocation, 1);
     /* Otherwise the script-within-the-spell has been terminated by some other means.
      * In practice this happens when the script doesn't wait for user input: the client
      * may still notify the server that it's done.  Without the above check, we'd be
      * running the same spell twice! */
 }
 
-int spell_attack (int caster_id, int target_id)
+int spell_attack(int caster_id, int target_id)
 {
-    character_t *caster = (character_t *) map_id2bl (caster_id);
+    character_t *caster = (character_t *) map_id2bl(caster_id);
     invocation_t *invocation;
-    int  stop_attack = 0;
+    int stop_attack = 0;
 
     if (!caster)
         return 0;
 
-    invocation = (invocation_t *) map_id2bl (caster->attack_spell_override);
+    invocation = (invocation_t *) map_id2bl(caster->attack_spell_override);
 
     if (invocation && invocation->flags & INVOCATION_FLAG_STOPATTACK)
         stop_attack = 1;
 
     if (invocation && caster->attack_spell_charges > 0)
     {
-        magic_clear_var (&invocation->env->vars[VAR_TARGET]);
+        magic_clear_var(&invocation->env->vars[VAR_TARGET]);
         invocation->env->vars[VAR_TARGET].ty = TY_ENTITY;
         invocation->env->vars[VAR_TARGET].v.v_int = target_id;
 
         invocation->current_effect = invocation->trigger_effect;
         invocation->flags &= ~INVOCATION_FLAG_ABORTED;
-        spell_execute_d (invocation,
+        spell_execute_d(invocation,
                          0 /* don't delete the invocation if done */ );
 
         // If the caster died, we need to refresh here:
         invocation =
-            (invocation_t *) map_id2bl (caster->attack_spell_override);
+            (invocation_t *) map_id2bl(caster->attack_spell_override);
 
         if (invocation && !(invocation->flags & INVOCATION_FLAG_ABORTED))   // If we didn't abort:
             caster->attack_spell_charges--;
@@ -1578,14 +1578,14 @@ int spell_attack (int caster_id, int target_id)
     else if (!invocation || caster->attack_spell_charges <= 0)
     {
         caster->attack_spell_override = 0;
-        char_set_weapon_icon (caster, 0, 0, 0);
-        char_set_attack_info (caster, 0, 0);
+        char_set_weapon_icon(caster, 0, 0, 0);
+        char_set_attack_info(caster, 0, 0);
 
         if (stop_attack)
-            pc_stopattack (caster);
+            pc_stopattack(caster);
 
         if (invocation)
-            spell_free_invocation (invocation);
+            spell_free_invocation(invocation);
     }
 
     return 1;