]> git.jsancho.org Git - lugaru.git/blobdiff - Source/GameTick.cpp
Applied clang-format on all files
[lugaru.git] / Source / GameTick.cpp
index b94d2e8b0162dce0f373c2c6ca6e363960de3b10..7e50cc0d41792850e3ea42b2fdf85ef3b2dd9fa0 100644 (file)
@@ -31,10 +31,10 @@ along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
 #include "Level/Dialog.hpp"
 #include "Level/Hotspot.hpp"
 #include "Menu/Menu.hpp"
+#include "Tutorial.hpp"
 #include "User/Settings.hpp"
 #include "Utils/Folders.hpp"
 #include "Utils/Input.hpp"
-#include "Tutorial.hpp"
 
 #if PLATFORM_UNIX
 #include <sys/stat.h>
@@ -60,7 +60,6 @@ using namespace Game;
 #define snprintf(buf, size, format, ...) _sprintf_p(buf, size, format)
 #endif
 
-
 extern float multiplier;
 extern XYZ viewer;
 extern int environment;
@@ -149,7 +148,7 @@ float musicvolume[4] = {};
 float oldmusicvolume[4] = {};
 int musicselected = 0;
 
-const char *rabbitskin[] = {
+const charrabbitskin[] = {
     "Textures/Fur3.jpg",
     "Textures/Fur.jpg",
     "Textures/Fur2.jpg",
@@ -162,16 +161,16 @@ const char *rabbitskin[] = {
     "Textures/WB2.jpg"
 };
 
-const char *wolfskin[] = {
+const charwolfskin[] = {
     "Textures/Wolf.jpg",
     "Textures/DarkWolf.jpg",
     "Textures/SnowWolf.jpg"
 };
 
-const char **creatureskin[] = {rabbitskin, wolfskin};
+const char** creatureskin[] = { rabbitskin, wolfskin };
 
 #define STATIC_ASSERT(x) extern int s_a_dummy[2 * (!!(x)) - 1];
-STATIC_ASSERT (rabbittype == 0 && wolftype == 1)
+STATIC_ASSERT(rabbittype == 0 && wolftype == 1)
 
 // utility functions
 
@@ -221,71 +220,71 @@ void Game::playdialoguescenesound()
 
     int sound = -1;
     switch (Dialog::currentScene().sound) {
-    case -6:
-        sound = alarmsound;
-        break;
-    case -4:
-        sound = consolefailsound;
-        break;
-    case -3:
-        sound = consolesuccesssound;
-        break;
-    case -2:
-        sound = firestartsound;
-        break;
-    case -1:
-        sound = fireendsound;
-        break;
-    case 1:
-        sound = rabbitchitter;
-        break;
-    case 2:
-        sound = rabbitchitter2;
-        break;
-    case 3:
-        sound = rabbitpainsound;
-        break;
-    case 4:
-        sound = rabbitpain1sound;
-        break;
-    case 5:
-        sound = rabbitattacksound;
-        break;
-    case 6:
-        sound = rabbitattack2sound;
-        break;
-    case 7:
-        sound = rabbitattack3sound;
-        break;
-    case 8:
-        sound = rabbitattack4sound;
-        break;
-    case 9:
-        sound = growlsound;
-        break;
-    case 10:
-        sound = growl2sound;
-        break;
-    case 11:
-        sound = snarlsound;
-        break;
-    case 12:
-        sound = snarl2sound;
-        break;
-    case 13:
-        sound = barksound;
-        break;
-    case 14:
-        sound = bark2sound;
-        break;
-    case 15:
-        sound = bark3sound;
-        break;
-    case 16:
-        sound = barkgrowlsound;
-        break;
-    default:
-        break;
+        case -6:
+            sound = alarmsound;
+            break;
+        case -4:
+            sound = consolefailsound;
+            break;
+        case -3:
+            sound = consolesuccesssound;
+            break;
+        case -2:
+            sound = firestartsound;
+            break;
+        case -1:
+            sound = fireendsound;
+            break;
+        case 1:
+            sound = rabbitchitter;
+            break;
+        case 2:
+            sound = rabbitchitter2;
+            break;
+        case 3:
+            sound = rabbitpainsound;
+            break;
+        case 4:
+            sound = rabbitpain1sound;
+            break;
+        case 5:
+            sound = rabbitattacksound;
+            break;
+        case 6:
+            sound = rabbitattack2sound;
+            break;
+        case 7:
+            sound = rabbitattack3sound;
+            break;
+        case 8:
+            sound = rabbitattack4sound;
+            break;
+        case 9:
+            sound = growlsound;
+            break;
+        case 10:
+            sound = growl2sound;
+            break;
+        case 11:
+            sound = snarlsound;
+            break;
+        case 12:
+            sound = snarl2sound;
+            break;
+        case 13:
+            sound = barksound;
+            break;
+        case 14:
+            sound = bark2sound;
+            break;
+        case 15:
+            sound = bark3sound;
+            break;
+        case 16:
+            sound = barkgrowlsound;
+            break;
+        default:
+            break;
     }
     if (sound != -1)
         emit_sound_at(sound, temppos);
@@ -315,10 +314,10 @@ static int findClosestObject()
 
     for (unsigned int i = 0; i < Object::objects.size(); i++) {
         float distance = distsq(&Object::objects[i]->position,
-                               &Person::players[0]->coords);
+                                &Person::players[0]->coords);
         if (distance < closestdist) {
             closestdist = distance;
-            closest = (int) i;
+            closest = (int)i;
         }
     }
     return closest;
@@ -338,12 +337,12 @@ static void cmd_dispatch(const string cmd)
 }
 
 /********************> Tick() <*****/
-extern bool save_screenshot(const char * fname);
-void Screenshot (void)
+extern bool save_screenshot(const char* fname);
+void Screenshot(void)
 {
     char filename[1024];
     time_t t = time(NULL);
-    struct tm *tme = localtime(&t);
+    struct tmtme = localtime(&t);
     sprintf(filename, "Screenshot-%04d%02d%02d-%02d%02d%02d.png",
             tme->tm_year + 1900, tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);
 
@@ -385,7 +384,6 @@ void Setenvironment(int which)
     pause_sound(stream_wind);
     pause_sound(stream_desertambient);
 
-
     if (environment == snowyenvironment) {
         windvector = 0;
         windvector.z = 3;
@@ -405,17 +403,15 @@ void Setenvironment(int which)
         terraintexture.load("Textures/Snow.jpg", 1);
         terraintexture2.load("Textures/Rock.jpg", 1);
 
-
         temptexdetail = texdetail;
         if (texdetail > 1)
             texdetail = 4;
-        skybox->load(   "Textures/Skybox(snow)/Front.jpg",
-                        "Textures/Skybox(snow)/Left.jpg",
-                        "Textures/Skybox(snow)/Back.jpg",
-                        "Textures/Skybox(snow)/Right.jpg",
-                        "Textures/Skybox(snow)/Up.jpg",
-                        "Textures/Skybox(snow)/Down.jpg");
-
+        skybox->load("Textures/Skybox(snow)/Front.jpg",
+                     "Textures/Skybox(snow)/Left.jpg",
+                     "Textures/Skybox(snow)/Back.jpg",
+                     "Textures/Skybox(snow)/Right.jpg",
+                     "Textures/Skybox(snow)/Up.jpg",
+                     "Textures/Skybox(snow)/Down.jpg");
 
         texdetail = temptexdetail;
     } else if (environment == desertenvironment) {
@@ -426,7 +422,6 @@ void Setenvironment(int which)
         Object::rocktextureptr.load("Textures/BoulderDesert.jpg", 1);
         Object::boxtextureptr.load("Textures/DesertBox.jpg", 1);
 
-
         if (ambientsound)
             emit_stream_np(stream_desertambient);
 
@@ -438,17 +433,15 @@ void Setenvironment(int which)
         terraintexture.load("Textures/Sand.jpg", 1);
         terraintexture2.load("Textures/SandSlope.jpg", 1);
 
-
         temptexdetail = texdetail;
         if (texdetail > 1)
             texdetail = 4;
-        skybox->load(   "Textures/Skybox(sand)/Front.jpg",
-                        "Textures/Skybox(sand)/Left.jpg",
-                        "Textures/Skybox(sand)/Back.jpg",
-                        "Textures/Skybox(sand)/Right.jpg",
-                        "Textures/Skybox(sand)/Up.jpg",
-                        "Textures/Skybox(sand)/Down.jpg");
-
+        skybox->load("Textures/Skybox(sand)/Front.jpg",
+                     "Textures/Skybox(sand)/Left.jpg",
+                     "Textures/Skybox(sand)/Back.jpg",
+                     "Textures/Skybox(sand)/Right.jpg",
+                     "Textures/Skybox(sand)/Up.jpg",
+                     "Textures/Skybox(sand)/Down.jpg");
 
         texdetail = temptexdetail;
     } else if (environment == grassyenvironment) {
@@ -470,17 +463,15 @@ void Setenvironment(int which)
         terraintexture.load("Textures/GrassDirt.jpg", 1);
         terraintexture2.load("Textures/MossRock.jpg", 1);
 
-
         temptexdetail = texdetail;
         if (texdetail > 1)
             texdetail = 4;
-        skybox->load(   "Textures/Skybox(grass)/Front.jpg",
-                        "Textures/Skybox(grass)/Left.jpg",
-                        "Textures/Skybox(grass)/Back.jpg",
-                        "Textures/Skybox(grass)/Right.jpg",
-                        "Textures/Skybox(grass)/Up.jpg",
-                        "Textures/Skybox(grass)/Down.jpg");
-
+        skybox->load("Textures/Skybox(grass)/Front.jpg",
+                     "Textures/Skybox(grass)/Left.jpg",
+                     "Textures/Skybox(grass)/Back.jpg",
+                     "Textures/Skybox(grass)/Right.jpg",
+                     "Textures/Skybox(grass)/Up.jpg",
+                     "Textures/Skybox(grass)/Down.jpg");
 
         texdetail = temptexdetail;
     }
@@ -546,7 +537,7 @@ bool Game::LoadLevel(const std::string& name, bool tutorial)
     pause_sound(stream_firesound);
 
     int mapvers;
-    FILE *tfile;
+    FILEtfile;
     errno = 0;
     tfile = Folders::openMandatoryFile(level_path, "rb");
 
@@ -846,7 +837,6 @@ bool Game::LoadLevel(const std::string& name, bool tutorial)
             }
         }
 
-
         Game::LoadingScreen();
 
         if (cellophane) {
@@ -984,7 +974,7 @@ void doDevKeys()
 
         /* Grow tree leaves?? */
         if (Input::isKeyPressed(SDL_SCANCODE_Y)) {
-           for (auto& an_object : Object::objects) {
+            for (auto& an_object : Object::objects) {
                 if (an_object->type == treeleavestype) {
                     an_object->scale *= .9;
                 }
@@ -1056,7 +1046,7 @@ void doDevKeys()
                     Person::players[closest]->whichskin = 0;
 
                 Person::players[closest]->skeleton.drawmodel.textureptr.load(creatureskin[Person::players[closest]->creature][Person::players[closest]->whichskin], 1,
-                        &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
+                                                                             &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
             }
 
             Person::players[closest]->addClothes();
@@ -1083,7 +1073,6 @@ void doDevKeys()
                     legprop = Person::players[closest]->proportionlegs.x / 1.1;
                 }
 
-
                 if (Person::players[closest]->creature == rabbittype) {
                     Person::players[closest]->creature = wolftype;
                     Person::players[closest]->whichskin = 0;
@@ -1126,7 +1115,6 @@ void doDevKeys()
                     Person::players[closest]->proportionlegs = 1.1 * legprop;
                     Person::players[closest]->proportionlegs.y = 1.05 * legprop;
                 }
-
             }
         }
 
@@ -1288,7 +1276,6 @@ void doDevKeys()
                 Person::players[closest]->skeleton.free = 2;
 
                 camerashake += .6;
-
             }
         }
 
@@ -1321,7 +1308,7 @@ void doDevKeys()
         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = findClosestPlayer();
             if (closest >= 0) {
-                Person::players.erase(Person::players.begin()+closest);
+                Person::players.erase(Person::players.begin() + closest);
             }
         }
 
@@ -1359,7 +1346,7 @@ void doDevKeys()
         if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             Person::players.push_back(shared_ptr<Person>(new Person()));
 
-            Person::players.back()->id = Person::players.size()-1;
+            Person::players.back()->id = Person::players.size() - 1;
 
             Person::players.back()->scale = Person::players[0]->scale;
             Person::players.back()->creature = rabbittype;
@@ -1563,7 +1550,6 @@ void doDevKeys()
                 editorsize = .1;
         }
 
-
         if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             mapradius -= multiplier * 10;
         }
