X-Git-Url: https://git.jsancho.org/?a=blobdiff_plain;f=Source%2FGameTick.cpp;h=c627e514765cd71dcdff4a7d741f3b501d2f0ea3;hb=e069918736630bf740df60442891b66f93b564e9;hp=9844ff0e9c89e8a446c00d6ef4e50fd241603eeb;hpb=b9a46d8e2b7e7e22c706e7dd3734f31015db4408;p=lugaru.git

diff --git a/Source/GameTick.cpp b/Source/GameTick.cpp
index 9844ff0..c627e51 100644
--- a/Source/GameTick.cpp
+++ b/Source/GameTick.cpp
@@ -1,6 +1,6 @@
 /*
 Copyright (C) 2003, 2010 - Wolfire Games
-Copyright (C) 2010-2016 - Lugaru contributors (see AUTHORS file)
+Copyright (C) 2010-2017 - Lugaru contributors (see AUTHORS file)
 
 This file is part of Lugaru.
 
@@ -148,27 +148,6 @@ float musicvolume[4] = {};
 float oldmusicvolume[4] = {};
 int musicselected = 0;
 
-const char* rabbitskin[] = {
-    "Textures/Fur3.jpg",
-    "Textures/Fur.jpg",
-    "Textures/Fur2.jpg",
-    "Textures/Lynx.jpg",
-    "Textures/Otter.jpg",
-    "Textures/Opal.jpg",
-    "Textures/Sable.jpg",
-    "Textures/Chocolate.jpg",
-    "Textures/BW2.jpg",
-    "Textures/WB2.jpg"
-};
-
-const char* wolfskin[] = {
-    "Textures/Wolf.jpg",
-    "Textures/DarkWolf.jpg",
-    "Textures/SnowWolf.jpg"
-};
-
-const char** creatureskin[] = { rabbitskin, wolfskin };
-
 #define STATIC_ASSERT(x) extern int s_a_dummy[2 * (!!(x)) - 1];
 STATIC_ASSERT(rabbittype == 0 && wolftype == 1)
 
@@ -300,11 +279,11 @@ int Game::findClosestPlayer()
     int closest = -1;
     float closestdist = std::numeric_limits<float>::max();
 
-    for (unsigned i = 1; i < Person::players.size(); i++) {
+    for (unsigned int i = 1; i < Person::players.size(); i++) {
         float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
         if (distance < closestdist) {
             closestdist = distance;
-            closest = i;
+            closest = (int)i;
         }
     }
     return closest;
@@ -851,11 +830,7 @@ bool Game::LoadLevel(const std::string& name, bool tutorial)
             Person::players[i]->updatedelay = 0;
             Person::players[i]->normalsupdatedelay = 0;
 
-            Person::players[i]->proportionhead = 1.2;
-            Person::players[i]->proportionbody = 1.05;
-            Person::players[i]->proportionarms = 1.00;
-            Person::players[i]->proportionlegs = 1.1;
-            Person::players[i]->proportionlegs.y = 1.05;
+            Person::players[i]->setProportions(1, 1, 1, 1);
             Person::players[i]->headless = 0;
             Person::players[i]->currentoffset = 0;
             Person::players[i]->targetoffset = 0;
@@ -865,20 +840,11 @@ bool Game::LoadLevel(const std::string& name, bool tutorial)
             } else {
                 Person::players[i]->damagetolerance = 200;
             }
-        }
 
-        Game::LoadingScreen();
-
-        if (cellophane) {
-            Person::players[i]->proportionhead.z = 0;
-            Person::players[i]->proportionbody.z = 0;
-            Person::players[i]->proportionarms.z = 0;
-            Person::players[i]->proportionlegs.z = 0;
-        }
+            Game::LoadingScreen();
 
-        Person::players[i]->tempanimation = Animation("Tempanim", lowheight, neutral);
+            Person::players[i]->tempanimation = Animation("Tempanim", lowheight, neutral);
 
-        if (i == 0) {
             Person::players[i]->headmorphness = 0;
             Person::players[i]->targetheadmorphness = 1;
             Person::players[i]->headmorphstart = 0;
@@ -959,21 +925,153 @@ bool Game::LoadLevel(const std::string& name, bool tutorial)
     return true;
 }
 
-void doDevKeys()
+/* Process input events that impact settings, console, devtools, etc.
+ * Gameplay-related input processing is still done in Game::Tick() for now
+ * as it is tightly coupled to the game logic.
+ */
+void Game::ProcessInput()
 {
-    float headprop, bodyprop, armprop, legprop;
-    if (!devtools) {
+    /* Pump SDL input events */
+    Input::Tick();
+
+    /* Menu handling (main menu, leave game) */
+    if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
+        (gameon || mainmenu == 0)) {
+        selected = -1;
+        if (mainmenu == 0 && !winfreeze) {
+            mainmenu = 2; // Pause
+        } else if (mainmenu == 1 || mainmenu == 2) {
+            mainmenu = 0; // Unpause
+        }
+        // Play menu theme
+        if (musictoggle && (mainmenu == 1 || mainmenu == 2)) {
+            OPENAL_SetFrequency(OPENAL_ALL);
+            emit_stream_np(stream_menutheme);
+            pause_sound(leveltheme);
+        }
+        // On resume, play level music
+        if (!mainmenu) {
+            pause_sound(stream_menutheme);
+            resume_stream(leveltheme);
+        }
+    }
+
+    /* Challenge mode */
+    if (!campaign && !mainmenu) {
+        if ((Input::isKeyPressed(jumpkey) || Input::isKeyPressed(SDL_SCANCODE_SPACE))) {
+            if (winfreeze) {
+                winfreeze = 0;
+            }
+        }
+
+        if ((Input::isKeyDown(SDL_SCANCODE_ESCAPE)) && gameon) {
+            if (console) {
+                console = false;
+                freeze = 0;
+            } else if (winfreeze) {
+                mainmenu = 9;
+                gameon = 0;
+            }
+        }
+    }
+
+    /* Tutorial mode hotkeys */
+    if (Tutorial::active) {
+        // Skip current tutorial stage
+        if (Input::isKeyPressed(SDL_SCANCODE_TAB)) {
+            if (Tutorial::stage != 51) {
+                Tutorial::stagetime = Tutorial::maxtime;
+            }
+            emit_sound_np(consolefailsound, 128.);
+        }
+    }
+
+    /* Screenshot */
+    if (Input::isKeyPressed(SDL_SCANCODE_F1)) {
+        Screenshot();
+    }
+
+    /* Stereo video mode hotkeys */
+    if (Input::isKeyPressed(SDL_SCANCODE_F6)) {
+        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            stereoreverse = true;
+            printf("Stereo reversed\n");
+        } else {
+            stereoreverse = false;
+            printf("Stereo unreversed\n");
+        }
+    }
+
+    if (Input::isKeyDown(SDL_SCANCODE_F7)) {
+        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            stereoseparation -= 0.001;
+        } else {
+            stereoseparation -= 0.010;
+        }
+        printf("Stereo separation decreased to %f\n", stereoseparation);
+    }
+
+    if (Input::isKeyDown(SDL_SCANCODE_F8)) {
+        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            stereoseparation += 0.001;
+        } else {
+            stereoseparation += 0.010;
+        }
+        printf("Stereo separation increased to %f\n", stereoseparation);
+    }
+
+    /* Devtools */
+    if (devtools && !mainmenu) {
+        /* Console */
+        if (Input::isKeyPressed(consolekey)) {
+            console = !console;
+            if (console) {
+                OPENAL_SetFrequency(OPENAL_ALL);
+            } else {
+                freeze = 0;
+                waiting = false;
+            }
+        }
+
+        /* Other devtools, disabled when the console is shown */
+        if (!console) {
+            ProcessDevInput();
+        }
+    }
+}
+
+void Game::ProcessDevInput()
+{
+    if (!devtools || mainmenu || console) {
         return;
     }
 
     if (Input::isKeyDown(SDL_SCANCODE_LALT)) {
-        /* Invicible */
+        /* Enable editor */
+        if (Input::isKeyPressed(SDL_SCANCODE_M) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            editorenabled = !editorenabled;
+            if (editorenabled) {
+                Person::players[0]->damagetolerance = 100000;
+                Person::players[0]->damage = 0;
+                Person::players[0]->permanentdamage = 0;
+                Person::players[0]->superpermanentdamage = 0;
+                Person::players[0]->burnt = 0;
+                Person::players[0]->bloodloss = 0;
+                Person::players[0]->deathbleeding = 0;
+            } else {
+                Person::players[0]->damagetolerance = 200;
+            }
+        }
+
+        /* Nullify damage and give 200000 health */
         if (Input::isKeyPressed(SDL_SCANCODE_H)) {
             Person::players[0]->damagetolerance = 200000;
             Person::players[0]->damage = 0;
-            Person::players[0]->burnt = 0;
             Person::players[0]->permanentdamage = 0;
             Person::players[0]->superpermanentdamage = 0;
+            Person::players[0]->burnt = 0;
+            Person::players[0]->bloodloss = 0;
+            Person::players[0]->deathbleeding = 0;
         }
 
         /* Change environment */
@@ -990,7 +1088,15 @@ void doDevKeys()
             cameramode = !cameramode;
         }
 
-        /* Toggle Slow motion */
+        /* Freeze */
+        if (Input::isKeyPressed(SDL_SCANCODE_V)) {
+            freeze = !freeze;
+            if (freeze) {
+                OPENAL_SetFrequency(OPENAL_ALL);
+            }
+        }
+
+        /* Toggle slow motion */
         if (Input::isKeyPressed(SDL_SCANCODE_B)) {
             slomo = 1 - slomo;
             slomodelay = 1000;
@@ -999,11 +1105,11 @@ void doDevKeys()
         /* Ragdoll */
         if (Input::isKeyPressed(SDL_SCANCODE_N)) {
             Person::players[0]->RagDoll(0);
-
             emit_sound_at(whooshsound, Person::players[0]->coords, 128.);
         }
 
-        /* Grow tree leaves?? */
+        /* Shrink tree leaves?? */
+        // FIXME: Can't see what this does in game.
         if (Input::isKeyPressed(SDL_SCANCODE_Y)) {
             for (auto& an_object : Object::objects) {
                 if (an_object->type == treeleavestype) {
@@ -1021,24 +1127,28 @@ void doDevKeys()
 
             if (closest >= 0) {
                 if (Person::players[closest]->num_weapons > 0) {
-                    if (weapons[Person::players[closest]->weaponids[0]].getType() == sword) {
-                        weapons[Person::players[closest]->weaponids[0]].setType(staff);
-                    } else if (weapons[Person::players[closest]->weaponids[0]].getType() == staff) {
-                        weapons[Person::players[closest]->weaponids[0]].setType(knife);
-                    } else {
-                        weapons[Person::players[closest]->weaponids[0]].setType(sword);
+                    int weapontype = 0;
+                    switch (weapons[Person::players[closest]->weaponids[0]].getType()) {
+                        case knife:
+                            weapontype = sword;
+                            break;
+                        case sword:
+                            weapontype = staff;
+                            break;
+                        case staff:
+                            weapontype = knife;
+                            break;
                     }
+                    weapons[Person::players[closest]->weaponids[0]].setType(weapontype);
                 } else {
                     Person::players[closest]->weaponids[0] = weapons.size();
-
                     weapons.push_back(Weapon(knife, closest));
-
                     Person::players[closest]->num_weapons = 1;
                 }
             }
         }
 
-        /* Change yaw? */
+        /* Change yaw (rotate around Z axis) */
         if (Input::isKeyDown(SDL_SCANCODE_U)) {
             int closest = 0;
             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
@@ -1053,18 +1163,24 @@ void doDevKeys()
 
         /* Toggle fire */
         if (Input::isKeyPressed(SDL_SCANCODE_F)) {
-            Person::players[0]->onfire = 1 - Person::players[0]->onfire;
-            if (Person::players[0]->onfire) {
-                Person::players[0]->CatchFire();
+            int closest = 0;
+            if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+                closest = findClosestPlayer();
             }
-            if (!Person::players[0]->onfire) {
-                emit_sound_at(fireendsound, Person::players[0]->coords);
-                pause_sound(stream_firesound);
+
+            if (closest >= 0) {
+                Person::players[closest]->onfire = !Person::players[closest]->onfire;
+                if (Person::players[closest]->onfire) {
+                    Person::players[closest]->CatchFire();
+                } else {
+                    emit_sound_at(fireendsound, Person::players[closest]->coords);
+                    pause_sound(stream_firesound);
+                }
             }
         }
 
         /* Change skin */
-        if (Input::isKeyPressed(SDL_SCANCODE_O) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+        if (Input::isKeyPressed(SDL_SCANCODE_T) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = 0;
             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
                 closest = findClosestPlayer();
@@ -1079,127 +1195,67 @@ 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.drawmodel.textureptr.load(
+                    PersonType::types[Person::players[closest]->creature].skins[Person::players[closest]->whichskin], 1,
+                    &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
             }
 
             Person::players[closest]->addClothes();
         }
 
         /* Change creature type */
-        if (Input::isKeyPressed(SDL_SCANCODE_O) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+        if (Input::isKeyPressed(SDL_SCANCODE_T) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = 0;
             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
                 closest = findClosestPlayer();
             }
 
             if (closest >= 0) {
-                if (Person::players[closest]->creature == wolftype) {
-                    headprop = Person::players[closest]->proportionhead.x / 1.1;
-                    bodyprop = Person::players[closest]->proportionbody.x / 1.1;
-                    armprop = Person::players[closest]->proportionarms.x / 1.1;
-                    legprop = Person::players[closest]->proportionlegs.x / 1.1;
-                } else {
-                    // rabbittype
-                    headprop = Person::players[closest]->proportionhead.x / 1.2;
-                    bodyprop = Person::players[closest]->proportionbody.x / 1.05;
-                    armprop = Person::players[closest]->proportionarms.x / 1.00;
-                    legprop = Person::players[closest]->proportionlegs.x / 1.1;
-                }
-
-                if (Person::players[closest]->creature == rabbittype) {
-                    Person::players[closest]->creature = wolftype;
-                    Person::players[closest]->whichskin = 0;
-                    Person::players[closest]->skeletonLoad();
-
-                    Person::players[closest]->proportionhead = 1.1;
-                    Person::players[closest]->proportionbody = 1.1;
-                    Person::players[closest]->proportionarms = 1.1;
-                    Person::players[closest]->proportionlegs = 1.1;
-                    Person::players[closest]->proportionlegs.y = 1.1;
-                    Person::players[closest]->scale = .23 * 5 * Person::players[0]->scale;
-
-                    Person::players[closest]->damagetolerance = 300;
-                } else {
-                    Person::players[closest]->creature = rabbittype;
-                    Person::players[closest]->whichskin = 0;
-                    Person::players[closest]->skeletonLoad(true);
-
-                    Person::players[closest]->proportionhead = 1.2;
-                    Person::players[closest]->proportionbody = 1.05;
-                    Person::players[closest]->proportionarms = 1.00;
-                    Person::players[closest]->proportionlegs = 1.1;
-                    Person::players[closest]->proportionlegs.y = 1.05;
-                    Person::players[closest]->scale = .2 * 5 * Person::players[0]->scale;
-
-                    Person::players[closest]->damagetolerance = 200;
-                }
-
-                if (Person::players[closest]->creature == wolftype) {
-                    Person::players[closest]->proportionhead = 1.1 * headprop;
-                    Person::players[closest]->proportionbody = 1.1 * bodyprop;
-                    Person::players[closest]->proportionarms = 1.1 * armprop;
-                    Person::players[closest]->proportionlegs = 1.1 * legprop;
-                }
-
-                if (Person::players[closest]->creature == rabbittype) {
-                    Person::players[closest]->proportionhead = 1.2 * headprop;
-                    Person::players[closest]->proportionbody = 1.05 * bodyprop;
-                    Person::players[closest]->proportionarms = 1.00 * armprop;
-                    Person::players[closest]->proportionlegs = 1.1 * legprop;
-                    Person::players[closest]->proportionlegs.y = 1.05 * legprop;
-                }
+                person_type nextType = static_cast<person_type>((Person::players[closest]->creature + 1) % PersonType::types.size());
+                Person::players[closest]->changeCreatureType(nextType);
             }
         }
 
-        /* Decapitate */
-        if (((Input::isKeyPressed(SDL_SCANCODE_I) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
-            int closest = -1;
-            float closestdist = std::numeric_limits<float>::max();
+        /* Explose nearby player's head */
+        if (Input::isKeyPressed(SDL_SCANCODE_I) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            int closest = findClosestPlayer();
+            if (closest > 0 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
+                XYZ flatfacing2, flatvelocity2, flatvelocity2_orig;
+                XYZ headspurtdirection;
+                Joint& headjoint = Person::players[closest]->joint(head);
 
-            for (unsigned i = 1; i < Person::players.size(); i++) {
-                float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
-                if (!Person::players[i]->headless) {
-                    if (distance < closestdist) {
-                        closestdist = distance;
-                        closest = i;
-                    }
+                if (!Person::players[closest]->skeleton.free) {
+                    flatvelocity2_orig = Person::players[closest]->velocity;
+                    flatfacing2 = DoRotation(
+                                      DoRotation(
+                                          DoRotation(headjoint.position, 0, 0, Person::players[closest]->tilt),
+                                          Person::players[closest]->tilt2, 0, 0),
+                                      0, Person::players[closest]->yaw, 0) *
+                                      Person::players[closest]->scale +
+                                  Person::players[closest]->coords;
+                } else {
+                    flatvelocity2_orig = headjoint.velocity;
+                    flatfacing2 = headjoint.position * Person::players[closest]->scale + Person::players[closest]->coords;
                 }
-            }
 
-            XYZ flatfacing2, flatvelocity2;
-            XYZ blah;
-            if (closest != -1 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
-                blah = Person::players[closest]->coords;
-                XYZ headspurtdirection;
-                //int i = Person::players[closest]->skeleton.jointlabels[head];
-                Joint& headjoint = Person::players[closest]->joint(head);
-                for (unsigned k = 0; k < Person::players[closest]->skeleton.joints.size(); k++) {
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->velocity;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = headjoint.velocity;
-                    }
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatfacing2 = DoRotation(DoRotation(DoRotation(headjoint.position, 0, 0, Person::players[closest]->tilt), Person::players[closest]->tilt2, 0, 0), 0, Person::players[closest]->yaw, 0) * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatfacing2 = headjoint.position * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
+                headspurtdirection = headjoint.position - Person::players[closest]->jointPos(neck);
+                Normalise(&headspurtdirection);
+
+                for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
+                    flatvelocity2 = flatvelocity2_orig;
                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
-                    headspurtdirection = headjoint.position - Person::players[closest]->jointPos(neck);
-                    Normalise(&headspurtdirection);
+                    printf("Test: %f\n", flatvelocity2.x);
+                    printf("Test orig: %f\n", flatvelocity2_orig.x);
                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, .6, 1);
                     flatvelocity2 += headspurtdirection * 8;
                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 / 2, 1, 1, 1, .16, 1);
                 }
                 Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
 
-                emit_sound_at(splattersound, blah);
-                emit_sound_at(breaksound2, blah, 100.);
+                emit_sound_at(splattersound, Person::players[closest]->coords);
+                emit_sound_at(breaksound2, Person::players[closest]->coords, 100.);
 
                 if (Person::players[closest]->skeleton.free == 2) {
                     Person::players[closest]->skeleton.free = 0;
@@ -1213,90 +1269,59 @@ void doDevKeys()
             }
         }
 
-        /* Explode */
-        if (((Input::isKeyPressed(SDL_SCANCODE_I) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
+        /* Explode nearby player */
+        if (Input::isKeyPressed(SDL_SCANCODE_I) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = findClosestPlayer();
-            XYZ flatfacing2, flatvelocity2;
-            XYZ blah;
             if (closest >= 0 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
-                blah = Person::players[closest]->coords;
-                emit_sound_at(splattersound, blah);
-                emit_sound_at(breaksound2, blah);
+                XYZ flatfacing2, flatvelocity2, flatvelocity2_orig;
+
+                emit_sound_at(splattersound, Person::players[closest]->coords);
+                emit_sound_at(breaksound2, Person::players[closest]->coords);
 
                 for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
                     if (!Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->velocity;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
-                    }
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatfacing2 = DoRotation(DoRotation(DoRotation(Person::players[closest]->skeleton.joints[i].position, 0, 0, Person::players[closest]->tilt), Person::players[closest]->tilt2, 0, 0), 0, Person::players[closest]->yaw, 0) * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
+                        flatvelocity2_orig = Person::players[closest]->velocity;
+                        flatfacing2 = DoRotation(
+                                          DoRotation(
+                                              DoRotation(Person::players[closest]->skeleton.joints[i].position, 0, 0, Person::players[closest]->tilt),
+                                              Person::players[closest]->tilt2, 0, 0),
+                                          0, Person::players[closest]->yaw, 0) *
+                                          Person::players[closest]->scale +
+                                      Person::players[closest]->coords;
+                    } else {
+                        flatvelocity2_orig = Person::players[closest]->skeleton.joints[i].velocity;
+                        flatfacing2 = Person::players[closest]->skeleton.joints[i].position *
+                                          Person::players[closest]->scale +
+                                      Person::players[closest]->coords;
                     }
+
+                    // Animation part 1
+                    flatvelocity2 = flatvelocity2_orig;
                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .3, 1);
                     Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
-                }
 
-                for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->velocity;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
-                    }
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatfacing2 = DoRotation(DoRotation(DoRotation(Person::players[closest]->skeleton.joints[i].position, 0, 0, Person::players[closest]->tilt), Person::players[closest]->tilt2, 0, 0), 0, Person::players[closest]->yaw, 0) * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
+                    // Animation part 2
+                    flatvelocity2 = flatvelocity2_orig;
                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .4, 1);
-                }
 
-                for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->velocity;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
-                    }
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatfacing2 = DoRotation(DoRotation(DoRotation(Person::players[closest]->skeleton.joints[i].position, 0, 0, Person::players[closest]->tilt), Person::players[closest]->tilt2, 0, 0), 0, Person::players[closest]->yaw, 0) * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
+                    // Animation part 3
+                    flatvelocity2 = flatvelocity2_orig;
                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, 3, 1);
                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, .4, 1);
-                }
 
-                for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->velocity;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
-                    }
-                    if (!Person::players[closest]->skeleton.free) {
-                        flatfacing2 = DoRotation(DoRotation(DoRotation(Person::players[closest]->skeleton.joints[i].position, 0, 0, Person::players[closest]->tilt), Person::players[closest]->tilt2, 0, 0), 0, Person::players[closest]->yaw, 0) * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
-                    if (Person::players[closest]->skeleton.free) {
-                        flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
-                    }
+                    // Animation part 4
+                    flatvelocity2 = flatvelocity2_orig;
                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
@@ -1306,21 +1331,23 @@ void doDevKeys()
 
                 XYZ temppos;
                 for (unsigned j = 0; j < Person::players.size(); j++) {
-                    if (int(j) != closest) {
-                        if (distsq(&Person::players[j]->coords, &Person::players[closest]->coords) < 25) {
-                            Person::players[j]->DoDamage((25 - distsq(&Person::players[j]->coords, &Person::players[closest]->coords)) * 60);
-                            if (Person::players[j]->skeleton.free == 2) {
-                                Person::players[j]->skeleton.free = 1;
-                            }
-                            Person::players[j]->skeleton.longdead = 0;
-                            Person::players[j]->RagDoll(0);
-                            for (unsigned i = 0; i < Person::players[j]->skeleton.joints.size(); i++) {
-                                temppos = Person::players[j]->skeleton.joints[i].position + Person::players[j]->coords;
-                                if (distsq(&temppos, &Person::players[closest]->coords) < 25) {
-                                    flatvelocity2 = temppos - Person::players[closest]->coords;
-                                    Normalise(&flatvelocity2);
-                                    Person::players[j]->skeleton.joints[i].velocity += flatvelocity2 * ((20 - distsq(&temppos, &Person::players[closest]->coords)) * 20);
-                                }
+                    if (int(j) == closest) {
+                        continue;
+                    }
+                    if (distsq(&Person::players[j]->coords, &Person::players[closest]->coords) < 25) {
+                        Person::players[j]->DoDamage((25 - distsq(&Person::players[j]->coords, &Person::players[closest]->coords)) * 60);
+                        if (Person::players[j]->skeleton.free == 2) {
+                            Person::players[j]->skeleton.free = 1;
+                        }
+                        Person::players[j]->skeleton.longdead = 0;
+                        Person::players[j]->RagDoll(0);
+                        for (unsigned i = 0; i < Person::players[j]->skeleton.joints.size(); i++) {
+                            temppos = Person::players[j]->skeleton.joints[i].position + Person::players[j]->coords;
+                            if (distsq(&temppos, &Person::players[closest]->coords) < 25) {
+                                flatvelocity2 = temppos - Person::players[closest]->coords;
+                                Normalise(&flatvelocity2);
+                                Person::players[j]->skeleton.joints[i].velocity +=
+                                    flatvelocity2 * ((20 - distsq(&temppos, &Person::players[closest]->coords)) * 20);
                             }
                         }
                     }
@@ -1335,24 +1362,10 @@ void doDevKeys()
                 camerashake += .6;
             }
         }
-
-        /* Enable editor */
-        if (Input::isKeyPressed(SDL_SCANCODE_M) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            editorenabled = !editorenabled;
-            if (editorenabled) {
-                Person::players[0]->damagetolerance = 100000;
-            } else {
-                Person::players[0]->damagetolerance = 200;
-            }
-            Person::players[0]->damage = 0; // these lines were in both if and else, but I think they would better fit in the if
-            Person::players[0]->permanentdamage = 0;
-            Person::players[0]->superpermanentdamage = 0;
-            Person::players[0]->bloodloss = 0;
-            Person::players[0]->deathbleeding = 0;
-        }
     }
 
-    //skip level
+    /* Skip level (only for challenges) */
+    // FIXME: Allow skipping levels in campaigns too
     if (whichlevel != -2 && Input::isKeyPressed(SDL_SCANCODE_K) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !editorenabled) {
         targetlevel++;
         if (targetlevel > numchallengelevels - 1) {
@@ -1362,51 +1375,54 @@ void doDevKeys()
         leveltime = 5;
     }
 
+    /* Editor mode keys */
     if (editorenabled) {
+        /* Closest player deletion */
         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = findClosestPlayer();
-            if (closest >= 0) {
+            if (closest > 0) {
                 Person::players.erase(Person::players.begin() + closest);
             }
         }
 
-        if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+        /* Closest object deletion */
+        if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             int closest = findClosestObject();
             if (closest >= 0) {
-                Object::objects[closest]->position.y -= 500;
+                Object::DeleteObject(closest);
             }
         }
 
-        if (Input::isKeyPressed(SDL_SCANCODE_M) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+        /* Add object */
+        if (Input::isKeyPressed(SDL_SCANCODE_O)) {
             if (Object::objects.size() < max_objects - 1) {
-                XYZ scenecoords;
-                scenecoords.x = Person::players[0]->coords.x;
-                scenecoords.z = Person::players[0]->coords.z;
-                scenecoords.y = Person::players[0]->coords.y - 3;
-                if (editortype == bushtype) {
-                    scenecoords.y = Person::players[0]->coords.y - .5;
-                }
-                if (editortype == firetype) {
-                    scenecoords.y = Person::players[0]->coords.y - .5;
+                XYZ scenecoords = Person::players[0]->coords;
+                scenecoords.y -= 3;
+                if (editortype == bushtype || editortype == firetype) {
+                    scenecoords.y -= 3.5;
+                } else {
+                    scenecoords.y -= 3;
                 }
-                float temprotat, temprotat2;
-                temprotat = editoryaw;
-                temprotat2 = editorpitch;
-                if (temprotat < 0 || editortype == bushtype) {
-                    temprotat = Random() % 360;
+
+                float tmpyaw, tmppitch;
+                tmpyaw = editoryaw;
+                tmppitch = editorpitch;
+                if (tmpyaw < 0 || editortype == bushtype) {
+                    tmpyaw = Random() % 360;
                 }
-                if (temprotat2 < 0) {
-                    temprotat2 = Random() % 360;
+                if (tmppitch < 0) {
+                    tmppitch = Random() % 360;
                 }
 
-                Object::MakeObject(editortype, scenecoords, (int)temprotat - ((int)temprotat) % 30, (int)temprotat2, editorsize);
+                Object::MakeObject(editortype, scenecoords, (int)tmpyaw - ((int)tmpyaw) % 30, (int)tmppitch, editorsize);
                 if (editortype == treetrunktype) {
-                    Object::MakeObject(treeleavestype, scenecoords, Random() % 360 * (temprotat2 < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
+                    Object::MakeObject(treeleavestype, scenecoords, Random() % 360 * (tmppitch < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
                 }
             }
         }
 
-        if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+        /* Add player */
+        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;
@@ -1414,17 +1430,9 @@ void doDevKeys()
             Person::players.back()->scale = Person::players[0]->scale;
             Person::players.back()->creature = rabbittype;
             Person::players.back()->howactive = editoractive;
+            Person::players.back()->whichskin = (int)(abs(Random() % 3));
 
-            int k = abs(Random() % 2) + 1;
-            if (k == 0) {
-                Person::players.back()->whichskin = 0;
-            } else if (k == 1) {
-                Person::players.back()->whichskin = 1;
-            } else {
-                Person::players.back()->whichskin = 2;
-            }
-
-            Person::players.back()->skeletonLoad(true);
+            Person::players.back()->skeletonLoad();
 
             Person::players.back()->skeleton.drawmodelclothes.textureptr.load("Textures/Belt.png", 1);
             Person::players.back()->speed = 1 + (float)(Random() % 100) / 1000;
@@ -1436,42 +1444,7 @@ void doDevKeys()
             Person::players.back()->oldcoords = Person::players.back()->coords;
             Person::players.back()->realoldcoords = Person::players.back()->coords;
 
-            if (Person::players[0]->creature == wolftype) {
-                headprop = Person::players[0]->proportionhead.x / 1.1;
-                bodyprop = Person::players[0]->proportionbody.x / 1.1;
-                armprop = Person::players[0]->proportionarms.x / 1.1;
-                legprop = Person::players[0]->proportionlegs.x / 1.1;
-            } else {
-                // rabbittype
-                headprop = Person::players[0]->proportionhead.x / 1.2;
-                bodyprop = Person::players[0]->proportionbody.x / 1.05;
-                armprop = Person::players[0]->proportionarms.x / 1.00;
-                legprop = Person::players[0]->proportionlegs.x / 1.1;
-            }
-
-            if (Person::players.back()->creature == wolftype) {
-                Person::players.back()->proportionhead = 1.1 * headprop;
-                Person::players.back()->proportionbody = 1.1 * bodyprop;
-                Person::players.back()->proportionarms = 1.1 * armprop;
-                Person::players.back()->proportionlegs = 1.1 * legprop;
-            }
-
-            if (Person::players.back()->creature == rabbittype) {
-                Person::players.back()->proportionhead = 1.2 * headprop;
-                Person::players.back()->proportionbody = 1.05 * bodyprop;
-                Person::players.back()->proportionarms = 1.00 * armprop;
-                Person::players.back()->proportionlegs = 1.1 * legprop;
-                Person::players.back()->proportionlegs.y = 1.05 * legprop;
-            }
-
-            if (cellophane) {
-                Person::players.back()->proportionhead.z = 0;
-                Person::players.back()->proportionbody.z = 0;
-                Person::players.back()->proportionarms.z = 0;
-                Person::players.back()->proportionlegs.z = 0;
-            }
-
-            Person::players.back()->tempanimation = Animation("Tempanim", lowheight, neutral);
+            Person::players.back()->setProportions(1, 1, 1, 1);
 
             Person::players.back()->damagetolerance = 200;
 
@@ -1499,33 +1472,39 @@ void doDevKeys()
             Person::players.back()->power = Person::players[0]->power;
             Person::players.back()->speedmult = Person::players[0]->speedmult;
 
+            if (Input::isKeyDown(SDL_SCANCODE_RSHIFT))
+                Person::players.back()->isplayerfriend = true;
+
             Person::players.back()->loaded = true;
         }
 
-        if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+        /* Add waypoint */
+        if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             if (Person::players.back()->numwaypoints < 90) {
                 Person::players.back()->waypoints[Person::players.back()->numwaypoints] = Person::players[0]->coords;
                 Person::players.back()->waypointtype[Person::players.back()->numwaypoints] = editorpathtype;
                 Person::players.back()->numwaypoints++;
+            } else {
+                printf("Add waypoint: Reached max number of waypoints (90), aborting.");
             }
         }
 
-        if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+        /* Connect waypoint */
+        if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LCTRL) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             if (numpathpoints < 30) {
-                bool connected, alreadyconnected;
-                connected = 0;
+                bool connected = false;
                 if (numpathpoints > 1) {
                     for (int i = 0; i < numpathpoints; i++) {
                         if (distsq(&pathpoint[i], &Person::players[0]->coords) < .5 && i != pathpointselected && !connected) {
-                            alreadyconnected = 0;
+                            bool alreadyconnected = false;
                             for (int j = 0; j < numpathpointconnect[pathpointselected]; j++) {
                                 if (pathpointconnect[pathpointselected][j] == i) {
-                                    alreadyconnected = 1;
+                                    alreadyconnected = true;
                                 }
                             }
                             if (!alreadyconnected) {
                                 numpathpointconnect[pathpointselected]++;
-                                connected = 1;
+                                connected = true;
                                 pathpointconnect[pathpointselected][numpathpointconnect[pathpointselected] - 1] = i;
                             }
                         }
@@ -1541,9 +1520,12 @@ void doDevKeys()
                     }
                     pathpointselected = numpathpoints - 1;
                 }
+            } else {
+                printf("Connect waypoint: Reached max number of path points (30), aborting.");
             }
         }
 
+        /* Select next path waypoint */
         if (Input::isKeyPressed(SDL_SCANCODE_PERIOD)) {
             pathpointselected++;
             if (pathpointselected >= numpathpoints) {
@@ -1551,6 +1533,7 @@ void doDevKeys()
             }
         }
 
+        /* Select previous path waypoint */
         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             pathpointselected--;
             if (pathpointselected <= -2) {
@@ -1558,6 +1541,7 @@ void doDevKeys()
             }
         }
 
+        /* Delete path waypoint */
         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
             if (pathpointselected != -1) {
                 numpathpoints--;
@@ -1581,6 +1565,7 @@ void doDevKeys()
             }
         }
 
+        /* Select previous object type */
         if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             editortype--;
             if (editortype == treeleavestype || editortype == 10) {
@@ -1591,6 +1576,7 @@ void doDevKeys()
             }
         }
 
+        /* Select next object type */
         if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             editortype++;
             if (editortype == treeleavestype || editortype == 10) {
@@ -1601,6 +1587,20 @@ void doDevKeys()
             }
         }
 
+        /* Decrease size for next object */
+        if (Input::isKeyDown(SDL_SCANCODE_DOWN) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            editorsize -= multiplier;
+            if (editorsize < .1) {
+                editorsize = .1;
+            }
+        }
+
+        /* Increase size for next object */
+        if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
+            editorsize += multiplier;
+        }
+
+        /* Decrease yaw for next object */
         if (Input::isKeyDown(SDL_SCANCODE_LEFT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             editoryaw -= multiplier * 100;
             if (editoryaw < -.01) {
@@ -1608,46 +1608,33 @@ void doDevKeys()
             }
         }
 
+        /* Increase yaw for next object */
         if (Input::isKeyDown(SDL_SCANCODE_RIGHT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             editoryaw += multiplier * 100;
         }
 
-        if (Input::isKeyDown(SDL_SCANCODE_UP) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
-            editorsize += multiplier;
+        /* Decrease pitch for next object */
+        if (Input::isKeyDown(SDL_SCANCODE_DOWN) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+            editorpitch -= multiplier * 100;
+            if (editorpitch < -.01) {
+                editorpitch = -.01;
+            }
         }
 
-        if (Input::isKeyDown(SDL_SCANCODE_DOWN) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
-            editorsize -= multiplier;
-            if (editorsize < .1) {
-                editorsize = .1;
-            }
+        /* Increase pitch for next object */
+        if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
+            editorpitch += multiplier * 100;
         }
 
+        /* Decrease map radius */
         if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             mapradius -= multiplier * 10;
         }
 
+        /* Increase map radius */
         if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
             mapradius += multiplier * 10;
         }
-
-        if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
-            editorpitch += multiplier * 100;
-        }
-
-        if (Input::isKeyDown(SDL_SCANCODE_DOWN) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
-            editorpitch -= multiplier * 100;
-            if (editorpitch < -.01) {
-                editorpitch = -.01;
-            }
-        }
-
-        if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Object::objects.size() && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            int closest = findClosestObject();
-            if (closest >= 0) {
-                Object::DeleteObject(closest);
-            }
-        }
     }
 }
 
@@ -1659,8 +1646,8 @@ void doJumpReversals()
                 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]->isPlayerControlled() ||
+                 Person::players[k]->isPlayerControlled()) &&
                 ((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) &&
@@ -1671,8 +1658,8 @@ void doJumpReversals()
                         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]->isPlayerControlled() && Person::players[k]->attackkeydown) ||
+                         !Person::players[k]->isPlayerControlled())) {
                         Person::players[i]->victim = Person::players[k];
                         Person::players[i]->velocity = 0;
                         Person::players[i]->animCurrent = jumpreversedanim;
@@ -1711,8 +1698,8 @@ void doJumpReversals()
                         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]->isPlayerControlled() && Person::players[i]->attackkeydown) ||