@@ -1595,24 +1581,24 @@ void doJumpReversals()
 {
     for (unsigned k = 0; k < Person::players.size(); k++) {
         for (unsigned i = k + 1; i < Person::players.size(); i++) {
-            if (     Person::players[k]->skeleton.free == 0 &&
-                     Person::players[i]->skeleton.oldfree == 0 &&
-                     (Person::players[i]->animTarget == jumpupanim ||
-                      Person::players[k]->animTarget == jumpupanim) &&
-                     (Person::players[i]->aitype == playercontrolled ||
-                      Person::players[k]->aitype == playercontrolled) &&
-                     ((Person::players[i]->aitype == attacktypecutoff && Person::players[i]->stunned <= 0) ||
-                      (Person::players[k]->aitype == attacktypecutoff && Person::players[k]->stunned <= 0))) {
-                if (     distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 10 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5) &&
-                         distsqflat(&Person::players[i]->coords, &Person::players[k]->coords) < 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
+            if (Person::players[k]->skeleton.free == 0 &&
+                Person::players[i]->skeleton.oldfree == 0 &&
+                (Person::players[i]->animTarget == jumpupanim ||
+                 Person::players[k]->animTarget == jumpupanim) &&
+                (Person::players[i]->aitype == playercontrolled ||
+                 Person::players[k]->aitype == playercontrolled) &&
+                ((Person::players[i]->aitype == attacktypecutoff && Person::players[i]->stunned <= 0) ||
+                 (Person::players[k]->aitype == attacktypecutoff && Person::players[k]->stunned <= 0))) {
+                if (distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 10 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5) &&
+                    distsqflat(&Person::players[i]->coords, &Person::players[k]->coords) < 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
                     //TODO: refactor two huge similar ifs
                     if (Person::players[i]->animTarget == jumpupanim &&
-                            Person::players[k]->animTarget != getupfrombackanim &&
-                            Person::players[k]->animTarget != getupfromfrontanim &&
-                            Animation::animations[Person::players[k]->animTarget].height == middleheight &&
-                            normaldotproduct(Person::players[i]->velocity, Person::players[k]->coords - Person::players[i]->coords) < 0 &&
-                            ((Person::players[k]->aitype == playercontrolled && Person::players[k]->attackkeydown) ||
-                             Person::players[k]->aitype != playercontrolled)) {
+                        Person::players[k]->animTarget != getupfrombackanim &&
+                        Person::players[k]->animTarget != getupfromfrontanim &&
+                        Animation::animations[Person::players[k]->animTarget].height == middleheight &&
+                        normaldotproduct(Person::players[i]->velocity, Person::players[k]->coords - Person::players[i]->coords) < 0 &&
+                        ((Person::players[k]->aitype == playercontrolled && Person::players[k]->attackkeydown) ||
+                         Person::players[k]->aitype != playercontrolled)) {
                         Person::players[i]->victim = Person::players[k];
                         Person::players[i]->velocity = 0;
                         Person::players[i]->animCurrent = jumpreversedanim;
@@ -1646,12 +1632,12 @@ void doJumpReversals()
                             Person::players[k]->stunned = .5;
                     }
                     if (Person::players[k]->animTarget == jumpupanim &&
-                            Person::players[i]->animTarget != getupfrombackanim &&
-                            Person::players[i]->animTarget != getupfromfrontanim &&
-                            Animation::animations[Person::players[i]->animTarget].height == middleheight &&
-                            normaldotproduct(Person::players[k]->velocity, Person::players[i]->coords - Person::players[k]->coords) < 0 &&
-                            ((Person::players[i]->aitype == playercontrolled && Person::players[i]->attackkeydown) ||
-                             Person::players[i]->aitype != playercontrolled)) {
+                        Person::players[i]->animTarget != getupfrombackanim &&
+                        Person::players[i]->animTarget != getupfromfrontanim &&
+                        Animation::animations[Person::players[i]->animTarget].height == middleheight &&
+                        normaldotproduct(Person::players[k]->velocity, Person::players[i]->coords - Person::players[k]->coords) < 0 &&
+                        ((Person::players[i]->aitype == playercontrolled && Person::players[i]->attackkeydown) ||
+                         Person::players[i]->aitype != playercontrolled)) {
                         Person::players[k]->victim = Person::players[i];
                         Person::players[k]->velocity = 0;
                         Person::players[k]->animCurrent = jumpreversedanim;
@@ -1697,30 +1683,29 @@ void doAerialAcrobatics()
         Person::players[k]->turnspeed = 500;
 
         if ((Person::players[k]->isRun() &&
-                ((Person::players[k]->targetyaw != rabbitrunninganim &&
-                  Person::players[k]->targetyaw != wolfrunninganim) ||
-                 Person::players[k]->frameTarget == 4)) ||
-                Person::players[k]->animTarget == removeknifeanim ||
-                Person::players[k]->animTarget == crouchremoveknifeanim ||
-                Person::players[k]->animTarget == flipanim ||
-                Person::players[k]->animTarget == fightsidestep ||
-                Person::players[k]->animTarget == walkanim) {
+             ((Person::players[k]->targetyaw != rabbitrunninganim &&
+               Person::players[k]->targetyaw != wolfrunninganim) ||
+              Person::players[k]->frameTarget == 4)) ||
+            Person::players[k]->animTarget == removeknifeanim ||
+            Person::players[k]->animTarget == crouchremoveknifeanim ||
+            Person::players[k]->animTarget == flipanim ||
+            Person::players[k]->animTarget == fightsidestep ||
+            Person::players[k]->animTarget == walkanim) {
             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed);
         }
 
-
         if (Person::players[k]->isStop() ||
-                Person::players[k]->isLanding() ||
-                Person::players[k]->animTarget == staggerbackhighanim ||
-                (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent == sneakanim) ||
-                Person::players[k]->animTarget == staggerbackhardanim ||
-                Person::players[k]->animTarget == backhandspringanim ||
-                Person::players[k]->animTarget == dodgebackanim ||
-                Person::players[k]->animTarget == rollanim ||
-                (Animation::animations[Person::players[k]->animTarget].attack &&
-                 Person::players[k]->animTarget != rabbitkickanim &&
-                 (Person::players[k]->animTarget != crouchstabanim || Person::players[k]->hasvictim) &&
-                 (Person::players[k]->animTarget != swordgroundstabanim || Person::players[k]->hasvictim))) {
+            Person::players[k]->isLanding() ||
+            Person::players[k]->animTarget == staggerbackhighanim ||
+            (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent == sneakanim) ||
+            Person::players[k]->animTarget == staggerbackhardanim ||
+            Person::players[k]->animTarget == backhandspringanim ||
+            Person::players[k]->animTarget == dodgebackanim ||
+            Person::players[k]->animTarget == rollanim ||
+            (Animation::animations[Person::players[k]->animTarget].attack &&
+             Person::players[k]->animTarget != rabbitkickanim &&
+             (Person::players[k]->animTarget != crouchstabanim || Person::players[k]->hasvictim) &&
+             (Person::players[k]->animTarget != swordgroundstabanim || Person::players[k]->hasvictim))) {
             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed * 2);
         }
 
@@ -1734,9 +1719,9 @@ void doAerialAcrobatics()
 
         //if player's position has changed (?)
         if (distsq(&Person::players[k]->coords, &Person::players[k]->realoldcoords) > 0 &&
-                !Person::players[k]->skeleton.free &&
-                Person::players[k]->animTarget != climbanim &&
-                Person::players[k]->animTarget != hanganim) {
+            !Person::players[k]->skeleton.free &&
+            Person::players[k]->animTarget != climbanim &&
+            Person::players[k]->animTarget != hanganim) {
             XYZ lowpoint, lowpointtarget, lowpoint2, lowpointtarget2, lowpoint3, lowpointtarget3, lowpoint4, lowpointtarget4, lowpoint5, lowpointtarget5, lowpoint6, lowpointtarget6, lowpoint7, lowpointtarget7, colpoint, colpoint2;
             int whichhit;
             bool tempcollide = 0;
@@ -1753,17 +1738,17 @@ void doAerialAcrobatics()
             for (unsigned int l = 0; l < terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz].size(); l++) {
                 unsigned int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
                 if (Object::objects[i]->type != rocktype ||
-                        Object::objects[i]->scale > .5 && Person::players[k]->aitype == playercontrolled ||
-                        Object::objects[i]->position.y > Person::players[k]->coords.y) {
+                    Object::objects[i]->scale > .5 && Person::players[k]->aitype == playercontrolled ||
+                    Object::objects[i]->position.y > Person::players[k]->coords.y) {
                     lowpoint = Person::players[k]->coords;
                     if (Person::players[k]->animTarget != jumpupanim &&
-                            Person::players[k]->animTarget != jumpdownanim &&
-                            !Person::players[k]->isFlip())
+                        Person::players[k]->animTarget != jumpdownanim &&
+                        !Person::players[k]->isFlip())
                         lowpoint.y += 1.25;
                     else
                         lowpoint.y += 1.3;
-                    if (     Person::players[k]->coords.y < terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) &&
-                             Person::players[k]->coords.y > terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) - .1)
+                    if (Person::players[k]->coords.y < terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) &&
+                        Person::players[k]->coords.y > terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) - .1)
                         Person::players[k]->coords.y = terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z);
                     if (Person::players[k]->SphereCheck(&lowpoint, 1.3, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
                         flatfacing = lowpoint - Person::players[k]->coords;
@@ -1774,11 +1759,11 @@ void doAerialAcrobatics()
                         //wall jumps
                         //TODO: refactor four similar blocks
                         if (Person::players[k]->aitype == playercontrolled &&
-                                (Person::players[k]->animTarget == jumpupanim ||
-                                 Person::players[k]->animTarget == jumpdownanim ||
-                                 Person::players[k]->isFlip()) &&
-                                !Person::players[k]->jumptogglekeydown &&
-                                Person::players[k]->jumpkeydown) {
+                            (Person::players[k]->animTarget == jumpupanim ||
+                             Person::players[k]->animTarget == jumpdownanim ||
+                             Person::players[k]->isFlip()) &&
+                            !Person::players[k]->jumptogglekeydown &&
+                            Person::players[k]->jumpkeydown) {
                             lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, -90, 0) * 1.5;
                             XYZ tempcoords1 = lowpoint;
                             whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
@@ -1907,19 +1892,19 @@ void doAerialAcrobatics()
                     if (Object::objects[i]->type != rocktype)
                         if (Person::players[k]->SphereCheck(&lowpoint, 1.33, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
                             if (Person::players[k]->animTarget != jumpupanim &&
-                                    Person::players[k]->animTarget != jumpdownanim &&
-                                    Person::players[k]->onterrain)
+                                Person::players[k]->animTarget != jumpdownanim &&
+                                Person::players[k]->onterrain)
                                 Person::players[k]->avoidcollided = 1;
                             Person::players[k]->coords = lowpoint;
                             Person::players[k]->coords.y -= 1.35;
                             Person::players[k]->collide = 1;
 
                             if ((Person::players[k]->grabdelay <= 0 || Person::players[k]->aitype != playercontrolled) &&
-                                    (Person::players[k]->animCurrent != climbanim &&
+                                (Person::players[k]->animCurrent != climbanim &&
                                      Person::players[k]->animCurrent != hanganim &&
                                      !Person::players[k]->isWallJump() ||
-                                     Person::players[k]->animTarget == jumpupanim ||
-                                     Person::players[k]->animTarget == jumpdownanim)) {
+                                 Person::players[k]->animTarget == jumpupanim ||
+                                 Person::players[k]->animTarget == jumpdownanim)) {
                                 lowpoint = Person::players[k]->coords;
                                 Object::objects[i]->model.SphereCheckPossible(&lowpoint, 1.5, &Object::objects[i]->position, &Object::objects[i]->yaw);
                                 lowpoint = Person::players[k]->coords;
@@ -1964,20 +1949,20 @@ void doAerialAcrobatics()
                                                 Person::players[k]->collided = 1;
                                             if (Object::checkcollide(lowpoint7, lowpointtarget7) == -1)
                                                 if (Object::checkcollide(lowpoint6, lowpointtarget6) == -1)
-                                                    if (     Object::objects[i]->model.LineCheckPossible(&lowpoint2, &lowpointtarget2,
-                                                             &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
-                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint3, &lowpointtarget3,
-                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
-                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint4, &lowpointtarget4,
-                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
-                                                             Object::objects[i]->model.LineCheckPossible(&lowpoint5, &lowpointtarget5,
-                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1)
+                                                    if (Object::objects[i]->model.LineCheckPossible(&lowpoint2, &lowpointtarget2,
+                                                                                                    &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                        Object::objects[i]->model.LineCheckPossible(&lowpoint3, &lowpointtarget3,
+                                                                                                    &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                        Object::objects[i]->model.LineCheckPossible(&lowpoint4, &lowpointtarget4,
+                                                                                                    &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
+                                                        Object::objects[i]->model.LineCheckPossible(&lowpoint5, &lowpointtarget5,
+                                                                                                    &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1)
                                                         for (int j = 0; j < 45; j++) {
                                                             lowpoint = Person::players[k]->coords;
                                                             lowpoint.y += (float)j / 13;
                                                             lowpointtarget = lowpoint + facing * 1.4;
                                                             if (Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget,
-                                                                                                   &colpoint2, &Object::objects[i]->position, &Object::objects[i]->yaw) == -1) {
+                                                                                                            &colpoint2, &Object::objects[i]->position, &Object::objects[i]->yaw) == -1) {
                                                                 if (j <= 6 || j <= 25 && Person::players[k]->animTarget == jumpdownanim)
                                                                     break;
                                                                 if (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim) {
@@ -2033,18 +2018,18 @@ void doAerialAcrobatics()
             if (Person::players[k]->collide <= 0) {
                 //in the air
                 if (!Person::players[k]->onterrain &&
-                        Person::players[k]->animTarget != jumpupanim &&
-                        Person::players[k]->animTarget != jumpdownanim &&
-                        Person::players[k]->animTarget != climbanim &&
-                        Person::players[k]->animTarget != hanganim &&
-                        !Person::players[k]->isWallJump() &&
-                        !Person::players[k]->isFlip()) {
+                    Person::players[k]->animTarget != jumpupanim &&
+                    Person::players[k]->animTarget != jumpdownanim &&
+                    Person::players[k]->animTarget != climbanim &&
+                    Person::players[k]->animTarget != hanganim &&
+                    !Person::players[k]->isWallJump() &&
+                    !Person::players[k]->isFlip()) {
                     if (Person::players[k]->animCurrent != climbanim &&
-                            Person::players[k]->animCurrent != tempanim &&
-                            Person::players[k]->animTarget != backhandspringanim &&
-                            (Person::players[k]->animTarget != rollanim ||
-                             Person::players[k]->frameTarget < 2 ||
-                             Person::players[k]->frameTarget > 6)) {
+                        Person::players[k]->animCurrent != tempanim &&
+                        Person::players[k]->animTarget != backhandspringanim &&
+                        (Person::players[k]->animTarget != rollanim ||
+                         Person::players[k]->frameTarget < 2 ||
+                         Person::players[k]->frameTarget > 6)) {
                         //stagger off ledge (?)
                         if (Person::players[k]->animTarget == staggerbackhighanim || Person::players[k]->animTarget == staggerbackhardanim)
                             Person::players[k]->RagDoll(0);
@@ -2076,23 +2061,23 @@ void doAttacks()
     if (!oldattackkey)
         playerrealattackkeydown = Input::isKeyDown(attackkey);
     if ((Person::players[0]->parriedrecently <= 0 ||
-            Person::players[0]->weaponactive == -1) &&
-            (!oldattackkey ||
-             (realthreat &&
-              Person::players[0]->lastattack != swordslashanim &&
-              Person::players[0]->lastattack != knifeslashstartanim &&
-              Person::players[0]->lastattack != staffhitanim &&
-              Person::players[0]->lastattack != staffspinhitanim)))
+         Person::players[0]->weaponactive == -1) &&
+        (!oldattackkey ||
+         (realthreat &&
+          Person::players[0]->lastattack != swordslashanim &&
+          Person::players[0]->lastattack != knifeslashstartanim &&
+          Person::players[0]->lastattack != staffhitanim &&
+          Person::players[0]->lastattack != staffspinhitanim)))
         Person::players[0]->attackkeydown = Input::isKeyDown(attackkey);
     if (Input::isKeyDown(attackkey) &&
-            !oldattackkey &&
-            !Person::players[0]->backkeydown) {
+        !oldattackkey &&
+        !Person::players[0]->backkeydown) {
         for (unsigned k = 0; k < Person::players.size(); k++) {
             if ((Person::players[k]->animTarget == swordslashanim ||
-                    Person::players[k]->animTarget == staffhitanim ||
-                    Person::players[k]->animTarget == staffspinhitanim) &&
-                    Person::players[0]->animCurrent != dodgebackanim &&
-                    !Person::players[k]->skeleton.free)
+                 Person::players[k]->animTarget == staffhitanim ||
+                 Person::players[k]->animTarget == staffspinhitanim) &&
+                Person::players[0]->animCurrent != dodgebackanim &&
+                !Person::players[k]->skeleton.free)
                 Person::players[k]->Reverse();
         }
     }
@@ -2110,11 +2095,11 @@ void doAttacks()
             if (Person::players[k]->attackkeydown) {
                 //dodge backward
                 if (Person::players[k]->backkeydown &&
-                        Person::players[k]->animTarget != backhandspringanim &&
-                        (Person::players[k]->isIdle() ||
-                         Person::players[k]->isStop() ||
-                         Person::players[k]->isRun() ||
-                         Person::players[k]->animTarget == walkanim)) {
+                    Person::players[k]->animTarget != backhandspringanim &&
+                    (Person::players[k]->isIdle() ||
+                     Person::players[k]->isStop() ||
+                     Person::players[k]->isRun() ||
+                     Person::players[k]->animTarget == walkanim)) {
                     if (Person::players[k]->jumppower <= 1) {
                         Person::players[k]->jumppower -= 2;
                     } else {
@@ -2122,9 +2107,9 @@ void doAttacks()
                             if (i == k)
                                 continue;
                             if (Person::players[i]->animTarget == swordslashanim ||
-                                    Person::players[i]->animTarget == knifeslashstartanim ||
-                                    Person::players[i]->animTarget == staffhitanim ||
-                                    Person::players[i]->animTarget == staffspinhitanim)
+                                Person::players[i]->animTarget == knifeslashstartanim ||
+                                Person::players[i]->animTarget == staffhitanim ||
+                                Person::players[i]->animTarget == staffspinhitanim)
                                 if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < 6.5 && !Person::players[i]->skeleton.free) {
                                     Person::players[k]->setTargetAnimation(dodgebackanim);
                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
@@ -2147,12 +2132,12 @@ void doAttacks()
                 }
                 //attack
                 if (!Animation::animations[Person::players[k]->animTarget].attack &&
-                        !Person::players[k]->backkeydown &&
-                        (Person::players[k]->isIdle() ||
-                         Person::players[k]->isRun() ||
-                         Person::players[k]->animTarget == walkanim ||
-                         Person::players[k]->animTarget == sneakanim ||
-                         Person::players[k]->isCrouch())) {
+                    !Person::players[k]->backkeydown &&
+                    (Person::players[k]->isIdle() ||
+                     Person::players[k]->isRun() ||
+                     Person::players[k]->animTarget == walkanim ||
+                     Person::players[k]->animTarget == sneakanim ||
+                     Person::players[k]->isCrouch())) {
                     const int attackweapon = Person::players[k]->weaponactive == -1 ? 0 : weapons[Person::players[k]->weaponids[Person::players[k]->weaponactive]].getType();
                     //normal attacks (?)
                     Person::players[k]->hasvictim = 0;
@@ -2165,25 +2150,25 @@ void doAttacks()
                                     //choose an attack
                                     const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
                                     if (distance < 4.5 &&
-                                            !Person::players[i]->skeleton.free &&
-                                            Person::players[i]->howactive < typedead1 &&
-                                            Person::players[i]->animTarget != jumpreversedanim &&
-                                            Person::players[i]->animTarget != rabbitkickreversedanim &&
-                                            Person::players[i]->animTarget != rabbitkickanim &&
-                                            Person::players[k]->animTarget != rabbitkickanim &&
-                                            Person::players[i]->animTarget != getupfrombackanim &&
-                                            (Person::players[i]->animTarget != staggerbackhighanim &&
-                                             (Person::players[i]->animTarget != staggerbackhardanim || Person::players[i]->targetFrame().label == 6)) &&
-                                            Person::players[i]->animTarget != jumpdownanim &&
-                                            Person::players[i]->animTarget != jumpupanim &&
-                                            Person::players[i]->animTarget != getupfromfrontanim) {
+                                        !Person::players[i]->skeleton.free &&
+                                        Person::players[i]->howactive < typedead1 &&
+                                        Person::players[i]->animTarget != jumpreversedanim &&
+                                        Person::players[i]->animTarget != rabbitkickreversedanim &&
+                                        Person::players[i]->animTarget != rabbitkickanim &&
+                                        Person::players[k]->animTarget != rabbitkickanim &&
+                                        Person::players[i]->animTarget != getupfrombackanim &&
+                                        (Person::players[i]->animTarget != staggerbackhighanim &&
+                                         (Person::players[i]->animTarget != staggerbackhardanim || Person::players[i]->targetFrame().label == 6)) &&
+                                        Person::players[i]->animTarget != jumpdownanim &&
+                                        Person::players[i]->animTarget != jumpupanim &&
+                                        Person::players[i]->animTarget != getupfromfrontanim) {
                                         Person::players[k]->victim = Person::players[i];
                                         Person::players[k]->hasvictim = 1;
                                         if (Person::players[k]->aitype == playercontrolled) { //human player
                                             //sweep
                                             if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
-                                                    Person::players[k]->crouchkeydown &&
-                                                    Animation::animations[Person::players[i]->animTarget].height != lowheight)
+                                                Person::players[k]->crouchkeydown &&
+                                                Animation::animations[Person::players[i]->animTarget].height != lowheight)
                                                 Person::players[k]->animTarget = sweepanim;
                                             //winduppunch
                                             else if (distance < 1.5 * sq(Person::players[k]->scale * 5) &&
@@ -2274,9 +2259,9 @@ void doAttacks()
                                                 if (attackweapon) {
                                                     //sweep
                                                     if ((!Tutorial::active || !attackweapon) &&
-                                                            distance < 2.5 * sq(Person::players[k]->scale * 5) &&
-                                                            randattack == 0 &&
-                                                            Animation::animations[Person::players[i]->animTarget].height != lowheight)
+                                                        distance < 2.5 * sq(Person::players[k]->scale * 5) &&
+                                                        randattack == 0 &&
+                                                        Animation::animations[Person::players[i]->animTarget].height != lowheight)
                                                         Person::players[k]->animTarget = sweepanim;
                                                     //knifeslashstart
                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
@@ -2326,15 +2311,15 @@ void doAttacks()
                                     }
                                     //sneak attacks
                                     if ((k == 0) && (!Tutorial::active || Tutorial::stage == 22) &&
-                                            Person::players[i]->howactive < typedead1 &&
-                                            distance < 1.5 * sq(Person::players[k]->scale * 5) &&
-                                            !Person::players[i]->skeleton.free &&
-                                            Person::players[i]->animTarget != getupfrombackanim &&
-                                            Person::players[i]->animTarget != getupfromfrontanim &&
-                                            (Person::players[i]->surprised > 0 ||
-                                             Person::players[i]->aitype == passivetype ||
-                                             attackweapon && Person::players[i]->stunned > 0) &&
-                                            normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[k]->coords) > 0) {
+                                        Person::players[i]->howactive < typedead1 &&
+                                        distance < 1.5 * sq(Person::players[k]->scale * 5) &&
+                                        !Person::players[i]->skeleton.free &&
+                                        Person::players[i]->animTarget != getupfrombackanim &&
+                                        Person::players[i]->animTarget != getupfromfrontanim &&
+                                        (Person::players[i]->surprised > 0 ||
+                                         Person::players[i]->aitype == passivetype ||
+                                         attackweapon && Person::players[i]->stunned > 0) &&
+                                        normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[k]->coords) > 0) {
                                         //sneakattack
                                         if (!attackweapon) {
                                             Person::players[k]->animCurrent = sneakattackanim;
@@ -2381,8 +2366,8 @@ void doAttacks()
                                         }
                                     }
                                     if (Animation::animations[Person::players[k]->animTarget].attack == normalattack &&
-                                            Person::players[k]->victim == Person::players[i] &&
-                                            (!Person::players[i]->skeleton.free)) {
+                                        Person::players[k]->victim == Person::players[i] &&
+                                        (!Person::players[i]->skeleton.free)) {
                                         oldattackkey = 1;
                                         Person::players[k]->frameTarget = 0;
                                         Person::players[k]->target = 0;
@@ -2394,7 +2379,7 @@ void doAttacks()
                                         Person::players[k]->lastattack = Person::players[k]->animTarget;
                                     }
                                     if (Person::players[k]->animTarget == knifefollowanim &&
-                                            Person::players[k]->victim == Person::players[i]) {
+                                        Person::players[k]->victim == Person::players[i]) {
                                         oldattackkey = 1;
                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
@@ -2430,20 +2415,20 @@ void doAttacks()
                             if (i == k)
                                 continue;
                             if ((playerrealattackkeydown || Person::players[i]->dead || !hasstaff) &&
-                                    Animation::animations[Person::players[k]->animTarget].attack == neutral) {
+                                Animation::animations[Person::players[k]->animTarget].attack == neutral) {
                                 const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
                                 if (!Person::players[i]->dead || !realthreat || (!attackweapon && Person::players[k]->crouchkeydown))
                                     if (Person::players[i]->skeleton.free)
                                         if (distance < 3.5 * sq(Person::players[k]->scale * 5) &&
-                                                (Person::players[i]->dead ||
-                                                 Person::players[i]->skeleton.longdead > 1000 ||
-                                                 Person::players[k]->isRun() ||
-                                                 hasstaff ||
-                                                 (attackweapon &&
-                                                  (Person::players[i]->skeleton.longdead > 2000 ||
-                                                   Person::players[i]->damage > Person::players[i]->damagetolerance / 8 ||
-                                                   Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2) &&
-                                                  distance < 1.5 * sq(Person::players[k]->scale * 5)))) {
+                                            (Person::players[i]->dead ||
+                                             Person::players[i]->skeleton.longdead > 1000 ||
+                                             Person::players[k]->isRun() ||
+                                             hasstaff ||
+                                             (attackweapon &&
+                                              (Person::players[i]->skeleton.longdead > 2000 ||
+                                               Person::players[i]->damage > Person::players[i]->damagetolerance / 8 ||
+                                               Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2) &&
+                                              distance < 1.5 * sq(Person::players[k]->scale * 5)))) {
                                             Person::players[k]->victim = Person::players[i];
                                             Person::players[k]->hasvictim = 1;
                                             if (attackweapon && !Tutorial::active) {
@@ -2458,12 +2443,12 @@ void doAttacks()
                                                     Person::players[k]->animTarget = staffgroundsmashanim;
                                             }
                                             if (distance < 2.5 &&
-                                                    Person::players[k]->crouchkeydown &&
-                                                    Person::players[k]->animTarget != crouchstabanim &&
-                                                    !attackweapon &&
-                                                    Person::players[i]->dead &&
-                                                    Person::players[i]->skeleton.free &&
-                                                    Person::players[i]->skeleton.longdead > 1000) {
+                                                Person::players[k]->crouchkeydown &&
+                                                Person::players[k]->animTarget != crouchstabanim &&
+                                                !attackweapon &&
+                                                Person::players[i]->dead &&
+                                                Person::players[i]->skeleton.free &&
+                                                Person::players[i]->skeleton.longdead > 1000) {
                                                 Person::players[k]->animTarget = killanim;
                                                 terrain.deleteDeadDecals();
                                                 for (unsigned int l = 0; l < Object::objects.size(); l++) {
@@ -2474,13 +2459,13 @@ void doAttacks()
                                             }
                                             if (!Person::players[i]->dead || musictype != 2)
                                                 if (distance < 3.5 &&
-                                                        (Person::players[k]->isRun() || Person::players[k]->isIdle() && Person::players[k]->attackkeydown) &&
-                                                        Person::players[k]->staggerdelay <= 0 &&
-                                                        (Person::players[i]->dead ||
-                                                         Person::players[i]->skeleton.longdead < 300 &&
+                                                    (Person::players[k]->isRun() || Person::players[k]->isIdle() && Person::players[k]->attackkeydown) &&
+                                                    Person::players[k]->staggerdelay <= 0 &&
+                                                    (Person::players[i]->dead ||
+                                                     Person::players[i]->skeleton.longdead < 300 &&
                                                          Person::players[k]->lastattack != spinkickanim &&
                                                          Person::players[i]->skeleton.free) &&
-                                                        (!Person::players[i]->dead || musictype != stream_fighttheme)) {
+                                                    (!Person::players[i]->dead || musictype != stream_fighttheme)) {
                                                     Person::players[k]->animTarget = dropkickanim;
                                                     terrain.deleteDeadDecals();
                                                     for (unsigned int l = 0; l < Object::objects.size(); l++) {
@@ -2491,23 +2476,24 @@ void doAttacks()
                                                 }
                                         }
                                 if (Animation::animations[Person::players[k]->animTarget].attack == normalattack &&
-                                        Person::players[k]->victim == Person::players[i] &&
-                                        (!Person::players[i]->skeleton.free ||
-                                         Person::players[k]->animTarget == killanim ||
-                                         Person::players[k]->animTarget == crouchstabanim ||
-                                         Person::players[k]->animTarget == swordgroundstabanim ||
-                                         Person::players[k]->animTarget == staffgroundsmashanim ||
-                                         Person::players[k]->animTarget == dropkickanim)) {
+                                    Person::players[k]->victim == Person::players[i] &&
+                                    (!Person::players[i]->skeleton.free ||
+                                     Person::players[k]->animTarget == killanim ||
+                                     Person::players[k]->animTarget == crouchstabanim ||
+                                     Person::players[k]->animTarget == swordgroundstabanim ||
+                                     Person::players[k]->animTarget == staffgroundsmashanim ||
+                                     Person::players[k]->animTarget == dropkickanim)) {
                                     oldattackkey = 1;
                                     Person::players[k]->frameTarget = 0;
                                     Person::players[k]->target = 0;
 
                                     XYZ targetpoint = Person::players[i]->coords;
                                     if (Person::players[k]->animTarget == crouchstabanim ||
-                                            Person::players[k]->animTarget == swordgroundstabanim ||
-                                            Person::players[k]->animTarget == staffgroundsmashanim) {
+                                        Person::players[k]->animTarget == swordgroundstabanim ||
+                                        Person::players[k]->animTarget == staffgroundsmashanim) {
                                         targetpoint += (Person::players[i]->jointPos(abdomen) +
-                                                        Person::players[i]->jointPos(neck)) / 2 *
+                                                        Person::players[i]->jointPos(neck)) /
+                                                       2 *
                                                        Person::players[i]->scale;
                                     }
                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, targetpoint);
@@ -2538,7 +2524,7 @@ void doAttacks()
                             if (!Person::players[i]->skeleton.free) {
                                 if (Person::players[k]->hasvictim) {
                                     if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) <
-                                            distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords))
+                                        distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords))
                                         Person::players[k]->victim = Person::players[i];
                                 } else {
                                     Person::players[k]->victim = Person::players[i];
@@ -2550,19 +2536,19 @@ void doAttacks()
                     if (Person::players[k]->aitype == playercontrolled)
                         //rabbit kick
                         if (Person::players[k]->attackkeydown &&
-                                Person::players[k]->isRun() &&
-                                Person::players[k]->wasRun() &&
-                                ((Person::players[k]->hasvictim &&
-                                  distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) < 12 * sq(Person::players[k]->scale * 5) &&
-                                  distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) > 7 * sq(Person::players[k]->scale * 5) &&
-                                  !Person::players[k]->victim->skeleton.free &&
-                                  Person::players[k]->victim->animTarget != getupfrombackanim &&
-                                  Person::players[k]->victim->animTarget != getupfromfrontanim &&
-                                  Animation::animations[Person::players[k]->victim->animTarget].height != lowheight &&
-                                  Person::players[k]->aitype != playercontrolled && //wat???
-                                  normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
-                                  Person::players[k]->rabbitkickenabled) ||
-                                 Person::players[k]->jumpkeydown)) {
+                            Person::players[k]->isRun() &&
+                            Person::players[k]->wasRun() &&
+                            ((Person::players[k]->hasvictim &&
+                              distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) < 12 * sq(Person::players[k]->scale * 5) &&
+                              distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) > 7 * sq(Person::players[k]->scale * 5) &&
+                              !Person::players[k]->victim->skeleton.free &&
+                              Person::players[k]->victim->animTarget != getupfrombackanim &&
+                              Person::players[k]->victim->animTarget != getupfromfrontanim &&
+                              Animation::animations[Person::players[k]->victim->animTarget].height != lowheight &&
+                              Person::players[k]->aitype != playercontrolled && //wat???
+                              normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
+                              Person::players[k]->rabbitkickenabled) ||
+                             Person::players[k]->jumpkeydown)) {
                             oldattackkey = 1;
                             Person::players[k]->setTargetAnimation(rabbitkickanim);
                         }
@@ -2570,18 +2556,18 @@ void doAttacks()
                     if (Animation::animations[Person::players[k]->animTarget].attack && k == 0) {
                         numattacks++;
                         switch (attackweapon) {
-                        case 0:
-                            numunarmedattack++;
-                            break;
-                        case knife:
-                            numknifeattack++;
-                            break;
-                        case sword:
-                            numswordattack++;
-                            break;
-                        case staff:
-                            numstaffattack++;
-                            break;
+                            case 0:
+                                numunarmedattack++;
+                                break;
+                            case knife:
+                                numknifeattack++;
+                                break;
+                            case sword:
+                                numswordattack++;
+                                break;
+                            case staff:
+                                numstaffattack++;
+                                break;
                         }
                     }
                 }
@@ -2599,25 +2585,27 @@ void doPlayerCollisions()
             for (unsigned i = k + 1; i < Person::players.size(); i++) {
                 //neither player is part of a reversal
                 if ((Animation::animations[Person::players[i]->animTarget].attack != reversed &&
-                        Animation::animations[Person::players[i]->animTarget].attack != reversal &&
-                        Animation::animations[Person::players[k]->animTarget].attack != reversed &&
-                        Animation::animations[Person::players[k]->animTarget].attack != reversal) || (i != 0 && k != 0))
+                     Animation::animations[Person::players[i]->animTarget].attack != reversal &&
+                     Animation::animations[Person::players[k]->animTarget].attack != reversed &&
+                     Animation::animations[Person::players[k]->animTarget].attack != reversal) ||
+                    (i != 0 && k != 0))
                     if ((Animation::animations[Person::players[i]->animCurrent].attack != reversed &&
-                            Animation::animations[Person::players[i]->animCurrent].attack != reversal &&
-                            Animation::animations[Person::players[k]->animCurrent].attack != reversed &&
-                            Animation::animations[Person::players[k]->animCurrent].attack != reversal) || (i != 0 && k != 0))
+                         Animation::animations[Person::players[i]->animCurrent].attack != reversal &&
+                         Animation::animations[Person::players[k]->animCurrent].attack != reversed &&
+                         Animation::animations[Person::players[k]->animCurrent].attack != reversal) ||
+                        (i != 0 && k != 0))
                         //neither is sleeping
                         if (Person::players[i]->howactive <= typesleeping && Person::players[k]->howactive <= typesleeping)
                             if (Person::players[i]->howactive != typesittingwall && Person::players[k]->howactive != typesittingwall)
                                 //in same patch, neither is climbing
                                 if (Person::players[i]->whichpatchx == Person::players[k]->whichpatchx &&
-                                        Person::players[i]->whichpatchz == Person::players[k]->whichpatchz &&
-                                        Person::players[k]->skeleton.oldfree == Person::players[k]->skeleton.free &&
-                                        Person::players[i]->skeleton.oldfree == Person::players[i]->skeleton.free &&
-                                        Person::players[i]->animTarget != climbanim &&
-                                        Person::players[i]->animTarget != hanganim &&
-                                        Person::players[k]->animTarget != climbanim &&
-                                        Person::players[k]->animTarget != hanganim)
+                                    Person::players[i]->whichpatchz == Person::players[k]->whichpatchz &&
+                                    Person::players[k]->skeleton.oldfree == Person::players[k]->skeleton.free &&
+                                    Person::players[i]->skeleton.oldfree == Person::players[i]->skeleton.free &&
+                                    Person::players[i]->animTarget != climbanim &&
+                                    Person::players[i]->animTarget != hanganim &&
+                                    Person::players[k]->animTarget != climbanim &&
+                                    Person::players[k]->animTarget != hanganim)
                                     //players are close (bounding box test)
                                     if (Person::players[i]->coords.y > Person::players[k]->coords.y - 3)
                                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 3)
@@ -2626,8 +2614,7 @@ void doPlayerCollisions()
                                                     if (Person::players[i]->coords.z > Person::players[k]->coords.z - 3)
                                                         if (Person::players[i]->coords.z < Person::players[k]->coords.z + 3) {
                                                             //spread fire from player to player
-                                                            if (distsq(&Person::players[i]->coords, &Person::players[k]->coords)
-                                                                    < 3 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
+                                                            if (distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 3 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
                                                                 if (Person::players[i]->onfire || Person::players[k]->onfire) {
                                                                     if (!Person::players[i]->onfire)
                                                                         Person::players[i]->CatchFire();
@@ -2647,20 +2634,20 @@ void doPlayerCollisions()
                                                                 if (Person::players[0]->animTarget == rabbitkickanim && (k == 0 || i == 0) && !Person::players[0]->victim->skeleton.free)
                                                                     collisionradius = 3;
                                                             if ((!Person::players[i]->skeleton.oldfree || !Person::players[k]->skeleton.oldfree) &&
-                                                                    (distsq(&tempcoords1, &tempcoords2) < collisionradius ||
-                                                                     distsq(&Person::players[i]->coords, &Person::players[k]->coords) < collisionradius)) {
+                                                                (distsq(&tempcoords1, &tempcoords2) < collisionradius ||
+                                                                 distsq(&Person::players[i]->coords, &Person::players[k]->coords) < collisionradius)) {
                                                                 //jump down on a dead body
                                                                 if (k == 0 || i == 0) {
                                                                     int l = i ? i : k;
                                                                     if (Person::players[0]->animTarget == jumpdownanim &&
-                                                                            !Person::players[0]->skeleton.oldfree &&
-                                                                            !Person::players[0]->skeleton.free &&
-                                                                            Person::players[l]->skeleton.oldfree &&
-                                                                            Person::players[l]->skeleton.free &&
-                                                                            Person::players[l]->dead &&
-                                                                            Person::players[0]->lastcollide <= 0 &&
-                                                                            fabs(Person::players[l]->coords.y - Person::players[0]->coords.y) < .2 &&
-                                                                            distsq(&Person::players[0]->coords, &Person::players[l]->coords) < .7 * sq((Person::players[l]->scale + Person::players[0]->scale) * 2.5)) {
+                                                                        !Person::players[0]->skeleton.oldfree &&
+                                                                        !Person::players[0]->skeleton.free &&
+                                                                        Person::players[l]->skeleton.oldfree &&
+                                                                        Person::players[l]->skeleton.free &&
+                                                                        Person::players[l]->dead &&
+                                                                        Person::players[0]->lastcollide <= 0 &&
+                                                                        fabs(Person::players[l]->coords.y - Person::players[0]->coords.y) < .2 &&
+                                                                        distsq(&Person::players[0]->coords, &Person::players[l]->coords) < .7 * sq((Person::players[l]->scale + Person::players[0]->scale) * 2.5)) {
                                                                         Person::players[0]->coords.y = Person::players[l]->coords.y;
                                                                         Person::players[l]->velocity = Person::players[0]->velocity;
                                                                         Person::players[l]->skeleton.free = 0;
@@ -2673,28 +2660,28 @@ void doPlayerCollisions()
                                                                     }
                                                                 }
 
-                                                                if (     (Person::players[i]->skeleton.oldfree == 1 && findLengthfast(&Person::players[i]->velocity) > 1) ||
-                                                                         (Person::players[k]->skeleton.oldfree == 1 && findLengthfast(&Person::players[k]->velocity) > 1) ||
-                                                                         (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0)) {
+                                                                if ((Person::players[i]->skeleton.oldfree == 1 && findLengthfast(&Person::players[i]->velocity) > 1) ||
+                                                                    (Person::players[k]->skeleton.oldfree == 1 && findLengthfast(&Person::players[k]->velocity) > 1) ||
+                                                                    (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0)) {
                                                                     rotatetarget = Person::players[k]->velocity - Person::players[i]->velocity;
                                                                     if ((Person::players[i]->animTarget != getupfrombackanim && Person::players[i]->animTarget != getupfromfrontanim ||
-                                                                            Person::players[i]->skeleton.free) &&
-                                                                            (Person::players[k]->animTarget != getupfrombackanim && Person::players[k]->animTarget != getupfromfrontanim ||
-                                                                             Person::players[k]->skeleton.free))
+                                                                         Person::players[i]->skeleton.free) &&
+                                                                        (Person::players[k]->animTarget != getupfrombackanim && Person::players[k]->animTarget != getupfromfrontanim ||
+                                                                         Person::players[k]->skeleton.free))
                                                                         if ((((k != 0 && findLengthfast(&rotatetarget) > 150 ||
-                                                                                k == 0 && findLengthfast(&rotatetarget) > 50 && Person::players[0]->rabbitkickragdoll) &&
-                                                                                normaldotproduct(rotatetarget, Person::players[k]->coords - Person::players[i]->coords) > 0) &&
-                                                                                (k == 0 ||
-                                                                                 k != 0 && Person::players[i]->skeleton.oldfree == 1 && Animation::animations[Person::players[k]->animCurrent].attack == neutral ||
-                                                                                 /*i!=0&&*/Person::players[k]->skeleton.oldfree == 1 && Animation::animations[Person::players[i]->animCurrent].attack == neutral)) ||
-                                                                                (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) &&
+                                                                               k == 0 && findLengthfast(&rotatetarget) > 50 && Person::players[0]->rabbitkickragdoll) &&
+                                                                              normaldotproduct(rotatetarget, Person::players[k]->coords - Person::players[i]->coords) > 0) &&
+                                                                             (k == 0 ||
+                                                                              k != 0 && Person::players[i]->skeleton.oldfree == 1 && Animation::animations[Person::players[k]->animCurrent].attack == neutral ||
+                                                                              /*i!=0&&*/ Person::players[k]->skeleton.oldfree == 1 && Animation::animations[Person::players[i]->animCurrent].attack == neutral)) ||
+                                                                            (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) &&
                                                                                 (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) &&
                                                                                 k == 0 && !Person::players[i]->skeleton.oldfree && !Person::players[k]->skeleton.oldfree) {
                                                                             //If hit by body
-                                                                            if (     (i != 0 || Person::players[i]->skeleton.free) &&
-                                                                                     (k != 0 || Person::players[k]->skeleton.free) ||
-                                                                                     (Animation::animations[Person::players[i]->animTarget].height == highheight &&
-                                                                                      Animation::animations[Person::players[k]->animTarget].height == highheight)) {
+                                                                            if ((i != 0 || Person::players[i]->skeleton.free) &&
+                                                                                    (k != 0 || Person::players[k]->skeleton.free) ||
+                                                                                (Animation::animations[Person::players[i]->animTarget].height == highheight &&
+                                                                                 Animation::animations[Person::players[k]->animTarget].height == highheight)) {
                                                                                 if (!Tutorial::active) {
                                                                                     emit_sound_at(heavyimpactsound, Person::players[i]->coords);
                                                                                 }
@@ -2716,21 +2703,19 @@ void doPlayerCollisions()
                                                                                 for (unsigned j = 0; j < Person::players[k]->skeleton.joints.size(); j++) {
                                                                                     Person::players[k]->skeleton.joints[j].velocity = Person::players[k]->skeleton.joints[j].velocity / 5 + Person::players[i]->velocity;
                                                                                 }
-
                                                                             }
                                                                         }
-                                                                    if (     (Animation::animations[Person::players[i]->animTarget].attack == neutral ||
-                                                                              Animation::animations[Person::players[i]->animTarget].attack == normalattack) &&
-                                                                             (Animation::animations[Person::players[k]->animTarget].attack == neutral ||
-                                                                              Animation::animations[Person::players[k]->animTarget].attack == normalattack)) {
+                                                                    if ((Animation::animations[Person::players[i]->animTarget].attack == neutral ||
+                                                                         Animation::animations[Person::players[i]->animTarget].attack == normalattack) &&
+                                                                        (Animation::animations[Person::players[k]->animTarget].attack == neutral ||
+                                                                         Animation::animations[Person::players[k]->animTarget].attack == normalattack)) {
                                                                         //If bumped
                                                                         if (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0) {
                                                                             if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < .5 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
                                                                                 rotatetarget = Person::players[k]->coords - Person::players[i]->coords;
                                                                                 Normalise(&rotatetarget);
                                                                                 Person::players[k]->coords = (Person::players[k]->coords + Person::players[i]->coords) / 2;
-                                                                                Person::players[i]->coords = Person::players[k]->coords - rotatetarget * fast_sqrt(.6) / 2
-                                                                                                   * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
+                                                                                Person::players[i]->coords = Person::players[k]->coords - rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
                                                                                 Person::players[k]->coords += rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
                                                                                 if (Person::players[k]->howactive == typeactive || hostile)
                                                                                     if (Person::players[k]->isIdle()) {
@@ -2754,12 +2739,11 @@ void doPlayerCollisions()
                                                                             //jump down on player
                                                                             if (hostile) {
                                                                                 if (k == 0 && i != 0 && Person::players[k]->animTarget == jumpdownanim &&
-                                                                                        !Person::players[i]->isCrouch() &&
-                                                                                        Person::players[i]->animTarget != rollanim &&
-                                                                                        !Person::players[k]->skeleton.oldfree && !
-                                                                                        Person::players[k]->skeleton.free &&
-                                                                                        Person::players[k]->lastcollide <= 0 &&
-                                                                                        Person::players[k]->velocity.y < -10) {
+                                                                                    !Person::players[i]->isCrouch() &&
+                                                                                    Person::players[i]->animTarget != rollanim &&
+                                                                                    !Person::players[k]->skeleton.oldfree && !Person::players[k]->skeleton.free &&
+                                                                                    Person::players[k]->lastcollide <= 0 &&
+                                                                                    Person::players[k]->velocity.y < -10) {
                                                                                     Person::players[i]->velocity = Person::players[k]->velocity;
                                                                                     Person::players[k]->velocity = Person::players[k]->velocity * -.5;
                                                                                     Person::players[k]->velocity.y = Person::players[i]->velocity.y;
@@ -2769,12 +2753,12 @@ void doPlayerCollisions()
                                                                                     award_bonus(k, AboveBonus);
                                                                                 }
                                                                                 if (i == 0 && k != 0 && Person::players[i]->animTarget == jumpdownanim &&
-                                                                                        !Person::players[k]->isCrouch() &&
-                                                                                        Person::players[k]->animTarget != rollanim &&
-                                                                                        !Person::players[i]->skeleton.oldfree &&
-                                                                                        !Person::players[i]->skeleton.free &&
-                                                                                        Person::players[i]->lastcollide <= 0 &&
-                                                                                        Person::players[i]->velocity.y < -10) {
+                                                                                    !Person::players[k]->isCrouch() &&
+                                                                                    Person::players[k]->animTarget != rollanim &&
+                                                                                    !Person::players[i]->skeleton.oldfree &&
+                                                                                    !Person::players[i]->skeleton.free &&
+                                                                                    Person::players[i]->lastcollide <= 0 &&
+                                                                                    Person::players[i]->velocity.y < -10) {
                                                                                     Person::players[k]->velocity = Person::players[i]->velocity;
                                                                                     Person::players[i]->velocity = Person::players[i]->velocity * -.3;
                                                                                     Person::players[i]->velocity.y = Person::players[k]->velocity.y;
@@ -2829,7 +2813,6 @@ void Game::Tick()
         printf("Stereo separation increased to %f\n", stereoseparation);
     }
 
-
     if (Input::isKeyPressed(SDL_SCANCODE_TAB) && Tutorial::active) {
         if (Tutorial::stage != 51) {
             Tutorial::stagetime = Tutorial::maxtime;
@@ -2873,7 +2856,7 @@ void Game::Tick()
         }
         //escape key pressed
         if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
-                (gameon || mainmenu == 0)) {
+            (gameon || mainmenu == 0)) {
             selected = -1;
             if (mainmenu == 0 && !winfreeze)
                 mainmenu = 2; //pause
@@ -2969,8 +2952,6 @@ void Game::Tick()
             }
         }
 
-
-
         if (!freeze && !winfreeze && !(mainmenu && gameon) && (gameon || !gamestarted)) {
 
             //dialogues
@@ -3027,11 +3008,11 @@ void Game::Tick()
             //bonuses
             if (!Tutorial::active) {
                 if (bonustime == 0 &&
-                        bonus != solidhit &&
-                        bonus != spinecrusher &&
-                        bonus != tracheotomy &&
-                        bonus != backstab &&
-                        bonusvalue > 10) {
+                    bonus != solidhit &&
+                    bonus != spinecrusher &&
+                    bonus != tracheotomy &&
+                    bonus != backstab &&
+                    bonusvalue > 10) {
                     emit_sound_np(consolesuccesssound);
                 }
             } else if (bonustime == 0) {
@@ -3039,10 +3020,10 @@ void Game::Tick()
             }
             if (bonustime == 0) {
                 if (bonus != solidhit &&
-                        bonus != twoxcombo &&
-                        bonus != threexcombo &&
-                        bonus != fourxcombo &&
-                        bonus != megacombo)
+                    bonus != twoxcombo &&
+                    bonus != threexcombo &&
+                    bonus != fourxcombo &&
+                    bonus != megacombo)
                     bonusnum[bonus]++;
                 else
                     bonusnum[bonus] += 0.15;
@@ -3071,10 +3052,8 @@ void Game::Tick()
                 }
             }
 
-
             doAerialAcrobatics();
 
-
             static XYZ oldviewer;
 
             //control keys
@@ -3101,7 +3080,6 @@ void Game::Tick()
             if (!Person::players[0]->jumpkeydown)
                 Person::players[0]->jumpclimb = 0;
 
-
             if (Dialog::inDialog()) {
                 cameramode = 1;
                 if (Dialog::directing) {
@@ -3128,28 +3106,38 @@ void Game::Tick()
                         viewer.y += multiplier * 4;
                     if (Input::isKeyDown(crouchkey))
                         viewer.y -= multiplier * 4;
-                    if (     Input::isKeyPressed(SDL_SCANCODE_1) ||
-                             Input::isKeyPressed(SDL_SCANCODE_2) ||
-                             Input::isKeyPressed(SDL_SCANCODE_3) ||
-                             Input::isKeyPressed(SDL_SCANCODE_4) ||
-                             Input::isKeyPressed(SDL_SCANCODE_5) ||
-                             Input::isKeyPressed(SDL_SCANCODE_6) ||
-                             Input::isKeyPressed(SDL_SCANCODE_7) ||
-                             Input::isKeyPressed(SDL_SCANCODE_8) ||
-                             Input::isKeyPressed(SDL_SCANCODE_9) ||
-                             Input::isKeyPressed(SDL_SCANCODE_0) ||
-                             Input::isKeyPressed(SDL_SCANCODE_MINUS)) {
+                    if (Input::isKeyPressed(SDL_SCANCODE_1) ||
+                        Input::isKeyPressed(SDL_SCANCODE_2) ||
+                        Input::isKeyPressed(SDL_SCANCODE_3) ||
+                        Input::isKeyPressed(SDL_SCANCODE_4) ||
+                        Input::isKeyPressed(SDL_SCANCODE_5) ||
+                        Input::isKeyPressed(SDL_SCANCODE_6) ||
+                        Input::isKeyPressed(SDL_SCANCODE_7) ||
+                        Input::isKeyPressed(SDL_SCANCODE_8) ||
+                        Input::isKeyPressed(SDL_SCANCODE_9) ||
+                        Input::isKeyPressed(SDL_SCANCODE_0) ||
+                        Input::isKeyPressed(SDL_SCANCODE_MINUS)) {
                         int whichend;
-                        if (Input::isKeyPressed(SDL_SCANCODE_1)) whichend = 1;
-                        if (Input::isKeyPressed(SDL_SCANCODE_2)) whichend = 2;
-                        if (Input::isKeyPressed(SDL_SCANCODE_3)) whichend = 3;
-                        if (Input::isKeyPressed(SDL_SCANCODE_4)) whichend = 4;
-                        if (Input::isKeyPressed(SDL_SCANCODE_5)) whichend = 5;
-                        if (Input::isKeyPressed(SDL_SCANCODE_6)) whichend = 6;
-                        if (Input::isKeyPressed(SDL_SCANCODE_7)) whichend = 7;
-                        if (Input::isKeyPressed(SDL_SCANCODE_8)) whichend = 8;
-                        if (Input::isKeyPressed(SDL_SCANCODE_9)) whichend = 9;
-                        if (Input::isKeyPressed(SDL_SCANCODE_0)) whichend = 0;
+                        if (Input::isKeyPressed(SDL_SCANCODE_1))
+                            whichend = 1;
+                        if (Input::isKeyPressed(SDL_SCANCODE_2))
+                            whichend = 2;
+                        if (Input::isKeyPressed(SDL_SCANCODE_3))
+                            whichend = 3;
+                        if (Input::isKeyPressed(SDL_SCANCODE_4))
+                            whichend = 4;
+                        if (Input::isKeyPressed(SDL_SCANCODE_5))
+                            whichend = 5;
+                        if (Input::isKeyPressed(SDL_SCANCODE_6))
+                            whichend = 6;
+                        if (Input::isKeyPressed(SDL_SCANCODE_7))
+                            whichend = 7;
+                        if (Input::isKeyPressed(SDL_SCANCODE_8))
+                            whichend = 8;
+                        if (Input::isKeyPressed(SDL_SCANCODE_9))
+                            whichend = 9;
+                        if (Input::isKeyPressed(SDL_SCANCODE_0))
+                            whichend = 0;
                         if (Input::isKeyPressed(SDL_SCANCODE_MINUS))
                             whichend = -1;
                         if (whichend != -1) {
@@ -3181,27 +3169,37 @@ void Game::Tick()
                         }
                     }
                     //TODO: should these be KeyDown or KeyPressed?
-                    if (     Input::isKeyDown(SDL_SCANCODE_KP_1) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_2) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_3) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_4) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_5) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_6) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_7) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_8) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_9) ||
-                             Input::isKeyDown(SDL_SCANCODE_KP_0)) {
+                    if (Input::isKeyDown(SDL_SCANCODE_KP_1) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_2) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_3) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_4) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_5) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_6) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_7) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_8) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_9) ||
+                        Input::isKeyDown(SDL_SCANCODE_KP_0)) {
                         int whichend;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_1)) whichend = 1;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_2)) whichend = 2;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_3)) whichend = 3;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_4)) whichend = 4;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_5)) whichend = 5;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_6)) whichend = 6;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_7)) whichend = 7;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_8)) whichend = 8;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_9)) whichend = 9;