+                         !Person::players[i]->isPlayerControlled())) {
                         Person::players[k]->victim = Person::players[i];
                         Person::players[k]->velocity = 0;
                         Person::players[k]->animCurrent = jumpreversedanim;
@@ -1817,7 +1804,7 @@ 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]->scale > .5 && Person::players[k]->isPlayerControlled() ||
                     Object::objects[i]->position.y > Person::players[k]->coords.y) {
                     lowpoint = Person::players[k]->coords;
                     if (Person::players[k]->animTarget != jumpupanim &&
@@ -1839,7 +1826,7 @@ void doAerialAcrobatics()
                         tempcollide = 1;
                         //wall jumps
                         //TODO: refactor four similar blocks
-                        if (Person::players[k]->aitype == playercontrolled &&
+                        if (Person::players[k]->isPlayerControlled() &&
                             (Person::players[k]->animTarget == jumpupanim ||
                              Person::players[k]->animTarget == jumpdownanim ||
                              Person::players[k]->isFlip()) &&
@@ -1995,7 +1982,7 @@ void doAerialAcrobatics()
                             Person::players[k]->coords.y -= 1.35;
                             Person::players[k]->collide = 1;
 
-                            if ((Person::players[k]->grabdelay <= 0 || Person::players[k]->aitype != playercontrolled) &&
+                            if ((Person::players[k]->grabdelay <= 0 || !Person::players[k]->isPlayerControlled()) &&
                                 (Person::players[k]->animCurrent != climbanim &&
                                      Person::players[k]->animCurrent != hanganim &&
                                      !Person::players[k]->isWallJump() ||
@@ -2173,7 +2160,7 @@ void doAttacks()
         playerrealattackkeydown = Input::isKeyDown(attackkey);
     }
     if ((Person::players[0]->parriedrecently <= 0 ||
-         Person::players[0]->weaponactive == -1) &&
+         !Person::players[0]->hasWeapon()) &&
         (!oldattackkey ||
          (realthreat &&
           Person::players[0]->lastattack != swordslashanim &&
@@ -2205,8 +2192,24 @@ void doAttacks()
             Person::players[k]->attackkeydown = 0;
         }
         if (Person::players[k]->animTarget != rabbitrunninganim && Person::players[k]->animTarget != wolfrunninganim) {
-            if (Person::players[k]->aitype != playercontrolled) {
-                Person::players[k]->victim = Person::players[0];
+            if (!Person::players[k]->isPlayerControlled()) {
+                if (Person::players[k]->isPlayerFriend()) {
+                    bool found = false;
+                    for (unsigned k2 = 1; k2 < Person::players.size(); k2++) {
+                        if (k != k2 &&
+                            !Person::players[k2]->dead &&
+                            Person::players[k2]->aitype == attacktypecutoff) {
+                            Person::players[k]->victim = Person::players[k2];
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        Person::players[k]->attackkeydown = 0;
+                    }
+                } else {
+                    Person::players[k]->victim = Person::players[0];
+                }
             }
             //attack key pressed
             if (Person::players[k]->attackkeydown) {
@@ -2260,7 +2263,7 @@ void doAttacks()
                      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();
+                    const int attackweapon = (Person::players[k]->hasWeapon() ? weapons[Person::players[k]->weaponids[Person::players[k]->weaponactive]].getType() : 0);
                     //normal attacks (?)
                     Person::players[k]->hasvictim = 0;
                     if (Person::players.size() > 1) {
@@ -2287,7 +2290,7 @@ void doAttacks()
                                         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
+                                        if (Person::players[k]->isPlayerControlled()) { //human player
                                             //sweep
                                             if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
                                                 Person::players[k]->crouchkeydown &&
@@ -2673,7 +2676,7 @@ void doAttacks()
                             }
                         }
                     }
-                    if (Person::players[k]->aitype == playercontrolled) {
+                    if (Person::players[k]->isPlayerControlled()) {
                         //rabbit kick
                         if (Person::players[k]->attackkeydown &&
                             Person::players[k]->isRun() &&
@@ -2685,7 +2688,7 @@ void doAttacks()
                               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???
+                              !Person::players[k]->isPlayerControlled() && //wat???
                               normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
                               Person::players[k]->rabbitkickenabled) ||
                              Person::players[k]->jumpkeydown)) {
@@ -2949,46 +2952,8 @@ void Game::Tick()
     static XYZ facing, flatfacing;
     static int target;
 
-    Input::Tick();
-
-    if (Input::isKeyPressed(SDL_SCANCODE_F6)) {
-        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            stereoreverse = true;
-        } else {
-            stereoreverse = false;
-        }
-
-        if (stereoreverse) {
-            printf("Stereo reversed\n");
-        } else {
-            printf("Stereo unreversed\n");
-        }
-    }
-
-    if (Input::isKeyDown(SDL_SCANCODE_F7)) {
-        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            stereoseparation -= 0.001;
-        } else {
-            stereoseparation -= 0.010;
-        }
-        printf("Stereo decreased increased to %f\n", stereoseparation);
-    }
-
-    if (Input::isKeyDown(SDL_SCANCODE_F8)) {
-        if (Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
-            stereoseparation += 0.001;
-        } else {
-            stereoseparation += 0.010;
-        }
-        printf("Stereo separation increased to %f\n", stereoseparation);
-    }
-
-    if (Input::isKeyPressed(SDL_SCANCODE_TAB) && Tutorial::active) {
-        if (Tutorial::stage != 51) {
-            Tutorial::stagetime = Tutorial::maxtime;
-        }
-        emit_sound_np(consolefailsound, 128.);
-    }
+    /* Pump SDL input events and process non-gameplay related ones */
+    ProcessInput();
 
     /*
     Values of mainmenu :
@@ -3025,27 +2990,6 @@ void Game::Tick()
             }
             Menu::Load();
         }
-        //escape key pressed
-        if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
-            (gameon || mainmenu == 0)) {
-            selected = -1;
-            if (mainmenu == 0 && !winfreeze) {
-                mainmenu = 2; //pause
-            } else if (mainmenu == 1 || mainmenu == 2) {
-                mainmenu = 0; //unpause
-            }
-            //play menu theme
-            if (musictoggle && (mainmenu == 1 || mainmenu == 2)) {
-                OPENAL_SetFrequency(OPENAL_ALL);
-                emit_stream_np(stream_menutheme);
-                pause_sound(leveltheme);
-            }
-            //on resume, play level music
-            if (!mainmenu) {
-                pause_sound(stream_menutheme);
-                resume_stream(leveltheme);
-            }
-        }
     }
 
     if (mainmenu) {
@@ -3062,28 +3006,9 @@ void Game::Tick()
             leveltime += multiplier;
         }
 
-        //keys
-        if (Input::isKeyDown(SDL_SCANCODE_LALT) && Input::isKeyPressed(SDL_SCANCODE_V) && devtools) {
-            freeze = !freeze;
-            if (freeze) {
-                OPENAL_SetFrequency(OPENAL_ALL);
-            }
-        }
-
-        if (Input::isKeyPressed(consolekey) && devtools) {
-            console = !console;
-            if (console) {
-                OPENAL_SetFrequency(OPENAL_ALL);
-            } else {
-                freeze = 0;
-                waiting = false;
-            }
-        }
-
         if (console) {
             freeze = 1;
-        }
-        if (console && !Input::isKeyDown(SDL_SCANCODE_LGUI)) {
+
             inputText(consoletext[0], &consoleselected);
             if (!waiting) {
                 if (!consoletext[0].empty()) {
@@ -3114,21 +3039,6 @@ void Game::Tick()
             oldwinfreeze++;
         }
 
-        if ((Input::isKeyPressed(jumpkey) || Input::isKeyPressed(SDL_SCANCODE_SPACE)) && !campaign) {
-            if (winfreeze) {
-                winfreeze = 0;
-            }
-        }
-        if ((Input::isKeyDown(SDL_SCANCODE_ESCAPE)) && !campaign && gameon) {
-            if (console) {
-                console = false;
-                freeze = 0;
-            } else if (winfreeze) {
-                mainmenu = 9;
-                gameon = 0;
-            }
-        }
-
         if (!freeze && !winfreeze && !(mainmenu && gameon) && (gameon || !gamestarted)) {
 
             //dialogues
@@ -3209,7 +3119,12 @@ void Game::Tick()
                 if (Tutorial::active) {
                     bonusvalue = 0;
                 }
-                bonusvalue /= bonusnum[bonus];
+                if (bonusvalue > 0) {
+                    bonusvalue /= bonusnum[bonus];
+                    if (bonusvalue <= 0) {
+                        bonusvalue = 0;
+                    }
+                }
                 bonustotal += bonusvalue;
             }
             bonustime += multiplier;
@@ -3488,8 +3403,6 @@ void Game::Tick()
                 hawkcalldelay = 16 + abs(Random() % 8);
             }
 
-            doDevKeys();
-
             doAttacks();
 
             doPlayerCollisions();
@@ -3514,8 +3427,8 @@ void Game::Tick()
             static bool respawnkeydown;
             if (!editorenabled &&
                 (whichlevel != -2 &&
-                     (Input::isKeyDown(SDL_SCANCODE_Z) &&
-                      Input::isKeyDown(SDL_SCANCODE_LGUI) &&
+                     (Input::isKeyDown(SDL_SCANCODE_K) &&
+                      Input::isKeyDown(SDL_SCANCODE_LALT) &&
                       devtools) ||
                  (Input::isKeyDown(jumpkey) &&
                   !respawnkeydown &&
@@ -3568,7 +3481,7 @@ void Game::Tick()
                         Person::players[i]->targetheadyaw = yaw;
                         Person::players[i]->targetheadpitch = pitch;
                     }
-                    if (i != 0 && Person::players[i]->aitype == playercontrolled && !Dialog::inDialog()) {
+                    if (i != 0 && Person::players[i]->isPlayerControlled() && !Dialog::inDialog()) {
                         if (!Animation::animations[Person::players[i]->animTarget].attack &&
                             Person::players[i]->animTarget != staggerbackhighanim &&
                             Person::players[i]->animTarget != staggerbackhardanim &&
@@ -3705,7 +3618,7 @@ void Game::Tick()
 
                     //pick up weapon
                     if (Person::players[i]->throwkeydown && !Person::players[i]->throwtogglekeydown) {
-                        if (Person::players[i]->weaponactive == -1 &&
+                        if (!Person::players[i]->hasWeapon() &&
                             Person::players[i]->num_weapons < 2 &&
                             (Person::players[i]->isIdle() ||
                              Person::players[i]->isCrouch() ||
@@ -3713,19 +3626,19 @@ void Game::Tick()
                              Person::players[i]->animTarget == rollanim ||
                              Person::players[i]->animTarget == backhandspringanim ||
                              Person::players[i]->isFlip() ||
-                             Person::players[i]->aitype != playercontrolled)) {
+                             !Person::players[i]->isPlayerControlled())) {
                             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) &&
+                                     Person::players[i]->isPlayerControlled()) &&
                                     weapons[j].owner == -1 &&
-                                    Person::players[i]->weaponactive == -1) {
+                                    !Person::players[i]->hasWeapon()) {
                                     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]->isPlayerControlled()) {
                                                 Person::players[i]->throwtogglekeydown = 1;
                                                 Person::players[i]->setTargetAnimation(crouchremoveknifeanim);
                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
@@ -3736,11 +3649,11 @@ 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]->isPlayerControlled()) &&
                                                         weapons[j].owner == -1 ||
                                                     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 (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2 && !Person::players[i]->hasWeapon()) {
                                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 1 || Person::players[i]->victim) {
                                                             if (weapons[j].getType() != staff) {
                                                                 emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
@@ -3753,7 +3666,7 @@ void Game::Tick()
                                             }
                                         } else if ((Person::players[i]->isIdle() ||
                                                     Person::players[i]->isFlip() ||
-                                                    Person::players[i]->aitype != playercontrolled) &&
+                                                    !Person::players[i]->isPlayerControlled()) &&
                                                    distsq(&Person::players[i]->coords, &weapons[j].position) < 5 &&
                                                    Person::players[i]->coords.y < weapons[j].position.y) {
                                             if (!Person::players[i]->isFlip()) {
@@ -3766,14 +3679,14 @@ void Game::Tick()
                                                 Person::players[i]->hasvictim = 0;
 
                                                 for (unsigned k = 0; k < weapons.size(); k++) {
-                                                    if (Person::players[i]->weaponactive == -1) {
+                                                    if (!Person::players[i]->hasWeapon()) {
                                                         if ((weapons[k].velocity.x == 0 && weapons[k].velocity.y == 0 && weapons[k].velocity.z == 0 ||
-                                                             Person::players[i]->aitype == playercontrolled) &&
+                                                             Person::players[i]->isPlayerControlled()) &&
                                                                 weapons[k].owner == -1 ||
                                                             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]->hasWeapon()) {
                                                                 if (weapons[k].getType() != staff) {
                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
                                                                 }
@@ -3795,7 +3708,7 @@ void Game::Tick()
                                 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 (!Person::players[i]->hasWeapon()) {
                                             if (j != i) {
                                                 if (Person::players[j]->num_weapons &&
                                                     Person::players[j]->skeleton.free &&
@@ -3896,7 +3809,7 @@ void Game::Tick()
                                 }
                             }
                         }
-                        if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
+                        if (Person::players[i]->hasWeapon() && Person::players[i]->isPlayerControlled()) {
                             if (weapons[Person::players[i]->weaponids[0]].getType() == knife) {
                                 if (Person::players[i]->isIdle() ||
                                     Person::players[i]->isRun() ||
@@ -3921,7 +3834,7 @@ void Game::Tick()
                                                                 Person::players[i]->targettilt2 = pitchTo(Person::players[i]->coords, Person::players[j]->coords);
                                                             }
                                                             if (Person::players[i]->isFlip()) {
-                                                                if (Person::players[i]->weaponactive != -1) {
+                                                                if (Person::players[i]->hasWeapon()) {
                                                                     Person::players[i]->throwtogglekeydown = 1;
                                                                     Person::players[i]->victim = Person::players[j];
                                                                     XYZ aim;
@@ -3947,7 +3860,7 @@ void Game::Tick()
                                 }
                             }
                         }
-                        if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
+                        if (Person::players[i]->hasWeapon() && Person::players[i]->isPlayerControlled()) {
                             if (Person::players[i]->isCrouch() || Person::players[i]->animTarget == sneakanim) {
                                 Person::players[i]->throwtogglekeydown = 1;
                                 XYZ tempVelocity = Person::players[i]->velocity * .2;
@@ -3972,16 +3885,16 @@ void Game::Tick()
                     }
 
                     //draw weapon
-                    if (i == 0 || !Person::players[0]->dead || (Person::players[i]->weaponactive != -1)) {
+                    if (i == 0 || !Person::players[0]->dead || (Person::players[i]->hasWeapon())) {
                         if (Person::players[i]->drawkeydown && !Person::players[i]->drawtogglekeydown ||
                             (Person::players[i]->num_weapons == 2) &&
-                                (Person::players[i]->weaponactive == -1) &&
+                                (!Person::players[i]->hasWeapon()) &&
                                 Person::players[i]->isIdle() ||
                             Person::players[0]->dead &&
-                                (Person::players[i]->weaponactive != -1) &&
+                                (Person::players[i]->hasWeapon()) &&
                                 i != 0) {
                             bool isgood = true;
-                            if (Person::players[i]->weaponactive != -1) {
+                            if (Person::players[i]->hasWeapon()) {
                                 if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == staff) {
                                     isgood = false;
                                 }
@@ -3992,8 +3905,8 @@ 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]->isPlayerControlled() &&
+                                      Person::players[0]->hasWeapon() &&
                                       Person::players[i]->isRun())) &&
                                     Person::players[i]->num_weapons &&
                                     weapons[Person::players[i]->weaponids[0]].getType() == sword) {
@@ -4009,7 +3922,7 @@ void Game::Tick()
                     }
 
                     //clean weapon
-                    if (Person::players[i]->weaponactive != -1) {
+                    if (Person::players[i]->hasWeapon()) {
                         if (Person::players[i]->isCrouch() &&
                             weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
                             bloodtoggle &&
@@ -4187,7 +4100,7 @@ void Game::Tick()
                                 }
                                 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]->isPlayerControlled())*/) {
                                 Person::players[i]->setTargetAnimation(climbanim);
                                 Person::players[i]->frameTarget = 1;
                                 Person::players[i]->jumpclimb = 1;
@@ -4348,7 +4261,7 @@ 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]->isPlayerControlled()) {
                                     Person::players[i]->velocity.y = 7;
                                     Person::players[i]->crouchtogglekeydown = 1;
                                 } else {
@@ -4384,7 +4297,7 @@ void Game::Tick()
                                 (((!floatjump &&
                                    !editorenabled) ||
                                   !devtools) ||
-                                 Person::players[i]->aitype != playercontrolled)) {
+                                 !Person::players[i]->isPlayerControlled())) {
                                 if (Person::players[i]->jumppower > multiplier * 6) {
                                     Person::players[i]->velocity.y += multiplier * 6;
                                     Person::players[i]->jumppower -= multiplier * 6;
@@ -4534,10 +4447,6 @@ void Game::Tick()
             oldviewer = viewer;
         }
     }
-
-    if (Input::isKeyPressed(SDL_SCANCODE_F1)) {
-        Screenshot();
-    }
 }
 
 void Game::TickOnce()
@@ -4594,6 +4503,7 @@ void Game::TickOnceAfter()
                  Person::players[i]->aitype == gethelptype ||
                  Person::players[i]->aitype == searchtype) &&
                 !Person::players[i]->dead &&
+                !Person::players[i]->isPlayerFriend() &&
                 (Person::players[i]->animTarget != sneakattackedanim &&
                  Person::players[i]->animTarget != knifesneakattackedanim &&
                  Person::players[i]->animTarget != swordsneakattackedanim)) {