-                        if (Input::isKeyDown(SDL_SCANCODE_KP_0)) whichend = 0;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_1))
+                            whichend = 1;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_2))
+                            whichend = 2;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_3))
+                            whichend = 3;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_4))
+                            whichend = 4;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_5))
+                            whichend = 5;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_6))
+                            whichend = 6;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_7))
+                            whichend = 7;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_8))
+                            whichend = 8;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_9))
+                            whichend = 9;
+                        if (Input::isKeyDown(SDL_SCANCODE_KP_0))
+                            whichend = 0;
                         Dialog::currentScene().participantfacing[whichend] = facing;
                     }
                     if (Dialog::indialogue >= int(Dialog::currentDialog().scenes.size())) {
@@ -3262,12 +3260,11 @@ void Game::Tick()
                 Person::players[0]->jumptogglekeydown = 0;
             }
             if (Person::players[0]->jumpkeydown &&
-                    Person::players[0]->animTarget != jumpupanim &&
-                    Person::players[0]->animTarget != jumpdownanim &&
-                    !Person::players[0]->isFlip())
+                Person::players[0]->animTarget != jumpupanim &&
+                Person::players[0]->animTarget != jumpdownanim &&
+                !Person::players[0]->isFlip())
                 Person::players[0]->jumptogglekeydown = 1;
 
-
             Dialog::dialoguetime += multiplier;
             hawkyaw += multiplier * 25;
             realhawkcoords = 0;
@@ -3304,21 +3301,20 @@ void Game::Tick()
             //respawn
             static bool respawnkeydown;
             if (!editorenabled &&
-                    (whichlevel != -2 &&
+                (whichlevel != -2 &&
                      (Input::isKeyDown(SDL_SCANCODE_Z) &&
                       Input::isKeyDown(SDL_SCANCODE_LGUI) &&
                       devtools) ||
-                     (Input::isKeyDown(jumpkey) &&
-                      !respawnkeydown &&
-                      !oldattackkey &&
-                      Person::players[0]->dead))) {
+                 (Input::isKeyDown(jumpkey) &&
+                  !respawnkeydown &&
+                  !oldattackkey &&
+                  Person::players[0]->dead))) {
                 targetlevel = whichlevel;
                 loading = 1;
                 leveltime = 5;
             }
             respawnkeydown = Input::isKeyDown(jumpkey);
 
-
             static bool movekey;
 
             //?
@@ -3329,14 +3325,14 @@ void Game::Tick()
                     if (i == 0 && !Dialog::inDialog()) {
                         //TODO: refactor repetitive code
                         if (!Animation::animations[Person::players[0]->animTarget].attack &&
-                                Person::players[0]->animTarget != staggerbackhighanim &&
-                                Person::players[0]->animTarget != staggerbackhardanim &&
-                                Person::players[0]->animTarget != crouchremoveknifeanim &&
-                                Person::players[0]->animTarget != removeknifeanim &&
-                                Person::players[0]->animTarget != backhandspringanim &&
-                                Person::players[0]->animTarget != dodgebackanim &&
-                                Person::players[0]->animTarget != walljumprightkickanim &&
-                                Person::players[0]->animTarget != walljumpleftkickanim) {
+                            Person::players[0]->animTarget != staggerbackhighanim &&
+                            Person::players[0]->animTarget != staggerbackhardanim &&
+                            Person::players[0]->animTarget != crouchremoveknifeanim &&
+                            Person::players[0]->animTarget != removeknifeanim &&
+                            Person::players[0]->animTarget != backhandspringanim &&
+                            Person::players[0]->animTarget != dodgebackanim &&
+                            Person::players[0]->animTarget != walljumprightkickanim &&
+                            Person::players[0]->animTarget != walljumpleftkickanim) {
                             if (cameramode)
                                 Person::players[0]->targetyaw = 0;
                             else
@@ -3361,14 +3357,14 @@ void Game::Tick()
                     }
                     if (i != 0 && Person::players[i]->aitype == playercontrolled && !Dialog::inDialog()) {
                         if (!Animation::animations[Person::players[i]->animTarget].attack &&
-                                Person::players[i]->animTarget != staggerbackhighanim &&
-                                Person::players[i]->animTarget != staggerbackhardanim &&
-                                Person::players[i]->animTarget != crouchremoveknifeanim &&
-                                Person::players[i]->animTarget != removeknifeanim &&
-                                Person::players[i]->animTarget != backhandspringanim &&
-                                Person::players[i]->animTarget != dodgebackanim &&
-                                Person::players[i]->animTarget != walljumprightkickanim &&
-                                Person::players[i]->animTarget != walljumpleftkickanim) {
+                            Person::players[i]->animTarget != staggerbackhighanim &&
+                            Person::players[i]->animTarget != staggerbackhardanim &&
+                            Person::players[i]->animTarget != crouchremoveknifeanim &&
+                            Person::players[i]->animTarget != removeknifeanim &&
+                            Person::players[i]->animTarget != backhandspringanim &&
+                            Person::players[i]->animTarget != dodgebackanim &&
+                            Person::players[i]->animTarget != walljumprightkickanim &&
+                            Person::players[i]->animTarget != walljumpleftkickanim) {
                             Person::players[i]->targetyaw = -Person::players[i]->lookyaw + 180;
                         }
 
@@ -3397,12 +3393,12 @@ void Game::Tick()
                     for (unsigned int j = 0; j < Object::objects.size(); j++)
                         if (Object::objects[j]->onfire)
                             if (distsq(&Person::players[i]->coords, &Object::objects[j]->position) < sq(Object::objects[j]->scale) * 200)
-                                if (     distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
-                                         distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
+                                if (distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
+                                    distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
                                     Person::players[i]->collided = 0;
                                     Person::players[i]->avoidcollided = 1;
                                     if (Person::players[i]->avoidsomething == 0 ||
-                                            distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
+                                        distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
                                         Person::players[i]->avoidwhere = Object::objects[j]->position;
                                         Person::players[i]->avoidsomething = 1;
@@ -3413,12 +3409,12 @@ void Game::Tick()
                     for (unsigned j = 0; j < Person::players.size(); j++)
                         if (Person::players[j]->onfire)
                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < sq(0.3) * 200)
-                                if (     distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
-                                         distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
+                                if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
+                                    distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
                                     Person::players[i]->collided = 0;
                                     Person::players[i]->avoidcollided = 1;
                                     if (Person::players[i]->avoidsomething == 0 ||
-                                            distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
+                                        distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
                                         Person::players[i]->avoidwhere = Person::players[j]->coords;
                                         Person::players[i]->avoidsomething = 1;
@@ -3472,10 +3468,10 @@ void Game::Tick()
                         Person::players[i]->surprised -= multiplier;
                     }
                     if (i != 0 && Person::players[i]->surprised <= 0 &&
-                            Person::players[i]->aitype == attacktypecutoff &&
-                            !Person::players[i]->dead &&
-                            !Person::players[i]->skeleton.free &&
-                            Animation::animations[Person::players[i]->animTarget].attack == neutral)
+                        Person::players[i]->aitype == attacktypecutoff &&
+                        !Person::players[i]->dead &&
+                        !Person::players[i]->skeleton.free &&
+                        Animation::animations[Person::players[i]->animTarget].attack == neutral)
                         numresponded = 1;
 
                     if (!Person::players[i]->throwkeydown)
@@ -3484,26 +3480,26 @@ void Game::Tick()
                     //pick up weapon
                     if (Person::players[i]->throwkeydown && !Person::players[i]->throwtogglekeydown) {
                         if (Person::players[i]->weaponactive == -1 &&
-                                Person::players[i]->num_weapons < 2 &&
-                                (Person::players[i]->isIdle() ||
-                                 Person::players[i]->isCrouch() ||
-                                 Person::players[i]->animTarget == sneakanim ||
-                                 Person::players[i]->animTarget == rollanim ||
-                                 Person::players[i]->animTarget == backhandspringanim ||
-                                 Person::players[i]->isFlip() ||
-                                 Person::players[i]->aitype != playercontrolled)) {
+                            Person::players[i]->num_weapons < 2 &&
+                            (Person::players[i]->isIdle() ||
+                             Person::players[i]->isCrouch() ||
+                             Person::players[i]->animTarget == sneakanim ||
+                             Person::players[i]->animTarget == rollanim ||
+                             Person::players[i]->animTarget == backhandspringanim ||
+                             Person::players[i]->isFlip() ||
+                             Person::players[i]->aitype != playercontrolled)) {
                             for (unsigned j = 0; j < weapons.size(); j++) {
                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
-                                        Person::players[i]->aitype == playercontrolled) &&
-                                        weapons[j].owner == -1 &&
-                                        Person::players[i]->weaponactive == -1)
+                                     Person::players[i]->aitype == playercontrolled) &&
+                                    weapons[j].owner == -1 &&
+                                    Person::players[i]->weaponactive == -1)
                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2) {
                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 2) {
                                             if (Person::players[i]->isCrouch() ||
-                                                    Person::players[i]->animTarget == sneakanim ||
-                                                    Person::players[i]->isRun() ||
-                                                    Person::players[i]->isIdle() ||
-                                                    Person::players[i]->aitype != playercontrolled) {
+                                                Person::players[i]->animTarget == sneakanim ||
+                                                Person::players[i]->isRun() ||
+                                                Person::players[i]->isIdle() ||
+                                                Person::players[i]->aitype != playercontrolled) {
                                                 Person::players[i]->throwtogglekeydown = 1;
                                                 Person::players[i]->setTargetAnimation(crouchremoveknifeanim);
                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
@@ -3514,9 +3510,9 @@ void Game::Tick()
                                                 Person::players[i]->hasvictim = 0;
 
                                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
-                                                        Person::players[i]->aitype == playercontrolled) &&
+                                                     Person::players[i]->aitype == playercontrolled) &&
                                                         weapons[j].owner == -1 ||
-                                                        Person::players[i]->victim &&
+                                                    Person::players[i]->victim &&
                                                         weapons[j].owner == int(Person::players[i]->victim->id))
                                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2 && Person::players[i]->weaponactive == -1)
                                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 1 || Person::players[i]->victim) {
@@ -3543,12 +3539,12 @@ void Game::Tick()
                                                 for (unsigned k = 0; k < weapons.size(); k++) {
                                                     if (Person::players[i]->weaponactive == -1)
                                                         if ((weapons[k].velocity.x == 0 && weapons[k].velocity.y == 0 && weapons[k].velocity.z == 0 ||
-                                                                Person::players[i]->aitype == playercontrolled) &&
+                                                             Person::players[i]->aitype == playercontrolled) &&
                                                                 weapons[k].owner == -1 ||
-                                                                Person::players[i]->victim &&
+                                                            Person::players[i]->victim &&
                                                                 weapons[k].owner == int(Person::players[i]->victim->id))
                                                             if (distsqflat(&Person::players[i]->coords, &weapons[k].position) < 3 &&
-                                                                    Person::players[i]->weaponactive == -1) {
+                                                                Person::players[i]->weaponactive == -1) {
                                                                 if (weapons[k].getType() != staff)
                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
 
@@ -3560,23 +3556,23 @@ void Game::Tick()
                                     }
                             }
                             if (Person::players[i]->isCrouch() ||
-                                    Person::players[i]->animTarget == sneakanim ||
-                                    Person::players[i]->isRun() ||
-                                    Person::players[i]->isIdle() || Person::players[i]->animTarget == rollanim ||
-                                    Person::players[i]->animTarget == backhandspringanim) {
+                                Person::players[i]->animTarget == sneakanim ||
+                                Person::players[i]->isRun() ||
+                                Person::players[i]->isIdle() || Person::players[i]->animTarget == rollanim ||
+                                Person::players[i]->animTarget == backhandspringanim) {
                                 if (Person::players.size() > 1)
                                     for (unsigned j = 0; j < Person::players.size(); j++) {
                                         if (Person::players[i]->weaponactive == -1)
                                             if (j != i)
                                                 if (Person::players[j]->num_weapons &&
-                                                        Person::players[j]->skeleton.free &&
-                                                        distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 2/*&&Person::players[j]->dead*/ &&
-                                                        (((Person::players[j]->skeleton.forward.y < 0 &&
-                                                           Person::players[j]->weaponstuckwhere == 0) ||
-                                                          (Person::players[j]->skeleton.forward.y > 0 &&
-                                                           Person::players[j]->weaponstuckwhere == 1)) ||
-                                                         Person::players[j]->weaponstuck == -1 ||
-                                                         Person::players[j]->num_weapons > 1)) {
+                                                    Person::players[j]->skeleton.free &&
+                                                    distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 2 /*&&Person::players[j]->dead*/ &&
+                                                    (((Person::players[j]->skeleton.forward.y < 0 &&
+                                                       Person::players[j]->weaponstuckwhere == 0) ||
+                                                      (Person::players[j]->skeleton.forward.y > 0 &&
+                                                       Person::players[j]->weaponstuckwhere == 1)) ||
+                                                     Person::players[j]->weaponstuck == -1 ||
+                                                     Person::players[j]->num_weapons > 1)) {
                                                     if (Person::players[i]->animTarget != rollanim && Person::players[i]->animTarget != backhandspringanim) {
                                                         Person::players[i]->throwtogglekeydown = 1;
                                                         Person::players[i]->victim = Person::players[j];
@@ -3661,20 +3657,20 @@ void Game::Tick()
                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
                             if (weapons[Person::players[i]->weaponids[0]].getType() == knife) {
                                 if (Person::players[i]->isIdle() ||
-                                        Person::players[i]->isRun() ||
-                                        Person::players[i]->isCrouch() ||
-                                        Person::players[i]->animTarget == sneakanim ||
-                                        Person::players[i]->isFlip())
+                                    Person::players[i]->isRun() ||
+                                    Person::players[i]->isCrouch() ||
+                                    Person::players[i]->animTarget == sneakanim ||
+                                    Person::players[i]->isFlip())
                                     if (Person::players.size() > 1)
                                         for (unsigned j = 0; j < Person::players.size(); j++) {
                                             if (i != j)
                                                 if (!Tutorial::active || Tutorial::stage == 49)
                                                     if (hostile)
                                                         if (normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0 &&
-                                                                distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
-                                                                distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
-                                                                !Person::players[j]->skeleton.free &&
-                                                                -1 == Object::checkcollide(DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*Person::players[j]->scale + Person::players[j]->coords, DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*Person::players[i]->scale + Person::players[i]->coords)) {
+                                                            distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
+                                                            distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
+                                                            !Person::players[j]->skeleton.free &&
+                                                            -1 == Object::checkcollide(DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0) * Person::players[j]->scale + Person::players[j]->coords, DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0) * Person::players[i]->scale + Person::players[i]->coords)) {
                                                             if (!Person::players[i]->isFlip()) {
                                                                 Person::players[i]->throwtogglekeydown = 1;
                                                                 Person::players[i]->victim = Person::players[j];
@@ -3724,16 +3720,15 @@ void Game::Tick()
                                 }
                             }
                         }
-
                     }
 
                     //draw weapon
                     if (i == 0 || !Person::players[0]->dead || (Person::players[i]->weaponactive != -1)) {
                         if (Person::players[i]->drawkeydown && !Person::players[i]->drawtogglekeydown ||
-                                (Person::players[i]->num_weapons == 2) &&
+                            (Person::players[i]->num_weapons == 2) &&
                                 (Person::players[i]->weaponactive == -1) &&
                                 Person::players[i]->isIdle() ||
-                                Person::players[0]->dead &&
+                            Person::players[0]->dead &&
                                 (Person::players[i]->weaponactive != -1) &&
                                 i != 0) {
                             bool isgood = true;
@@ -3746,11 +3741,11 @@ void Game::Tick()
                                     Person::players[i]->drawtogglekeydown = 1;
                                 }
                                 if ((Person::players[i]->isIdle() ||
-                                        (Person::players[i]->aitype != playercontrolled &&
-                                         Person::players[0]->weaponactive != -1 &&
-                                         Person::players[i]->isRun())) &&
-                                        Person::players[i]->num_weapons &&
-                                        weapons[Person::players[i]->weaponids[0]].getType() == sword) {
+                                     (Person::players[i]->aitype != playercontrolled &&
+                                      Person::players[0]->weaponactive != -1 &&
+                                      Person::players[i]->isRun())) &&
+                                    Person::players[i]->num_weapons &&
+                                    weapons[Person::players[i]->weaponids[0]].getType() == sword) {
                                     Person::players[i]->setTargetAnimation(drawleftanim);
                                     Person::players[i]->drawtogglekeydown = 1;
                                 }
@@ -3765,12 +3760,12 @@ void Game::Tick()
                     //clean weapon
                     if (Person::players[i]->weaponactive != -1) {
                         if (Person::players[i]->isCrouch() &&
-                                weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
-                                bloodtoggle &&
-                                Person::players[i]->onterrain &&
-                                Person::players[i]->num_weapons &&
-                                Person::players[i]->attackkeydown &&
-                                musictype != stream_fighttheme) {
+                            weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
+                            bloodtoggle &&
+                            Person::players[i]->onterrain &&
+                            Person::players[i]->num_weapons &&
+                            Person::players[i]->attackkeydown &&
+                            musictype != stream_fighttheme) {
                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == knife)
                                 Person::players[i]->setTargetAnimation(crouchstabanim);
                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == sword)
@@ -3804,10 +3799,10 @@ void Game::Tick()
                     movekey = 0;
                     //Do controls
                     if (!Animation::animations[Person::players[i]->animTarget].attack &&
-                            Person::players[i]->animTarget != staggerbackhighanim &&
-                            Person::players[i]->animTarget != staggerbackhardanim &&
-                            Person::players[i]->animTarget != backhandspringanim &&
-                            Person::players[i]->animTarget != dodgebackanim) {
+                        Person::players[i]->animTarget != staggerbackhighanim &&
+                        Person::players[i]->animTarget != staggerbackhardanim &&
+                        Person::players[i]->animTarget != backhandspringanim &&
+                        Person::players[i]->animTarget != dodgebackanim) {
                         if (!Person::players[i]->forwardkeydown)
                             Person::players[i]->forwardstogglekeydown = 0;
                         if (Person::players[i]->crouchkeydown) {
@@ -3826,15 +3821,15 @@ void Game::Tick()
                                 for (unsigned j = 0; j < Person::players.size(); j++) {
                                     if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim && Person::players[i]->lowreversaldelay <= 0) {
                                         if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
-                                                Person::players[j]->victim == Person::players[i] &&
-                                                (Person::players[j]->animTarget == sweepanim ||
-                                                 Person::players[j]->animTarget == upunchanim ||
-                                                 Person::players[j]->animTarget == wolfslapanim ||
-                                                 ((Person::players[j]->animTarget == swordslashanim ||
-                                                   Person::players[j]->animTarget == knifeslashstartanim ||
-                                                   Person::players[j]->animTarget == staffhitanim ||
-                                                   Person::players[j]->animTarget == staffspinhitanim) &&
-                                                  distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2))) {
+                                            Person::players[j]->victim == Person::players[i] &&
+                                            (Person::players[j]->animTarget == sweepanim ||
+                                             Person::players[j]->animTarget == upunchanim ||
+                                             Person::players[j]->animTarget == wolfslapanim ||
+                                             ((Person::players[j]->animTarget == swordslashanim ||
+                                               Person::players[j]->animTarget == knifeslashstartanim ||
+                                               Person::players[j]->animTarget == staffhitanim ||
+                                               Person::players[j]->animTarget == staffspinhitanim) &&
+                                              distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2))) {
                                             if (target >= 0)
                                                 target = -1;
                                             else
@@ -3851,11 +3846,11 @@ void Game::Tick()
                                 Person::players[i]->transspeed = 10;
                             }
                             if (Person::players[i]->isRun() ||
-                                    (Person::players[i]->isStop() &&
-                                     (Person::players[i]->leftkeydown ||
-                                      Person::players[i]->rightkeydown ||
-                                      Person::players[i]->forwardkeydown ||
-                                      Person::players[i]->backkeydown))) {
+                                (Person::players[i]->isStop() &&
+                                 (Person::players[i]->leftkeydown ||
+                                  Person::players[i]->rightkeydown ||
+                                  Person::players[i]->forwardkeydown ||
+                                  Person::players[i]->backkeydown))) {
                                 Person::players[i]->setTargetAnimation(rollanim);
                                 Person::players[i]->transspeed = 20;
                             }
@@ -3869,13 +3864,13 @@ void Game::Tick()
                                 if (Person::players.size() > 1)
                                     for (unsigned j = 0; j < Person::players.size(); j++) {
                                         if (j != i &&
-                                                !Person::players[j]->skeleton.free &&
-                                                Person::players[j]->victim &&
-                                                Person::players[i]->highreversaldelay <= 0) {
+                                            !Person::players[j]->skeleton.free &&
+                                            Person::players[j]->victim &&
+                                            Person::players[i]->highreversaldelay <= 0) {
                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
-                                                    Person::players[j]->victim == Person::players[i] &&
-                                                    (Person::players[j]->animTarget == spinkickanim) &&
-                                                    Person::players[i]->isCrouch()) {
+                                                Person::players[j]->victim == Person::players[i] &&
+                                                (Person::players[j]->animTarget == spinkickanim) &&
+                                                Person::players[i]->isCrouch()) {
                                                 if (target >= 0)
                                                     target = -1;
                                                 else
@@ -3903,15 +3898,15 @@ void Game::Tick()
                         }
                         if (Person::players[i]->forwardkeydown) {
                             if (Person::players[i]->isIdle() ||
-                                    (Person::players[i]->isStop() &&
-                                     Person::players[i]->targetyaw == Person::players[i]->yaw) ||
-                                    (Person::players[i]->isLanding() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown) ||
-                                    (Person::players[i]->isLandhard() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown &&
-                                     Person::players[i]->crouchkeydown)) {
+                                (Person::players[i]->isStop() &&
+                                 Person::players[i]->targetyaw == Person::players[i]->yaw) ||
+                                (Person::players[i]->isLanding() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown) ||
+                                (Person::players[i]->isLandhard() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown &&
+                                 Person::players[i]->crouchkeydown)) {
                                 if (Person::players[i]->aitype == passivetype)
                                     Person::players[i]->setTargetAnimation(walkanim);
                                 else
@@ -3923,7 +3918,7 @@ void Game::Tick()
                                     Person::players[i]->target = 0;
                                 Person::players[i]->frameTarget = 0;
                             }
-                            if (Person::players[i]->animTarget == hanganim/*&&(!Person::players[i]->forwardstogglekeydown||Person::players[i]->aitype!=playercontrolled)*/) {
+                            if (Person::players[i]->animTarget == hanganim /*&&(!Person::players[i]->forwardstogglekeydown||Person::players[i]->aitype!=playercontrolled)*/) {
                                 Person::players[i]->setTargetAnimation(climbanim);
                                 Person::players[i]->frameTarget = 1;
                                 Person::players[i]->jumpclimb = 1;
@@ -3936,15 +3931,15 @@ void Game::Tick()
                         }
                         if (Person::players[i]->rightkeydown) {
                             if (Person::players[i]->isIdle() ||
-                                    (Person::players[i]->isStop() &&
-                                     Person::players[i]->targetyaw == Person::players[i]->yaw) ||
-                                    (Person::players[i]->isLanding() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown) ||
-                                    (Person::players[i]->isLandhard() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown &&
-                                     Person::players[i]->crouchkeydown)) {
+                                (Person::players[i]->isStop() &&
+                                 Person::players[i]->targetyaw == Person::players[i]->yaw) ||
+                                (Person::players[i]->isLanding() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown) ||
+                                (Person::players[i]->isLandhard() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown &&
+                                 Person::players[i]->crouchkeydown)) {
                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
                             }
                             if (Person::players[i]->isCrouch()) {
@@ -3963,17 +3958,17 @@ void Game::Tick()
                                 Person::players[i]->targetyaw -= 45;
                             movekey = 1;
                         }
-                        if ( Person::players[i]->leftkeydown) {
+                        if (Person::players[i]->leftkeydown) {
                             if (Person::players[i]->isIdle() ||
-                                    (Person::players[i]->isStop() &&
-                                     Person::players[i]->targetyaw == Person::players[i]->yaw) ||
-                                    (Person::players[i]->isLanding() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown) ||
-                                    (Person::players[i]->isLandhard() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown &&
-                                     Person::players[i]->crouchkeydown)) {
+                                (Person::players[i]->isStop() &&
+                                 Person::players[i]->targetyaw == Person::players[i]->yaw) ||
+                                (Person::players[i]->isLanding() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown) ||
+                                (Person::players[i]->isLandhard() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown &&
+                                 Person::players[i]->crouchkeydown)) {
                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
                             }
                             if (Person::players[i]->isCrouch()) {
@@ -3994,15 +3989,15 @@ void Game::Tick()
                         }
                         if (Person::players[i]->backkeydown) {
                             if (Person::players[i]->isIdle() ||
-                                    (Person::players[i]->isStop() &&
-                                     Person::players[i]->targetyaw == Person::players[i]->yaw) ||
-                                    (Person::players[i]->isLanding() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown) ||
-                                    (Person::players[i]->isLandhard() &&
-                                     Person::players[i]->frameTarget > 0 &&
-                                     !Person::players[i]->jumpkeydown &&
-                                     Person::players[i]->crouchkeydown)) {
+                                (Person::players[i]->isStop() &&
+                                 Person::players[i]->targetyaw == Person::players[i]->yaw) ||
+                                (Person::players[i]->isLanding() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown) ||
+                                (Person::players[i]->isLandhard() &&
+                                 Person::players[i]->frameTarget > 0 &&
+                                 !Person::players[i]->jumpkeydown &&
+                                 Person::players[i]->crouchkeydown)) {
                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
                             }
                             if (Person::players[i]->isCrouch()) {
@@ -4025,19 +4020,20 @@ void Game::Tick()
                                 Person::players[i]->coords.y -= 1.4;
                                 Person::players[i]->grabdelay = 1;
                             }
-                            if ( !Person::players[i]->leftkeydown && !Person::players[i]->rightkeydown)
+                            if (!Person::players[i]->leftkeydown && !Person::players[i]->rightkeydown)
                                 Person::players[i]->targetyaw += 180;
                             movekey = 1;
                         }
                         if ((Person::players[i]->jumpkeydown && !Person::players[i]->jumpclimb) || Person::players[i]->jumpstart) {
                             if ((((Person::players[i]->isLanding() && Person::players[i]->frameTarget >= 3) ||
-                                    Person::players[i]->isRun() ||
-                                    Person::players[i]->animTarget == walkanim ||
-                                    Person::players[i]->isCrouch() ||
-                                    Person::players[i]->animTarget == sneakanim) &&
-                                    Person::players[i]->jumppower > 1) &&
-                                    ((Person::players[i]->animTarget != rabbitrunninganim &&
-                                      Person::players[i]->animTarget != wolfrunninganim) || i != 0)) {
+                                  Person::players[i]->isRun() ||
+                                  Person::players[i]->animTarget == walkanim ||
+                                  Person::players[i]->isCrouch() ||
+                                  Person::players[i]->animTarget == sneakanim) &&
+                                 Person::players[i]->jumppower > 1) &&
+                                ((Person::players[i]->animTarget != rabbitrunninganim &&
+                                  Person::players[i]->animTarget != wolfrunninganim) ||
+                                 i != 0)) {
                                 Person::players[i]->jumpstart = 0;
                                 Person::players[i]->setTargetAnimation(jumpupanim);
                                 Person::players[i]->yaw = Person::players[i]->targetyaw;
@@ -4060,8 +4056,8 @@ void Game::Tick()
                                     for (unsigned j = 0; j < Person::players.size(); j++) {
                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim) {
                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
-                                                    (Person::players[j]->victim == Person::players[i]) &&
-                                                    (Person::players[j]->animTarget == sweepanim)) {
+                                                (Person::players[j]->victim == Person::players[i]) &&
+                                                (Person::players[j]->animTarget == sweepanim)) {
                                                 if (target >= 0)
                                                     target = -1;
                                                 else
@@ -4071,11 +4067,11 @@ void Game::Tick()
                                     }
                                 if (target >= 0)
                                     Person::players[i]->velocity.y = 1;
-                                else
-                                    if (Person::players[i]->crouchkeydown || Person::players[i]->aitype != playercontrolled) {
+                                else if (Person::players[i]->crouchkeydown || Person::players[i]->aitype != playercontrolled) {
                                     Person::players[i]->velocity.y = 7;
                                     Person::players[i]->crouchtogglekeydown = 1;
-                                } else Person::players[i]->velocity.y = 5;
+                                } else
+                                    Person::players[i]->velocity.y = 5;
 
                                 if (mousejump && i == 0 && devtools) {
                                     if (!Person::players[i]->isLanding())
@@ -4100,10 +4096,10 @@ void Game::Tick()
                                 Person::players[i]->tempdeltav = deltav;
                             }
                             if (Person::players[i]->animTarget == jumpupanim &&
-                                    (((!floatjump &&
-                                       !editorenabled) ||
-                                      !devtools) ||
-                                     Person::players[i]->aitype != playercontrolled)) {
+                                (((!floatjump &&
+                                   !editorenabled) ||
+                                  !devtools) ||
+                                 Person::players[i]->aitype != playercontrolled)) {
                                 if (Person::players[i]->jumppower > multiplier * 6) {
                                     Person::players[i]->velocity.y += multiplier * 6;
                                     Person::players[i]->jumppower -= multiplier * 6;
@@ -4130,10 +4126,10 @@ void Game::Tick()
                             }
                         }
                         if (Person::players[i]->animTarget == walkanim &&
-                                (Person::players[i]->aitype == attacktypecutoff ||
-                                 Person::players[i]->aitype == searchtype ||
-                                 (Person::players[i]->aitype == passivetype &&
-                                  Person::players[i]->numwaypoints <= 1)))
+                            (Person::players[i]->aitype == attacktypecutoff ||
+                             Person::players[i]->aitype == searchtype ||
+                             (Person::players[i]->aitype == passivetype &&
+                              Person::players[i]->numwaypoints <= 1)))
                             Person::players[i]->setTargetAnimation(Person::players[i]->getStop());
                         if (Person::players[i]->isRun() && (Person::players[i]->aitype == passivetype))
                             Person::players[i]->setTargetAnimation(Person::players[i]->getStop());
@@ -4160,9 +4156,9 @@ void Game::Tick()
                     Person::players[k]->targettilt = 0;
 
                 if (Person::players[k]->animTarget != jumpupanim &&
-                        Person::players[k]->animTarget != backhandspringanim &&
-                        Person::players[k]->animTarget != jumpdownanim &&
-                        !Person::players[k]->isFlip()) {
+                    Person::players[k]->animTarget != backhandspringanim &&
+                    Person::players[k]->animTarget != jumpdownanim &&
+                    !Person::players[k]->isFlip()) {
                     Person::players[k]->targettilt = 0;
                     if (Person::players[k]->jumppower < 0 && !Person::players[k]->jumpkeydown)
                         Person::players[k]->jumppower = 0;
@@ -4204,7 +4200,6 @@ void Game::Tick()
                 Tutorial::DoStuff(multiplier);
             }
 
-
             //3d sound
             static float gLoc[3];
             gLoc[0] = viewer.x;
@@ -4229,7 +4224,6 @@ void Game::Tick()
             facing = DoRotation(facing, -pitch, 0, 0);
             facing = DoRotation(facing, 0, 0 - yaw, 0);
 
-
             static float ori[6];
             ori[0] = -facing.x;
             ori[1] = facing.y;
@@ -4294,13 +4288,13 @@ void Game::TickOnceAfter()
         musictype = leveltheme;
         for (unsigned i = 0; i < Person::players.size(); i++) {
             if ((Person::players[i]->aitype == attacktypecutoff ||
-                    Person::players[i]->aitype == getweapontype ||
-                    Person::players[i]->aitype == gethelptype ||
-                    Person::players[i]->aitype == searchtype) &&
-                    !Person::players[i]->dead &&
-                    (Person::players[i]->animTarget != sneakattackedanim &&
-                     Person::players[i]->animTarget != knifesneakattackedanim &&
-                     Person::players[i]->animTarget != swordsneakattackedanim)) {
+                 Person::players[i]->aitype == getweapontype ||
+                 Person::players[i]->aitype == gethelptype ||
+                 Person::players[i]->aitype == searchtype) &&
+                !Person::players[i]->dead &&
+                (Person::players[i]->animTarget != sneakattackedanim &&
+                 Person::players[i]->animTarget != knifesneakattackedanim &&
+                 Person::players[i]->animTarget != swordsneakattackedanim)) {
                 musictype = stream_fighttheme;
                 realthreat = 1;
             }
@@ -4308,7 +4302,6 @@ void Game::TickOnceAfter()
         if (Person::players[0]->dead)
             musictype = stream_menutheme;
 
-
         if (musictype == stream_fighttheme)
             unseendelay = 1;
 
@@ -4318,7 +4311,6 @@ void Game::TickOnceAfter()
                 musictype = stream_fighttheme;
         }
 
-
         if (loading == 2) {
             musictype = stream_menutheme;
             musicvolume[2] = 512;
@@ -4401,7 +4393,6 @@ void Game::TickOnceAfter()
         if (Hotspot::killhotspot == 2)
             Hotspot::killhotspot = 0;
 
-
         winhotspot = false;
         for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
             if (Hotspot::hotspots[i].type == -1) {
@@ -4434,7 +4425,6 @@ void Game::TickOnceAfter()
                 }
             }
 
-
             if (alldead && !Person::players[0]->dead && maptype == mapkilleveryone) {
                 changedelay = 1;
                 targetlevel = whichlevel + 1;
@@ -4448,7 +4438,6 @@ void Game::TickOnceAfter()
                     targetlevel = 0;
             }
 
-
             if (Hotspot::killhotspot) {
                 changedelay = 1;
                 targetlevel = whichlevel + 1;
@@ -4511,19 +4500,19 @@ void Game::TickOnceAfter()
                     loading = 3;
                 }
                 if (changedelay <= -999 &&
-                        whichlevel != -2 &&
-                        !loading &&
-                        (Person::players[0]->dead ||
-                         (alldead && maptype == mapkilleveryone) ||
-                         (winhotspot) ||
-                         (Hotspot::killhotspot)))
+                    whichlevel != -2 &&
+                    !loading &&
+                    (Person::players[0]->dead ||
+                     (alldead && maptype == mapkilleveryone) ||
+                     (winhotspot) ||
+                     (Hotspot::killhotspot)))
                     loading = 1;
                 if ((Person::players[0]->dead ||
-                        (alldead && maptype == mapkilleveryone) ||
-                        (winhotspot) ||
-                        (windialogue) ||
-                        (Hotspot::killhotspot)) &&
-                        changedelay <= 0) {
+                     (alldead && maptype == mapkilleveryone) ||
+                     (winhotspot) ||
+                     (windialogue) ||
+                     (Hotspot::killhotspot)) &&
+                    changedelay <= 0) {
                     if (whichlevel != -2 && !loading && !Person::players[0]->dead) {
                         winfreeze = true;
                         changedelay = -999;
@@ -4576,7 +4565,6 @@ void Game::TickOnceAfter()
 
             if (loading == 3)
                 loading = 0;
-
         }
 
         oldmusictype = musictype;
@@ -4669,4 +4657,3 @@ void Game::TickOnceAfter()
         }
     }
 }
-