Source/GameTick.cpp

   1 /*
   2 Copyright (C) 2003, 2010 - Wolfire Games
   3 Copyright (C) 2010-2016 - Lugaru contributors (see AUTHORS file)
   4
   5 This file is part of Lugaru.
   6
   7 Lugaru is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 Lugaru is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 // Enable full math definitions
  22 #define _USE_MATH_DEFINES
  23
  24 #include "Game.hpp"
  25
  26 #include "Animation/Animation.hpp"
  27 #include "Audio/openal_wrapper.hpp"
  28 #include "Devtools/ConsoleCmds.hpp"
  29 #include "Level/Awards.hpp"
  30 #include "Level/Campaign.hpp"
  31 #include "Level/Dialog.hpp"
  32 #include "Level/Hotspot.hpp"
  33 #include "Menu/Menu.hpp"
  34 #include "Tutorial.hpp"
  35 #include "User/Settings.hpp"
  36 #include "Utils/Folders.hpp"
  37 #include "Utils/Input.hpp"
  38
  39 #if PLATFORM_UNIX
  40 #include <sys/stat.h>
  41 #include <sys/types.h>
  42 #include <unistd.h>
  43 #else
  44 #include <direct.h>
  45 #endif
  46
  47 #include <algorithm>
  48 #include <cmath>
  49 #include <ctime>
  50 #include <dirent.h>
  51 #include <limits>
  52 #include <set>
  53
  54 using namespace std;
  55 using namespace Game;
  56
  57 // Added more evilness needed for MSVC
  58 #ifdef _MSC_VER
  59 #define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
  60 #define snprintf(buf, size, format, ...) _sprintf_p(buf, size, format)
  61 #endif
  62
  63 extern float multiplier;
  64 extern XYZ viewer;
  65 extern int environment;
  66 extern Terrain terrain;
  67 extern float screenwidth, screenheight;
  68 extern float gravity;
  69 extern int detail;
  70 extern float texdetail;
  71 extern int slomo;
  72 extern float slomodelay;
  73 extern bool floatjump;
  74 extern float volume;
  75 extern Light light;
  76 extern float camerashake;
  77 extern float woozy;
  78 extern float blackout;
  79 extern bool cellophane;
  80 extern bool musictoggle;
  81 extern int difficulty;
  82 extern int bloodtoggle;
  83 extern bool invertmouse;
  84 extern float windvar;
  85 extern float precipdelay;
  86 extern XYZ viewerfacing;
  87 extern bool ambientsound;
  88 extern bool mousejump;
  89 extern float viewdistance;
  90 extern bool freeze;
  91 extern XYZ windvector;
  92 extern bool devtools;
  93 int leveltheme;
  94 extern int mainmenu;
  95 extern int oldmainmenu;
  96 extern bool visibleloading;
  97 extern XYZ envsound[30];
  98 extern float envsoundvol[30];
  99 extern int numenvsounds;
 100 extern float envsoundlife[30];
 101 extern float usermousesensitivity;
 102 extern bool ismotionblur;
 103 extern bool showdamagebar; // (des)activate the damage bar
 104 extern bool decalstoggle;
 105 extern bool skyboxtexture;
 106 extern float skyboxr;
 107 extern float skyboxg;
 108 extern float skyboxb;
 109 extern float skyboxlightr;
 110 extern float skyboxlightg;
 111 extern float skyboxlightb;
 112 extern float fadestart;
 113 extern float slomospeed;
 114 extern float slomofreq;
 115 extern float smoketex;
 116 extern bool againbonus;
 117 extern bool reversaltrain;
 118 extern bool canattack;
 119 extern bool cananger;
 120 extern float damagedealt;
 121 extern int maptype;
 122 extern int editoractive;
 123 extern int editorpathtype;
 124
 125 extern float hostiletime;
 126
 127 extern bool gamestarted;
 128
 129 extern int hostile;
 130
 131 extern bool stillloading;
 132 extern bool winfreeze;
 133
 134 extern bool campaign;
 135
 136 extern void toggleFullscreen();
 137
 138 bool won = false;
 139 int whichchoice = 0;
 140 bool winhotspot = false;
 141 bool windialogue = false;
 142 bool realthreat = 0;
 143 XYZ cameraloc;
 144 float cameradist = 0;
 145 bool oldattackkey = 0;
 146 int whichlevel = 0;
 147 float musicvolume[4] = {};
 148 float oldmusicvolume[4] = {};
 149 int musicselected = 0;
 150
 151 const char* rabbitskin[] = {
 152     "Textures/Fur3.jpg",
 153     "Textures/Fur.jpg",
 154     "Textures/Fur2.jpg",
 155     "Textures/Lynx.jpg",
 156     "Textures/Otter.jpg",
 157     "Textures/Opal.jpg",
 158     "Textures/Sable.jpg",
 159     "Textures/Chocolate.jpg",
 160     "Textures/BW2.jpg",
 161     "Textures/WB2.jpg"
 162 };
 163
 164 const char* wolfskin[] = {
 165     "Textures/Wolf.jpg",
 166     "Textures/DarkWolf.jpg",
 167     "Textures/SnowWolf.jpg"
 168 };
 169
 170 const char** creatureskin[] = { rabbitskin, wolfskin };
 171
 172 #define STATIC_ASSERT(x) extern int s_a_dummy[2 * (!!(x)) - 1];
 173 STATIC_ASSERT(rabbittype == 0 && wolftype == 1)
 174
 175 // utility functions
 176
 177 // TODO: this is slightly incorrect
 178 float roughDirection(XYZ vec)
 179 {
 180     Normalise(&vec);
 181     float angle = -asin(-vec.x) * 180 / M_PI;
 182     if (vec.z < 0)
 183         angle = 180 - angle;
 184     return angle;
 185 }
 186 float roughDirectionTo(XYZ start, XYZ end)
 187 {
 188     return roughDirection(end - start);
 189 }
 190 inline float pitchOf(XYZ vec)
 191 {
 192     Normalise(&vec);
 193     return -asin(vec.y) * 180 / M_PI;
 194 }
 195 float pitchTo(XYZ start, XYZ end)
 196 {
 197     return pitchOf(end - start);
 198 }
 199 float sq(float n)
 200 {
 201     return n * n;
 202 }
 203 inline float stepTowardf(float from, float to, float by)
 204 {
 205     if (fabs(from - to) < by)
 206         return to;
 207     else if (from > to)
 208         return from - by;
 209     else
 210         return from + by;
 211 }
 212
 213 void Game::playdialoguescenesound()
 214 {
 215     XYZ temppos;
 216     temppos = Person::players.at(Dialog::currentScene().participantfocus)->coords;
 217     temppos = temppos - viewer;
 218     Normalise(&temppos);
 219     temppos += viewer;
 220
 221     int sound = -1;
 222     switch (Dialog::currentScene().sound) {
 223         case -6:
 224             sound = alarmsound;
 225             break;
 226         case -4:
 227             sound = consolefailsound;
 228             break;
 229         case -3:
 230             sound = consolesuccesssound;
 231             break;
 232         case -2:
 233             sound = firestartsound;
 234             break;
 235         case -1:
 236             sound = fireendsound;
 237             break;
 238         case 1:
 239             sound = rabbitchitter;
 240             break;
 241         case 2:
 242             sound = rabbitchitter2;
 243             break;
 244         case 3:
 245             sound = rabbitpainsound;
 246             break;
 247         case 4:
 248             sound = rabbitpain1sound;
 249             break;
 250         case 5:
 251             sound = rabbitattacksound;
 252             break;
 253         case 6:
 254             sound = rabbitattack2sound;
 255             break;
 256         case 7:
 257             sound = rabbitattack3sound;
 258             break;
 259         case 8:
 260             sound = rabbitattack4sound;
 261             break;
 262         case 9:
 263             sound = growlsound;
 264             break;
 265         case 10:
 266             sound = growl2sound;
 267             break;
 268         case 11:
 269             sound = snarlsound;
 270             break;
 271         case 12:
 272             sound = snarl2sound;
 273             break;
 274         case 13:
 275             sound = barksound;
 276             break;
 277         case 14:
 278             sound = bark2sound;
 279             break;
 280         case 15:
 281             sound = bark3sound;
 282             break;
 283         case 16:
 284             sound = barkgrowlsound;
 285             break;
 286         default:
 287             break;
 288     }
 289     if (sound != -1)
 290         emit_sound_at(sound, temppos);
 291 }
 292
 293 // ================================================================
 294
 295 int Game::findClosestPlayer()
 296 {
 297     int closest = -1;
 298     float closestdist = std::numeric_limits<float>::max();
 299
 300     for (unsigned i = 1; i < Person::players.size(); i++) {
 301         float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
 302         if (distance < closestdist) {
 303             closestdist = distance;
 304             closest = i;
 305         }
 306     }
 307     return closest;
 308 }
 309
 310 static int findClosestObject()
 311 {
 312     int closest = -1;
 313     float closestdist = std::numeric_limits<float>::max();
 314
 315     for (unsigned int i = 0; i < Object::objects.size(); i++) {
 316         float distance = distsq(&Object::objects[i]->position,
 317                                 &Person::players[0]->coords);
 318         if (distance < closestdist) {
 319             closestdist = distance;
 320             closest = (int)i;
 321         }
 322     }
 323     return closest;
 324 }
 325
 326 static void cmd_dispatch(const string cmd)
 327 {
 328     int i, n_cmds = sizeof(cmd_names) / sizeof(cmd_names[0]);
 329
 330     for (i = 0; i < n_cmds; i++)
 331         if (cmd.substr(0, cmd.find(' ')) == string(cmd_names[i])) {
 332             cout << "|" << cmd.substr(cmd.find(' ') + 1) << "|" << endl;
 333             cmd_handlers[i](cmd.substr(cmd.find(' ') + 1).c_str());
 334             break;
 335         }
 336     emit_sound_np(i < n_cmds ? consolesuccesssound : consolefailsound);
 337 }
 338
 339 /********************> Tick() <*****/
 340 extern bool save_screenshot(const char* fname);
 341 void Screenshot(void)
 342 {
 343     char filename[1024];
 344     time_t t = time(NULL);
 345     struct tm* tme = localtime(&t);
 346     sprintf(filename, "Screenshot-%04d%02d%02d-%02d%02d%02d.png",
 347             tme->tm_year + 1900, tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);
 348
 349     save_screenshot(filename);
 350 }
 351
 352 void Game::SetUpLighting()
 353 {
 354     if (environment == snowyenvironment)
 355         light.setColors(.65, .65, .7, .4, .4, .44);
 356     if (environment == desertenvironment)
 357         light.setColors(.95, .95, .95, .4, .35, .3);
 358     if (environment == grassyenvironment)
 359         light.setColors(.95, .95, 1, .4, .4, .44);
 360     if (!skyboxtexture)
 361         light.setColors(1, 1, 1, .4, .4, .4);
 362     float average;
 363     average = (skyboxlightr + skyboxlightg + skyboxlightb) / 3;
 364     light.color[0] *= (skyboxlightr + average) / 2;
 365     light.color[1] *= (skyboxlightg + average) / 2;
 366     light.color[2] *= (skyboxlightb + average) / 2;
 367     light.ambient[0] *= (skyboxlightr + average) / 2;
 368     light.ambient[1] *= (skyboxlightg + average) / 2;
 369     light.ambient[2] *= (skyboxlightb + average) / 2;
 370 }
 371
 372 void Setenvironment(int which)
 373 {
 374     LOGFUNC;
 375
 376     LOG(" Setting environment...");
 377
 378     float temptexdetail;
 379     environment = which;
 380
 381     pause_sound(stream_snowtheme);
 382     pause_sound(stream_grasstheme);
 383     pause_sound(stream_deserttheme);
 384     pause_sound(stream_wind);
 385     pause_sound(stream_desertambient);
 386
 387     if (environment == snowyenvironment) {
 388         windvector = 0;
 389         windvector.z = 3;
 390         if (ambientsound)
 391             emit_stream_np(stream_wind);
 392
 393         Object::treetextureptr.load("Textures/SnowTree.png", 0);
 394         Object::bushtextureptr.load("Textures/BushSnow.png", 0);
 395         Object::rocktextureptr.load("Textures/BoulderSnow.jpg", 1);
 396         Object::boxtextureptr.load("Textures/SnowBox.jpg", 1);
 397
 398         footstepsound = footstepsn1;
 399         footstepsound2 = footstepsn2;
 400         footstepsound3 = footstepst1;
 401         footstepsound4 = footstepst2;
 402
 403         terraintexture.load("Textures/Snow.jpg", 1);
 404         terraintexture2.load("Textures/Rock.jpg", 1);
 405
 406         temptexdetail = texdetail;
 407         if (texdetail > 1)
 408             texdetail = 4;
 409         skybox->load("Textures/Skybox(snow)/Front.jpg",
 410                      "Textures/Skybox(snow)/Left.jpg",
 411                      "Textures/Skybox(snow)/Back.jpg",
 412                      "Textures/Skybox(snow)/Right.jpg",
 413                      "Textures/Skybox(snow)/Up.jpg",
 414                      "Textures/Skybox(snow)/Down.jpg");
 415
 416         texdetail = temptexdetail;
 417     } else if (environment == desertenvironment) {
 418         windvector = 0;
 419         windvector.z = 2;
 420         Object::treetextureptr.load("Textures/DesertTree.png", 0);
 421         Object::bushtextureptr.load("Textures/BushDesert.png", 0);
 422         Object::rocktextureptr.load("Textures/BoulderDesert.jpg", 1);
 423         Object::boxtextureptr.load("Textures/DesertBox.jpg", 1);
 424
 425         if (ambientsound)
 426             emit_stream_np(stream_desertambient);
 427
 428         footstepsound = footstepsn1;
 429         footstepsound2 = footstepsn2;
 430         footstepsound3 = footstepsn1;
 431         footstepsound4 = footstepsn2;
 432
 433         terraintexture.load("Textures/Sand.jpg", 1);
 434         terraintexture2.load("Textures/SandSlope.jpg", 1);
 435
 436         temptexdetail = texdetail;
 437         if (texdetail > 1)
 438             texdetail = 4;
 439         skybox->load("Textures/Skybox(sand)/Front.jpg",
 440                      "Textures/Skybox(sand)/Left.jpg",
 441                      "Textures/Skybox(sand)/Back.jpg",
 442                      "Textures/Skybox(sand)/Right.jpg",
 443                      "Textures/Skybox(sand)/Up.jpg",
 444                      "Textures/Skybox(sand)/Down.jpg");
 445
 446         texdetail = temptexdetail;
 447     } else if (environment == grassyenvironment) {
 448         windvector = 0;
 449         windvector.z = 2;
 450         Object::treetextureptr.load("Textures/Tree.png", 0);
 451         Object::bushtextureptr.load("Textures/Bush.png", 0);
 452         Object::rocktextureptr.load("Textures/Boulder.jpg", 1);
 453         Object::boxtextureptr.load("Textures/GrassBox.jpg", 1);
 454
 455         if (ambientsound)
 456             emit_stream_np(stream_wind, 100.);
 457
 458         footstepsound = footstepgr1;
 459         footstepsound2 = footstepgr2;
 460         footstepsound3 = footstepst1;
 461         footstepsound4 = footstepst2;
 462
 463         terraintexture.load("Textures/GrassDirt.jpg", 1);
 464         terraintexture2.load("Textures/MossRock.jpg", 1);
 465
 466         temptexdetail = texdetail;
 467         if (texdetail > 1)
 468             texdetail = 4;
 469         skybox->load("Textures/Skybox(grass)/Front.jpg",
 470                      "Textures/Skybox(grass)/Left.jpg",
 471                      "Textures/Skybox(grass)/Back.jpg",
 472                      "Textures/Skybox(grass)/Right.jpg",
 473                      "Textures/Skybox(grass)/Up.jpg",
 474                      "Textures/Skybox(grass)/Down.jpg");
 475
 476         texdetail = temptexdetail;
 477     }
 478     temptexdetail = texdetail;
 479     texdetail = 1;
 480     terrain.load("Textures/HeightMap.png");
 481
 482     texdetail = temptexdetail;
 483 }
 484
 485 bool Game::LoadLevel(int which)
 486 {
 487     stealthloading = 0;
 488     whichlevel = which;
 489
 490     if (which == -1) {
 491         return LoadLevel("tutorial", true);
 492     } else if (which >= 0 && which <= 15) {
 493         char buf[32];
 494         snprintf(buf, 32, "map%d", which + 1); // challenges
 495         return LoadLevel(buf);
 496     } else {
 497         return LoadLevel("mapsave");
 498     }
 499 }
 500
 501 bool Game::LoadLevel(const std::string& name, bool tutorial)
 502 {
 503     const std::string level_path = Folders::getResourcePath("Maps/" + name);
 504     if (!Folders::file_exists(level_path)) {
 505         perror(std::string("LoadLevel: Could not open file '" + level_path).c_str());
 506         return false;
 507     }
 508
 509     int indemo; // FIXME this should be removed
 510     int templength;
 511     float lamefloat;
 512
 513     LOGFUNC;
 514
 515     LOG(std::string("Loading level...") + name);
 516
 517     if (!gameon)
 518         visibleloading = true;
 519     if (stealthloading)
 520         visibleloading = false;
 521     if (!stillloading)
 522         loadtime = 0;
 523     gamestarted = 1;
 524
 525     numenvsounds = 0;
 526
 527     Tutorial::active = tutorial;
 528
 529     if (Tutorial::active) {
 530         Tutorial::stage = 0;
 531     }
 532     if (Tutorial::stage == 0) {
 533         Tutorial::stagetime = 0;
 534         Tutorial::maxtime = 1;
 535     }
 536     pause_sound(whooshsound);
 537     pause_sound(stream_firesound);
 538
 539     int mapvers;
 540     FILE* tfile;
 541     errno = 0;
 542     tfile = Folders::openMandatoryFile(level_path, "rb");
 543
 544     pause_sound(stream_firesound);
 545     scoreadded = 0;
 546     windialogue = false;
 547     hostiletime = 0;
 548     won = 0;
 549
 550     //~ Animation::animations[bounceidleanim].Load("Idle", middleheight, neutral);
 551
 552     Dialog::dialogs.clear();
 553
 554     Dialog::indialogue = -1;
 555     cameramode = 0;
 556
 557     damagedealt = 0;
 558     damagetaken = 0;
 559
 560     if (Account::hasActive()) {
 561         difficulty = Account::active().getDifficulty();
 562     }
 563
 564     Hotspot::hotspots.clear();
 565     Hotspot::current = -1;
 566     bonustime = 1;
 567
 568     skyboxtexture = 1;
 569     skyboxr = 1;
 570     skyboxg = 1;
 571     skyboxb = 1;
 572
 573     freeze = 0;
 574     winfreeze = 0;
 575
 576     for (unsigned char i = 0; i < 100; i++)
 577         bonusnum[i] = 0;
 578
 579     numfalls = 0;
 580     numflipfail = 0;
 581     numseen = 0;
 582     numstaffattack = 0;
 583     numswordattack = 0;
 584     numknifeattack = 0;
 585     numunarmedattack = 0;
 586     numescaped = 0;
 587     numflipped = 0;
 588     numwallflipped = 0;
 589     numthrowkill = 0;
 590     numafterkill = 0;
 591     numreversals = 0;
 592     numattacks = 0;
 593     maxalarmed = 0;
 594     numresponded = 0;
 595
 596     bonustotal = startbonustotal;
 597     bonus = 0;
 598     gameon = 1;
 599     changedelay = 0;
 600     if (console) {
 601         emit_sound_np(consolesuccesssound);
 602         freeze = 0;
 603         console = false;
 604     }
 605
 606     if (!stealthloading) {
 607         terrain.decals.clear();
 608         Sprite::deleteSprites();
 609
 610         for (int i = 0; i < subdivision; i++) {
 611             for (int j = 0; j < subdivision; j++) {
 612                 terrain.patchobjects[i][j].clear();
 613             }
 614         }
 615         Game::LoadingScreen();
 616     }
 617
 618     weapons.clear();
 619     Person::players.resize(1);
 620
 621     funpackf(tfile, "Bi", &mapvers);
 622     if (mapvers < 12) {
 623         cerr << name << " has obsolete map version " << mapvers << endl;
 624     }
 625     if (mapvers >= 15)
 626         funpackf(tfile, "Bi", &indemo);
 627     else
 628         indemo = 0;
 629     if (mapvers >= 5)
 630         funpackf(tfile, "Bi", &maptype);
 631     else
 632         maptype = mapkilleveryone;
 633     if (mapvers >= 6)
 634         funpackf(tfile, "Bi", &hostile);
 635     else
 636         hostile = 1;
 637     if (mapvers >= 4)
 638         funpackf(tfile, "Bf Bf", &viewdistance, &fadestart);
 639     else {
 640         viewdistance = 100;
 641         fadestart = .6;
 642     }
 643     if (mapvers >= 2)
 644         funpackf(tfile, "Bb Bf Bf Bf", &skyboxtexture, &skyboxr, &skyboxg, &skyboxb);
 645     else {
 646         skyboxtexture = 1;
 647         skyboxr = 1;
 648         skyboxg = 1;
 649         skyboxb = 1;
 650     }
 651     if (mapvers >= 10)
 652         funpackf(tfile, "Bf Bf Bf", &skyboxlightr, &skyboxlightg, &skyboxlightb);
 653     else {
 654         skyboxlightr = skyboxr;
 655         skyboxlightg = skyboxg;
 656         skyboxlightb = skyboxb;
 657     }
 658     /* TODO - This should be done in an other way so that we can rebuild main player as well (so coords would need to be copied from old ones after rebuilding) */
 659     if (stealthloading) {
 660         funpackf(tfile, "Bf Bf Bf Bf Bf Bi", &lamefloat, &lamefloat, &lamefloat, &lamefloat, &lamefloat, &Person::players[0]->num_weapons);
 661     } else {
 662         funpackf(tfile, "Bf Bf Bf Bf Bf Bi", &Person::players[0]->coords.x, &Person::players[0]->coords.y, &Person::players[0]->coords.z, &Person::players[0]->yaw, &Person::players[0]->targetyaw, &Person::players[0]->num_weapons);
 663     }
 664     if (Person::players[0]->num_weapons > 0 && Person::players[0]->num_weapons < 5)
 665         for (int j = 0; j < Person::players[0]->num_weapons; j++) {
 666             Person::players[0]->weaponids[j] = weapons.size();
 667             int type;
 668             funpackf(tfile, "Bi", &type);
 669             weapons.push_back(Weapon(type, 0));
 670         }
 671
 672     Game::LoadingScreen();
 673
 674     funpackf(tfile, "Bf Bf Bf", &Person::players[0]->armorhead, &Person::players[0]->armorhigh, &Person::players[0]->armorlow);
 675     funpackf(tfile, "Bf Bf Bf", &Person::players[0]->protectionhead, &Person::players[0]->protectionhigh, &Person::players[0]->protectionlow);
 676     funpackf(tfile, "Bf Bf Bf", &Person::players[0]->metalhead, &Person::players[0]->metalhigh, &Person::players[0]->metallow);
 677     funpackf(tfile, "Bf Bf", &Person::players[0]->power, &Person::players[0]->speedmult);
 678
 679     funpackf(tfile, "Bi", &Person::players[0]->numclothes);
 680
 681     if (mapvers >= 9)
 682         funpackf(tfile, "Bi Bi", &Person::players[0]->whichskin, &Person::players[0]->creature);
 683     else {
 684         Person::players[0]->whichskin = 0;
 685         Person::players[0]->creature = rabbittype;
 686     }
 687
 688     Person::players[0]->lastattack = -1;
 689     Person::players[0]->lastattack2 = -1;
 690     Person::players[0]->lastattack3 = -1;
 691
 692     //dialogues
 693     if (mapvers >= 8) {
 694         Dialog::loadDialogs(tfile);
 695     }
 696
 697     for (int k = 0; k < Person::players[0]->numclothes; k++) {
 698         funpackf(tfile, "Bi", &templength);
 699         for (int l = 0; l < templength; l++)
 700             funpackf(tfile, "Bb", &Person::players[0]->clothes[k][l]);
 701         Person::players[0]->clothes[k][templength] = '\0';
 702         funpackf(tfile, "Bf Bf Bf", &Person::players[0]->clothestintr[k], &Person::players[0]->clothestintg[k], &Person::players[0]->clothestintb[k]);
 703     }
 704
 705     funpackf(tfile, "Bi", &environment);
 706
 707     if (environment != oldenvironment)
 708         Setenvironment(environment);
 709     oldenvironment = environment;
 710
 711     Object::LoadObjectsFromFile(tfile, stealthloading);
 712
 713     if (mapvers >= 7) {
 714         int numhotspots;
 715         funpackf(tfile, "Bi", &numhotspots);
 716         if (numhotspots < 0) {
 717             cerr << "Map " << name << " have an invalid number of hotspots" << endl;
 718             numhotspots = 0;
 719         }
 720         Hotspot::hotspots.resize(numhotspots);
 721         for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
 722             funpackf(tfile, "Bi Bf Bf Bf Bf", &Hotspot::hotspots[i].type, &Hotspot::hotspots[i].size, &Hotspot::hotspots[i].position.x, &Hotspot::hotspots[i].position.y, &Hotspot::hotspots[i].position.z);
 723             funpackf(tfile, "Bi", &templength);
 724             if (templength)
 725                 for (int l = 0; l < templength; l++)
 726                     funpackf(tfile, "Bb", &Hotspot::hotspots[i].text[l]);
 727             Hotspot::hotspots[i].text[templength] = '\0';
 728             if (Hotspot::hotspots[i].type == -111)
 729                 indemo = 1;
 730         }
 731     } else {
 732         Hotspot::hotspots.clear();
 733     }
 734
 735     Game::LoadingScreen();
 736
 737     if (!stealthloading) {
 738         Object::ComputeCenter();
 739         Object::ComputeRadius();
 740     }
 741
 742     Game::LoadingScreen();
 743
 744     int numplayers;
 745     funpackf(tfile, "Bi", &numplayers);
 746     if (numplayers > maxplayers) {
 747         cout << "Warning: this level contains more players than allowed" << endl;
 748     }
 749     unsigned j = 1;
 750     for (int i = 1; i < numplayers; i++) {
 751         try {
 752             Person::players.push_back(shared_ptr<Person>(new Person(tfile, mapvers, j)));
 753             j++;
 754         } catch (InvalidPersonException e) {
 755             cerr << "Invalid Person found in " << name << endl;
 756         }
 757     }
 758     Game::LoadingScreen();
 759
 760     funpackf(tfile, "Bi", &numpathpoints);
 761     if (numpathpoints > 30 || numpathpoints < 0)
 762         numpathpoints = 0;
 763     for (int j = 0; j < numpathpoints; j++) {
 764         funpackf(tfile, "Bf Bf Bf Bi", &pathpoint[j].x, &pathpoint[j].y, &pathpoint[j].z, &numpathpointconnect[j]);
 765         for (int k = 0; k < numpathpointconnect[j]; k++) {
 766             funpackf(tfile, "Bi", &pathpointconnect[j][k]);
 767         }
 768     }
 769     Game::LoadingScreen();
 770
 771     funpackf(tfile, "Bf Bf Bf Bf", &mapcenter.x, &mapcenter.y, &mapcenter.z, &mapradius);
 772
 773     SetUpLighting();
 774
 775     if (!stealthloading) {
 776         Object::AddObjectsToTerrain();
 777         terrain.DoShadows();
 778         Game::LoadingScreen();
 779         Object::DoShadows();
 780         Game::LoadingScreen();
 781     }
 782
 783     fclose(tfile);
 784
 785     for (unsigned i = 0; i < Person::players.size(); i++) {
 786         Game::LoadingScreen();
 787         if (i == 0) {
 788             Person::players[i]->burnt = 0;
 789             Person::players[i]->bled = 0;
 790             Person::players[i]->onfire = 0;
 791             Person::players[i]->scale = .2;
 792             if (mapvers < 9) {
 793                 Person::players[i]->creature = rabbittype;
 794             }
 795         }
 796         Person::players[i]->skeleton.free = 0;
 797
 798         Person::players[i]->skeletonLoad();
 799
 800         Person::players[i]->addClothes();
 801
 802         if (i == 0) {
 803             Person::players[i]->animCurrent = bounceidleanim;
 804             Person::players[i]->animTarget = bounceidleanim;
 805             Person::players[i]->frameCurrent = 0;
 806             Person::players[i]->frameTarget = 1;
 807             Person::players[i]->target = 0;
 808         }
 809         Person::players[i]->speed = 1 + (float)(Random() % 100) / 1000;
 810         if (difficulty == 0)
 811             Person::players[i]->speed -= .2;
 812         if (difficulty == 1)
 813             Person::players[i]->speed -= .1;
 814
 815         if (i == 0) {
 816             Person::players[i]->velocity = 0;
 817             Person::players[i]->oldcoords = Person::players[i]->coords;
 818             Person::players[i]->realoldcoords = Person::players[i]->coords;
 819
 820             Person::players[i]->id = i;
 821             Person::players[i]->updatedelay = 0;
 822             Person::players[i]->normalsupdatedelay = 0;
 823
 824             Person::players[i]->proportionhead = 1.2;
 825             Person::players[i]->proportionbody = 1.05;
 826             Person::players[i]->proportionarms = 1.00;
 827             Person::players[i]->proportionlegs = 1.1;
 828             Person::players[i]->proportionlegs.y = 1.05;
 829             Person::players[i]->headless = 0;
 830             Person::players[i]->currentoffset = 0;
 831             Person::players[i]->targetoffset = 0;
 832             if (Person::players[i]->creature == wolftype) {
 833                 Person::players[i]->scale = .23;
 834                 Person::players[i]->damagetolerance = 300;
 835             } else {
 836                 Person::players[i]->damagetolerance = 200;
 837             }
 838         }
 839
 840         Game::LoadingScreen();
 841
 842         if (cellophane) {
 843             Person::players[i]->proportionhead.z = 0;
 844             Person::players[i]->proportionbody.z = 0;
 845             Person::players[i]->proportionarms.z = 0;
 846             Person::players[i]->proportionlegs.z = 0;
 847         }
 848
 849         Person::players[i]->tempanimation = Animation("Tempanim", lowheight, neutral);
 850
 851         if (i == 0) {
 852             Person::players[i]->headmorphness = 0;
 853             Person::players[i]->targetheadmorphness = 1;
 854             Person::players[i]->headmorphstart = 0;
 855             Person::players[i]->headmorphend = 0;
 856
 857             Person::players[i]->pausetime = 0;
 858
 859             Person::players[i]->dead = 0;
 860             Person::players[i]->jumppower = 5;
 861             Person::players[i]->damage = 0;
 862             Person::players[i]->permanentdamage = 0;
 863             Person::players[i]->superpermanentdamage = 0;
 864
 865             Person::players[i]->forwardkeydown = 0;
 866             Person::players[i]->leftkeydown = 0;
 867             Person::players[i]->backkeydown = 0;
 868             Person::players[i]->rightkeydown = 0;
 869             Person::players[i]->jumpkeydown = 0;
 870             Person::players[i]->crouchkeydown = 0;
 871             Person::players[i]->throwkeydown = 0;
 872
 873             Person::players[i]->collided = -10;
 874             Person::players[i]->loaded = 1;
 875             Person::players[i]->bloodloss = 0;
 876             Person::players[i]->weaponactive = -1;
 877             Person::players[i]->weaponstuck = -1;
 878             Person::players[i]->bleeding = 0;
 879             Person::players[i]->deathbleeding = 0;
 880             Person::players[i]->stunned = 0;
 881             Person::players[i]->hasvictim = 0;
 882             Person::players[i]->wentforweapon = 0;
 883         }
 884     }
 885
 886     Person::players[0]->aitype = playercontrolled;
 887
 888     if (difficulty == 1) {
 889         Person::players[0]->power = 1 / .9;
 890         Person::players[0]->damagetolerance = 250;
 891     } else if (difficulty == 0) {
 892         Person::players[0]->power = 1 / .8;
 893         Person::players[0]->damagetolerance = 300;
 894         Person::players[0]->armorhead *= 1.5;
 895         Person::players[0]->armorhigh *= 1.5;
 896         Person::players[0]->armorlow *= 1.5;
 897     }
 898
 899     cameraloc = Person::players[0]->coords;
 900     cameraloc.y += 5;
 901     yaw = Person::players[0]->yaw;
 902
 903     hawkcoords = Person::players[0]->coords;
 904     hawkcoords.y += 30;
 905
 906     Game::LoadingScreen();
 907
 908     LOG("Starting background music...");
 909
 910     OPENAL_StopSound(OPENAL_ALL);
 911     if (ambientsound) {
 912         if (environment == snowyenvironment) {
 913             emit_stream_np(stream_wind);
 914         } else if (environment == desertenvironment) {
 915             emit_stream_np(stream_desertambient);
 916         } else if (environment == grassyenvironment) {
 917             emit_stream_np(stream_wind, 100.);
 918         }
 919     }
 920     oldmusicvolume[0] = 0;
 921     oldmusicvolume[1] = 0;
 922     oldmusicvolume[2] = 0;
 923     oldmusicvolume[3] = 0;
 924
 925     leveltime = 0;
 926     wonleveltime = 0;
 927     visibleloading = false;
 928
 929     return true;
 930 }
 931
 932 void doDevKeys()
 933 {
 934     float headprop, bodyprop, armprop, legprop;
 935     if (!devtools) {
 936         return;
 937     }
 938
 939     if (Input::isKeyDown(SDL_SCANCODE_LALT)) {
 940         /* Invicible */
 941         if (Input::isKeyPressed(SDL_SCANCODE_H)) {
 942             Person::players[0]->damagetolerance = 200000;
 943             Person::players[0]->damage = 0;
 944             Person::players[0]->burnt = 0;
 945             Person::players[0]->permanentdamage = 0;
 946             Person::players[0]->superpermanentdamage = 0;
 947         }
 948
 949         /* Change environment */
 950         if (Input::isKeyPressed(SDL_SCANCODE_J)) {
 951             environment++;
 952             if (environment > 2)
 953                 environment = 0;
 954             Setenvironment(environment);
 955         }
 956
 957         /* Camera mode */
 958         if (Input::isKeyPressed(SDL_SCANCODE_C)) {
 959             cameramode = !cameramode;
 960         }
 961
 962         /* Toggle Slow motion */
 963         if (Input::isKeyPressed(SDL_SCANCODE_B)) {
 964             slomo = 1 - slomo;
 965             slomodelay = 1000;
 966         }
 967
 968         /* Ragdoll */
 969         if (Input::isKeyPressed(SDL_SCANCODE_N)) {
 970             Person::players[0]->RagDoll(0);
 971
 972             emit_sound_at(whooshsound, Person::players[0]->coords, 128.);
 973         }
 974
 975         /* Grow tree leaves?? */
 976         if (Input::isKeyPressed(SDL_SCANCODE_Y)) {
 977             for (auto& an_object : Object::objects) {
 978                 if (an_object->type == treeleavestype) {
 979                     an_object->scale *= .9;
 980                 }
 981             }
 982         }
 983
 984         /* Change (or add) weapon */
 985         if (Input::isKeyPressed(SDL_SCANCODE_X)) {
 986             int closest = 0;
 987             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
 988                 closest = findClosestPlayer();
 989             }
 990
 991             if (closest >= 0) {
 992                 if (Person::players[closest]->num_weapons > 0) {
 993                     if (weapons[Person::players[closest]->weaponids[0]].getType() == sword)
 994                         weapons[Person::players[closest]->weaponids[0]].setType(staff);
 995                     else if (weapons[Person::players[closest]->weaponids[0]].getType() == staff)
 996                         weapons[Person::players[closest]->weaponids[0]].setType(knife);
 997                     else
 998                         weapons[Person::players[closest]->weaponids[0]].setType(sword);
 999                 } else {
1000                     Person::players[closest]->weaponids[0] = weapons.size();
1001
1002                     weapons.push_back(Weapon(knife, closest));
1003
1004                     Person::players[closest]->num_weapons = 1;
1005                 }
1006             }
1007         }
1008
1009         /* Change yaw? */
1010         if (Input::isKeyDown(SDL_SCANCODE_U)) {
1011             int closest = 0;
1012             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1013                 closest = findClosestPlayer();
1014             }
1015
1016             if (closest >= 0) {
1017                 Person::players[closest]->yaw += multiplier * 50;
1018                 Person::players[closest]->targetyaw = Person::players[closest]->yaw;
1019             }
1020         }
1021
1022         /* Toggle fire */
1023         if (Input::isKeyPressed(SDL_SCANCODE_F)) {
1024             Person::players[0]->onfire = 1 - Person::players[0]->onfire;
1025             if (Person::players[0]->onfire) {
1026                 Person::players[0]->CatchFire();
1027             }
1028             if (!Person::players[0]->onfire) {
1029                 emit_sound_at(fireendsound, Person::players[0]->coords);
1030                 pause_sound(stream_firesound);
1031             }
1032         }
1033
1034         /* Change skin */
1035         if (Input::isKeyPressed(SDL_SCANCODE_O) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1036             int closest = 0;
1037             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1038                 closest = findClosestPlayer();
1039             }
1040
1041             if (closest >= 0) {
1042                 Person::players[closest]->whichskin++;
1043                 if (Person::players[closest]->whichskin > 9)
1044                     Person::players[closest]->whichskin = 0;
1045                 if (Person::players[closest]->whichskin > 2 && Person::players[closest]->creature == wolftype)
1046                     Person::players[closest]->whichskin = 0;
1047
1048                 Person::players[closest]->skeleton.drawmodel.textureptr.load(creatureskin[Person::players[closest]->creature][Person::players[closest]->whichskin], 1,
1049                                                                              &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
1050             }
1051
1052             Person::players[closest]->addClothes();
1053         }
1054
1055         /* Change creature type */
1056         if (Input::isKeyPressed(SDL_SCANCODE_O) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1057             int closest = 0;
1058             if (!Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1059                 closest = findClosestPlayer();
1060             }
1061
1062             if (closest >= 0) {
1063                 if (Person::players[closest]->creature == wolftype) {
1064                     headprop = Person::players[closest]->proportionhead.x / 1.1;
1065                     bodyprop = Person::players[closest]->proportionbody.x / 1.1;
1066                     armprop = Person::players[closest]->proportionarms.x / 1.1;
1067                     legprop = Person::players[closest]->proportionlegs.x / 1.1;
1068                 } else {
1069                     // rabbittype
1070                     headprop = Person::players[closest]->proportionhead.x / 1.2;
1071                     bodyprop = Person::players[closest]->proportionbody.x / 1.05;
1072                     armprop = Person::players[closest]->proportionarms.x / 1.00;
1073                     legprop = Person::players[closest]->proportionlegs.x / 1.1;
1074                 }
1075
1076                 if (Person::players[closest]->creature == rabbittype) {
1077                     Person::players[closest]->creature = wolftype;
1078                     Person::players[closest]->whichskin = 0;
1079                     Person::players[closest]->skeletonLoad();
1080
1081                     Person::players[closest]->proportionhead = 1.1;
1082                     Person::players[closest]->proportionbody = 1.1;
1083                     Person::players[closest]->proportionarms = 1.1;
1084                     Person::players[closest]->proportionlegs = 1.1;
1085                     Person::players[closest]->proportionlegs.y = 1.1;
1086                     Person::players[closest]->scale = .23 * 5 * Person::players[0]->scale;
1087
1088                     Person::players[closest]->damagetolerance = 300;
1089                 } else {
1090                     Person::players[closest]->creature = rabbittype;
1091                     Person::players[closest]->whichskin = 0;
1092                     Person::players[closest]->skeletonLoad(true);
1093
1094                     Person::players[closest]->proportionhead = 1.2;
1095                     Person::players[closest]->proportionbody = 1.05;
1096                     Person::players[closest]->proportionarms = 1.00;
1097                     Person::players[closest]->proportionlegs = 1.1;
1098                     Person::players[closest]->proportionlegs.y = 1.05;
1099                     Person::players[closest]->scale = .2 * 5 * Person::players[0]->scale;
1100
1101                     Person::players[closest]->damagetolerance = 200;
1102                 }
1103
1104                 if (Person::players[closest]->creature == wolftype) {
1105                     Person::players[closest]->proportionhead = 1.1 * headprop;
1106                     Person::players[closest]->proportionbody = 1.1 * bodyprop;
1107                     Person::players[closest]->proportionarms = 1.1 * armprop;
1108                     Person::players[closest]->proportionlegs = 1.1 * legprop;
1109                 }
1110
1111                 if (Person::players[closest]->creature == rabbittype) {
1112                     Person::players[closest]->proportionhead = 1.2 * headprop;
1113                     Person::players[closest]->proportionbody = 1.05 * bodyprop;
1114                     Person::players[closest]->proportionarms = 1.00 * armprop;
1115                     Person::players[closest]->proportionlegs = 1.1 * legprop;
1116                     Person::players[closest]->proportionlegs.y = 1.05 * legprop;
1117                 }
1118             }
1119         }
1120
1121         /* Decapitate */
1122         if (((Input::isKeyPressed(SDL_SCANCODE_I) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
1123             int closest = -1;
1124             float closestdist = std::numeric_limits<float>::max();
1125
1126             for (unsigned i = 1; i < Person::players.size(); i++) {
1127                 float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
1128                 if (!Person::players[i]->headless)
1129                     if (distance < closestdist) {
1130                         closestdist = distance;
1131                         closest = i;
1132                     }
1133             }
1134
1135             XYZ flatfacing2, flatvelocity2;
1136             XYZ blah;
1137             if (closest != -1 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
1138                 blah = Person::players[closest]->coords;
1139                 XYZ headspurtdirection;
1140                 //int i = Person::players[closest]->skeleton.jointlabels[head];
1141                 Joint& headjoint = Person::players[closest]->joint(head);
1142                 for (unsigned k = 0; k < Person::players[closest]->skeleton.joints.size(); k++) {
1143                     if (!Person::players[closest]->skeleton.free)
1144                         flatvelocity2 = Person::players[closest]->velocity;
1145                     if (Person::players[closest]->skeleton.free)
1146                         flatvelocity2 = headjoint.velocity;
1147                     if (!Person::players[closest]->skeleton.free)
1148                         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;
1149                     if (Person::players[closest]->skeleton.free)
1150                         flatfacing2 = headjoint.position * Person::players[closest]->scale + Person::players[closest]->coords;
1151                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
1152                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
1153                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
1154                     headspurtdirection = headjoint.position - Person::players[closest]->jointPos(neck);
1155                     Normalise(&headspurtdirection);
1156                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, .6, 1);
1157                     flatvelocity2 += headspurtdirection * 8;
1158                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 / 2, 1, 1, 1, .16, 1);
1159                 }
1160                 Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
1161
1162                 emit_sound_at(splattersound, blah);
1163                 emit_sound_at(breaksound2, blah, 100.);
1164
1165                 if (Person::players[closest]->skeleton.free == 2)
1166                     Person::players[closest]->skeleton.free = 0;
1167                 Person::players[closest]->RagDoll(0);
1168                 Person::players[closest]->dead = 2;
1169                 Person::players[closest]->headless = 1;
1170                 Person::players[closest]->DoBloodBig(3, 165);
1171
1172                 camerashake += .3;
1173             }
1174         }
1175
1176         /* Explode */
1177         if (((Input::isKeyPressed(SDL_SCANCODE_I) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
1178             int closest = findClosestPlayer();
1179             XYZ flatfacing2, flatvelocity2;
1180             XYZ blah;
1181             if (closest >= 0 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
1182                 blah = Person::players[closest]->coords;
1183                 emit_sound_at(splattersound, blah);
1184                 emit_sound_at(breaksound2, blah);
1185
1186                 for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
1187                     if (!Person::players[closest]->skeleton.free)
1188                         flatvelocity2 = Person::players[closest]->velocity;
1189                     if (Person::players[closest]->skeleton.free)
1190                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
1191                     if (!Person::players[closest]->skeleton.free)
1192                         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;
1193                     if (Person::players[closest]->skeleton.free)
1194                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
1195                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
1196                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
1197                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
1198                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
1199                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .3, 1);
1200                     Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
1201                 }
1202
1203                 for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
1204                     if (!Person::players[closest]->skeleton.free)
1205                         flatvelocity2 = Person::players[closest]->velocity;
1206                     if (Person::players[closest]->skeleton.free)
1207                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
1208                     if (!Person::players[closest]->skeleton.free)
1209                         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;
1210                     if (Person::players[closest]->skeleton.free)
1211                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
1212                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
1213                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
1214                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
1215                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
1216                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .4, 1);
1217                 }
1218
1219                 for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
1220                     if (!Person::players[closest]->skeleton.free)
1221                         flatvelocity2 = Person::players[closest]->velocity;
1222                     if (Person::players[closest]->skeleton.free)
1223                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
1224                     if (!Person::players[closest]->skeleton.free)
1225                         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;
1226                     if (Person::players[closest]->skeleton.free)
1227                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
1228                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
1229                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
1230                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
1231                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, 3, 1);
1232                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, .4, 1);
1233                 }
1234
1235                 for (unsigned i = 0; i < Person::players[closest]->skeleton.joints.size(); i++) {
1236                     if (!Person::players[closest]->skeleton.free)
1237                         flatvelocity2 = Person::players[closest]->velocity;
1238                     if (Person::players[closest]->skeleton.free)
1239                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
1240                     if (!Person::players[closest]->skeleton.free)
1241                         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;
1242                     if (Person::players[closest]->skeleton.free)
1243                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
1244                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
1245                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
1246                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
1247                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, 3, 1);
1248                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, .4, 1);
1249                 }
1250
1251                 XYZ temppos;
1252                 for (unsigned j = 0; j < Person::players.size(); j++) {
1253                     if (int(j) != closest) {
1254                         if (distsq(&Person::players[j]->coords, &Person::players[closest]->coords) < 25) {
1255                             Person::players[j]->DoDamage((25 - distsq(&Person::players[j]->coords, &Person::players[closest]->coords)) * 60);
1256                             if (Person::players[j]->skeleton.free == 2)
1257                                 Person::players[j]->skeleton.free = 1;
1258                             Person::players[j]->skeleton.longdead = 0;
1259                             Person::players[j]->RagDoll(0);
1260                             for (unsigned i = 0; i < Person::players[j]->skeleton.joints.size(); i++) {
1261                                 temppos = Person::players[j]->skeleton.joints[i].position + Person::players[j]->coords;
1262                                 if (distsq(&temppos, &Person::players[closest]->coords) < 25) {
1263                                     flatvelocity2 = temppos - Person::players[closest]->coords;
1264                                     Normalise(&flatvelocity2);
1265                                     Person::players[j]->skeleton.joints[i].velocity += flatvelocity2 * ((20 - distsq(&temppos, &Person::players[closest]->coords)) * 20);
1266                                 }
1267                             }
1268                         }
1269                     }
1270                 }
1271
1272                 Person::players[closest]->DoDamage(10000);
1273                 Person::players[closest]->RagDoll(0);
1274                 Person::players[closest]->dead = 2;
1275                 Person::players[closest]->coords = 20;
1276                 Person::players[closest]->skeleton.free = 2;
1277
1278                 camerashake += .6;
1279             }
1280         }
1281
1282         /* Enable editor */
1283         if (Input::isKeyPressed(SDL_SCANCODE_M) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1284             editorenabled = !editorenabled;
1285             if (editorenabled) {
1286                 Person::players[0]->damagetolerance = 100000;
1287             } else {
1288                 Person::players[0]->damagetolerance = 200;
1289             }
1290             Person::players[0]->damage = 0; // these lines were in both if and else, but I think they would better fit in the if
1291             Person::players[0]->permanentdamage = 0;
1292             Person::players[0]->superpermanentdamage = 0;
1293             Person::players[0]->bloodloss = 0;
1294             Person::players[0]->deathbleeding = 0;
1295         }
1296     }
1297
1298     //skip level
1299     if (whichlevel != -2 && Input::isKeyPressed(SDL_SCANCODE_K) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !editorenabled) {
1300         targetlevel++;
1301         if (targetlevel > numchallengelevels - 1)
1302             targetlevel = 0;
1303         loading = 1;
1304         leveltime = 5;
1305     }
1306
1307     if (editorenabled) {
1308         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1309             int closest = findClosestPlayer();
1310             if (closest >= 0) {
1311                 Person::players.erase(Person::players.begin() + closest);
1312             }
1313         }
1314
1315         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1316             int closest = findClosestObject();
1317             if (closest >= 0) {
1318                 Object::objects[closest]->position.y -= 500;
1319             }
1320         }
1321
1322         if (Input::isKeyPressed(SDL_SCANCODE_M) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1323             if (Object::objects.size() < max_objects - 1) {
1324                 XYZ scenecoords;
1325                 scenecoords.x = Person::players[0]->coords.x;
1326                 scenecoords.z = Person::players[0]->coords.z;
1327                 scenecoords.y = Person::players[0]->coords.y - 3;
1328                 if (editortype == bushtype)
1329                     scenecoords.y = Person::players[0]->coords.y - .5;
1330                 if (editortype == firetype)
1331                     scenecoords.y = Person::players[0]->coords.y - .5;
1332                 float temprotat, temprotat2;
1333                 temprotat = editoryaw;
1334                 temprotat2 = editorpitch;
1335                 if (temprotat < 0 || editortype == bushtype)
1336                     temprotat = Random() % 360;
1337                 if (temprotat2 < 0)
1338                     temprotat2 = Random() % 360;
1339
1340                 Object::MakeObject(editortype, scenecoords, (int)temprotat - ((int)temprotat) % 30, (int)temprotat2, editorsize);
1341                 if (editortype == treetrunktype)
1342                     Object::MakeObject(treeleavestype, scenecoords, Random() % 360 * (temprotat2 < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
1343             }
1344         }
1345
1346         if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1347             Person::players.push_back(shared_ptr<Person>(new Person()));
1348
1349             Person::players.back()->id = Person::players.size() - 1;
1350
1351             Person::players.back()->scale = Person::players[0]->scale;
1352             Person::players.back()->creature = rabbittype;
1353             Person::players.back()->howactive = editoractive;
1354
1355             int k = abs(Random() % 2) + 1;
1356             if (k == 0) {
1357                 Person::players.back()->whichskin = 0;
1358             } else if (k == 1) {
1359                 Person::players.back()->whichskin = 1;
1360             } else {
1361                 Person::players.back()->whichskin = 2;
1362             }
1363
1364             Person::players.back()->skeletonLoad(true);
1365
1366             Person::players.back()->skeleton.drawmodelclothes.textureptr.load("Textures/Belt.png", 1);
1367             Person::players.back()->speed = 1 + (float)(Random() % 100) / 1000;
1368
1369             Person::players.back()->targetyaw = Person::players[0]->targetyaw;
1370             Person::players.back()->yaw = Person::players[0]->yaw;
1371
1372             Person::players.back()->coords = Person::players[0]->coords;
1373             Person::players.back()->oldcoords = Person::players.back()->coords;
1374             Person::players.back()->realoldcoords = Person::players.back()->coords;
1375
1376             if (Person::players[0]->creature == wolftype) {
1377                 headprop = Person::players[0]->proportionhead.x / 1.1;
1378                 bodyprop = Person::players[0]->proportionbody.x / 1.1;
1379                 armprop = Person::players[0]->proportionarms.x / 1.1;
1380                 legprop = Person::players[0]->proportionlegs.x / 1.1;
1381             } else {
1382                 // rabbittype
1383                 headprop = Person::players[0]->proportionhead.x / 1.2;
1384                 bodyprop = Person::players[0]->proportionbody.x / 1.05;
1385                 armprop = Person::players[0]->proportionarms.x / 1.00;
1386                 legprop = Person::players[0]->proportionlegs.x / 1.1;
1387             }
1388
1389             if (Person::players.back()->creature == wolftype) {
1390                 Person::players.back()->proportionhead = 1.1 * headprop;
1391                 Person::players.back()->proportionbody = 1.1 * bodyprop;
1392                 Person::players.back()->proportionarms = 1.1 * armprop;
1393                 Person::players.back()->proportionlegs = 1.1 * legprop;
1394             }
1395
1396             if (Person::players.back()->creature == rabbittype) {
1397                 Person::players.back()->proportionhead = 1.2 * headprop;
1398                 Person::players.back()->proportionbody = 1.05 * bodyprop;
1399                 Person::players.back()->proportionarms = 1.00 * armprop;
1400                 Person::players.back()->proportionlegs = 1.1 * legprop;
1401                 Person::players.back()->proportionlegs.y = 1.05 * legprop;
1402             }
1403
1404             if (cellophane) {
1405                 Person::players.back()->proportionhead.z = 0;
1406                 Person::players.back()->proportionbody.z = 0;
1407                 Person::players.back()->proportionarms.z = 0;
1408                 Person::players.back()->proportionlegs.z = 0;
1409             }
1410
1411             Person::players.back()->tempanimation = Animation("Tempanim", lowheight, neutral);
1412
1413             Person::players.back()->damagetolerance = 200;
1414
1415             Person::players.back()->protectionhead = Person::players[0]->protectionhead;
1416             Person::players.back()->protectionhigh = Person::players[0]->protectionhigh;
1417             Person::players.back()->protectionlow = Person::players[0]->protectionlow;
1418             Person::players.back()->armorhead = Person::players[0]->armorhead;
1419             Person::players.back()->armorhigh = Person::players[0]->armorhigh;
1420             Person::players.back()->armorlow = Person::players[0]->armorlow;
1421             Person::players.back()->metalhead = Person::players[0]->metalhead;
1422             Person::players.back()->metalhigh = Person::players[0]->metalhigh;
1423             Person::players.back()->metallow = Person::players[0]->metallow;
1424
1425             Person::players.back()->immobile = Person::players[0]->immobile;
1426
1427             Person::players.back()->numclothes = Person::players[0]->numclothes;
1428             for (int i = 0; i < Person::players.back()->numclothes; i++) {
1429                 strcpy(Person::players.back()->clothes[i], Person::players[0]->clothes[i]);
1430                 Person::players.back()->clothestintr[i] = Person::players[0]->clothestintr[i];
1431                 Person::players.back()->clothestintg[i] = Person::players[0]->clothestintg[i];
1432                 Person::players.back()->clothestintb[i] = Person::players[0]->clothestintb[i];
1433             }
1434             Person::players.back()->addClothes();
1435
1436             Person::players.back()->power = Person::players[0]->power;
1437             Person::players.back()->speedmult = Person::players[0]->speedmult;
1438
1439             Person::players.back()->loaded = true;
1440         }
1441
1442         if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1443             if (Person::players.back()->numwaypoints < 90) {
1444                 Person::players.back()->waypoints[Person::players.back()->numwaypoints] = Person::players[0]->coords;
1445                 Person::players.back()->waypointtype[Person::players.back()->numwaypoints] = editorpathtype;
1446                 Person::players.back()->numwaypoints++;
1447             }
1448         }
1449
1450         if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1451             if (numpathpoints < 30) {
1452                 bool connected, alreadyconnected;
1453                 connected = 0;
1454                 if (numpathpoints > 1)
1455                     for (int i = 0; i < numpathpoints; i++) {
1456                         if (distsq(&pathpoint[i], &Person::players[0]->coords) < .5 && i != pathpointselected && !connected) {
1457                             alreadyconnected = 0;
1458                             for (int j = 0; j < numpathpointconnect[pathpointselected]; j++) {
1459                                 if (pathpointconnect[pathpointselected][j] == i)
1460                                     alreadyconnected = 1;
1461                             }
1462                             if (!alreadyconnected) {
1463                                 numpathpointconnect[pathpointselected]++;
1464                                 connected = 1;
1465                                 pathpointconnect[pathpointselected][numpathpointconnect[pathpointselected] - 1] = i;
1466                             }
1467                         }
1468                     }
1469                 if (!connected) {
1470                     numpathpoints++;
1471                     pathpoint[numpathpoints - 1] = Person::players[0]->coords;
1472                     numpathpointconnect[numpathpoints - 1] = 0;
1473                     if (numpathpoints > 1 && pathpointselected != -1) {
1474                         numpathpointconnect[pathpointselected]++;
1475                         pathpointconnect[pathpointselected][numpathpointconnect[pathpointselected] - 1] = numpathpoints - 1;
1476                     }
1477                     pathpointselected = numpathpoints - 1;
1478                 }
1479             }
1480         }
1481
1482         if (Input::isKeyPressed(SDL_SCANCODE_PERIOD)) {
1483             pathpointselected++;
1484             if (pathpointselected >= numpathpoints)
1485                 pathpointselected = -1;
1486         }
1487
1488         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1489             pathpointselected--;
1490             if (pathpointselected <= -2)
1491                 pathpointselected = numpathpoints - 1;
1492         }
1493
1494         if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1495             if (pathpointselected != -1) {
1496                 numpathpoints--;
1497                 pathpoint[pathpointselected] = pathpoint[numpathpoints];
1498                 numpathpointconnect[pathpointselected] = numpathpointconnect[numpathpoints];
1499                 for (int i = 0; i < numpathpointconnect[pathpointselected]; i++) {
1500                     pathpointconnect[pathpointselected][i] = pathpointconnect[numpathpoints][i];
1501                 }
1502                 for (int i = 0; i < numpathpoints; i++) {
1503                     for (int j = 0; j < numpathpointconnect[i]; j++) {
1504                         if (pathpointconnect[i][j] == pathpointselected) {
1505                             pathpointconnect[i][j] = pathpointconnect[i][numpathpointconnect[i] - 1];
1506                             numpathpointconnect[i]--;
1507                         }
1508                         if (pathpointconnect[i][j] == numpathpoints) {
1509                             pathpointconnect[i][j] = pathpointselected;
1510                         }
1511                     }
1512                 }
1513                 pathpointselected = numpathpoints - 1;
1514             }
1515         }
1516
1517         if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1518             editortype--;
1519             if (editortype == treeleavestype || editortype == 10)
1520                 editortype--;
1521             if (editortype < 0)
1522                 editortype = firetype;
1523         }
1524
1525         if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1526             editortype++;
1527             if (editortype == treeleavestype || editortype == 10)
1528                 editortype++;
1529             if (editortype > firetype)
1530                 editortype = 0;
1531         }
1532
1533         if (Input::isKeyDown(SDL_SCANCODE_LEFT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1534             editoryaw -= multiplier * 100;
1535             if (editoryaw < -.01)
1536                 editoryaw = -.01;
1537         }
1538
1539         if (Input::isKeyDown(SDL_SCANCODE_RIGHT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1540             editoryaw += multiplier * 100;
1541         }
1542
1543         if (Input::isKeyDown(SDL_SCANCODE_UP) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1544             editorsize += multiplier;
1545         }
1546
1547         if (Input::isKeyDown(SDL_SCANCODE_DOWN) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1548             editorsize -= multiplier;
1549             if (editorsize < .1)
1550                 editorsize = .1;
1551         }
1552
1553         if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1554             mapradius -= multiplier * 10;
1555         }
1556
1557         if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1558             mapradius += multiplier * 10;
1559         }
1560
1561         if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1562             editorpitch += multiplier * 100;
1563         }
1564
1565         if (Input::isKeyDown(SDL_SCANCODE_DOWN) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
1566             editorpitch -= multiplier * 100;
1567             if (editorpitch < -.01)
1568                 editorpitch = -.01;
1569         }
1570
1571         if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Object::objects.size() && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
1572             int closest = findClosestObject();
1573             if (closest >= 0) {
1574                 Object::DeleteObject(closest);
1575             }
1576         }
1577     }
1578 }
1579
1580 void doJumpReversals()
1581 {
1582     for (unsigned k = 0; k < Person::players.size(); k++) {
1583         for (unsigned i = k + 1; i < Person::players.size(); i++) {
1584             if (Person::players[k]->skeleton.free == 0 &&
1585                 Person::players[i]->skeleton.oldfree == 0 &&
1586                 (Person::players[i]->animTarget == jumpupanim ||
1587                  Person::players[k]->animTarget == jumpupanim) &&
1588                 (Person::players[i]->aitype == playercontrolled ||
1589                  Person::players[k]->aitype == playercontrolled) &&
1590                 ((Person::players[i]->aitype == attacktypecutoff && Person::players[i]->stunned <= 0) ||
1591                  (Person::players[k]->aitype == attacktypecutoff && Person::players[k]->stunned <= 0))) {
1592                 if (distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 10 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5) &&
1593                     distsqflat(&Person::players[i]->coords, &Person::players[k]->coords) < 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
1594                     //TODO: refactor two huge similar ifs
1595                     if (Person::players[i]->animTarget == jumpupanim &&
1596                         Person::players[k]->animTarget != getupfrombackanim &&
1597                         Person::players[k]->animTarget != getupfromfrontanim &&
1598                         Animation::animations[Person::players[k]->animTarget].height == middleheight &&
1599                         normaldotproduct(Person::players[i]->velocity, Person::players[k]->coords - Person::players[i]->coords) < 0 &&
1600                         ((Person::players[k]->aitype == playercontrolled && Person::players[k]->attackkeydown) ||
1601                          Person::players[k]->aitype != playercontrolled)) {
1602                         Person::players[i]->victim = Person::players[k];
1603                         Person::players[i]->velocity = 0;
1604                         Person::players[i]->animCurrent = jumpreversedanim;
1605                         Person::players[i]->animTarget = jumpreversedanim;
1606                         Person::players[i]->frameCurrent = 0;
1607                         Person::players[i]->frameTarget = 1;
1608                         Person::players[i]->targettilt2 = 0;
1609                         Person::players[k]->victim = Person::players[i];
1610                         Person::players[k]->velocity = 0;
1611                         Person::players[k]->animCurrent = jumpreversalanim;
1612                         Person::players[k]->animTarget = jumpreversalanim;
1613                         Person::players[k]->frameCurrent = 0;
1614                         Person::players[k]->frameTarget = 1;
1615                         Person::players[k]->targettilt2 = 0;
1616                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 1) {
1617                             Person::players[i]->animCurrent = rabbitkickreversedanim;
1618                             Person::players[i]->animTarget = rabbitkickreversedanim;
1619                             Person::players[i]->frameCurrent = 1;
1620                             Person::players[i]->frameTarget = 2;
1621                             Person::players[k]->animCurrent = rabbitkickreversalanim;
1622                             Person::players[k]->animTarget = rabbitkickreversalanim;
1623                             Person::players[k]->frameCurrent = 1;
1624                             Person::players[k]->frameTarget = 2;
1625                         }
1626                         Person::players[i]->target = 0;
1627                         Person::players[k]->oldcoords = Person::players[k]->coords;
1628                         Person::players[i]->coords = Person::players[k]->coords;
1629                         Person::players[k]->targetyaw = Person::players[i]->targetyaw;
1630                         Person::players[k]->yaw = Person::players[i]->targetyaw;
1631                         if (Person::players[k]->aitype == attacktypecutoff)
1632                             Person::players[k]->stunned = .5;
1633                     }
1634                     if (Person::players[k]->animTarget == jumpupanim &&
1635                         Person::players[i]->animTarget != getupfrombackanim &&
1636                         Person::players[i]->animTarget != getupfromfrontanim &&
1637                         Animation::animations[Person::players[i]->animTarget].height == middleheight &&
1638                         normaldotproduct(Person::players[k]->velocity, Person::players[i]->coords - Person::players[k]->coords) < 0 &&
1639                         ((Person::players[i]->aitype == playercontrolled && Person::players[i]->attackkeydown) ||
1640                          Person::players[i]->aitype != playercontrolled)) {
1641                         Person::players[k]->victim = Person::players[i];
1642                         Person::players[k]->velocity = 0;
1643                         Person::players[k]->animCurrent = jumpreversedanim;
1644                         Person::players[k]->animTarget = jumpreversedanim;
1645                         Person::players[k]->frameCurrent = 0;
1646                         Person::players[k]->frameTarget = 1;
1647                         Person::players[k]->targettilt2 = 0;
1648                         Person::players[i]->victim = Person::players[k];
1649                         Person::players[i]->velocity = 0;
1650                         Person::players[i]->animCurrent = jumpreversalanim;
1651                         Person::players[i]->animTarget = jumpreversalanim;
1652                         Person::players[i]->frameCurrent = 0;
1653                         Person::players[i]->frameTarget = 1;
1654                         Person::players[i]->targettilt2 = 0;
1655                         if (Person::players[k]->coords.y < Person::players[i]->coords.y + 1) {
1656                             Person::players[k]->animTarget = rabbitkickreversedanim;
1657                             Person::players[k]->animCurrent = rabbitkickreversedanim;
1658                             Person::players[i]->animCurrent = rabbitkickreversalanim;
1659                             Person::players[i]->animTarget = rabbitkickreversalanim;
1660                             Person::players[k]->frameCurrent = 1;
1661                             Person::players[k]->frameTarget = 2;
1662                             Person::players[i]->frameCurrent = 1;
1663                             Person::players[i]->frameTarget = 2;
1664                         }
1665                         Person::players[k]->target = 0;
1666                         Person::players[i]->oldcoords = Person::players[i]->coords;
1667                         Person::players[k]->coords = Person::players[i]->coords;
1668                         Person::players[i]->targetyaw = Person::players[k]->targetyaw;
1669                         Person::players[i]->yaw = Person::players[k]->targetyaw;
1670                         if (Person::players[i]->aitype == attacktypecutoff)
1671                             Person::players[i]->stunned = .5;
1672                     }
1673                 }
1674             }
1675         }
1676     }
1677 }
1678
1679 void doAerialAcrobatics()
1680 {
1681     static XYZ facing, flatfacing;
1682     for (unsigned k = 0; k < Person::players.size(); k++) {
1683         Person::players[k]->turnspeed = 500;
1684
1685         if ((Person::players[k]->isRun() &&
1686              ((Person::players[k]->targetyaw != rabbitrunninganim &&
1687                Person::players[k]->targetyaw != wolfrunninganim) ||
1688               Person::players[k]->frameTarget == 4)) ||
1689             Person::players[k]->animTarget == removeknifeanim ||
1690             Person::players[k]->animTarget == crouchremoveknifeanim ||
1691             Person::players[k]->animTarget == flipanim ||
1692             Person::players[k]->animTarget == fightsidestep ||
1693             Person::players[k]->animTarget == walkanim) {
1694             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed);
1695         }
1696
1697         if (Person::players[k]->isStop() ||
1698             Person::players[k]->isLanding() ||
1699             Person::players[k]->animTarget == staggerbackhighanim ||
1700             (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent == sneakanim) ||
1701             Person::players[k]->animTarget == staggerbackhardanim ||
1702             Person::players[k]->animTarget == backhandspringanim ||
1703             Person::players[k]->animTarget == dodgebackanim ||
1704             Person::players[k]->animTarget == rollanim ||
1705             (Animation::animations[Person::players[k]->animTarget].attack &&
1706              Person::players[k]->animTarget != rabbitkickanim &&
1707              (Person::players[k]->animTarget != crouchstabanim || Person::players[k]->hasvictim) &&
1708              (Person::players[k]->animTarget != swordgroundstabanim || Person::players[k]->hasvictim))) {
1709             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed * 2);
1710         }
1711
1712         if (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent != sneakanim) {
1713             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed * 4);
1714         }
1715
1716         Person::players[k]->DoStuff();
1717         if (Person::players[k]->immobile && k != 0)
1718             Person::players[k]->coords = Person::players[k]->realoldcoords;
1719
1720         //if player's position has changed (?)
1721         if (distsq(&Person::players[k]->coords, &Person::players[k]->realoldcoords) > 0 &&
1722             !Person::players[k]->skeleton.free &&
1723             Person::players[k]->animTarget != climbanim &&
1724             Person::players[k]->animTarget != hanganim) {
1725             XYZ lowpoint, lowpointtarget, lowpoint2, lowpointtarget2, lowpoint3, lowpointtarget3, lowpoint4, lowpointtarget4, lowpoint5, lowpointtarget5, lowpoint6, lowpointtarget6, lowpoint7, lowpointtarget7, colpoint, colpoint2;
1726             int whichhit;
1727             bool tempcollide = 0;
1728
1729             if (Person::players[k]->collide < -.3)
1730                 Person::players[k]->collide = -.3;
1731             if (Person::players[k]->collide > 1)
1732                 Person::players[k]->collide = 1;
1733             Person::players[k]->collide -= multiplier * 30;
1734
1735             //clip to terrain
1736             Person::players[k]->coords.y = max(Person::players[k]->coords.y, terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z));
1737
1738             for (unsigned int l = 0; l < terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz].size(); l++) {
1739                 unsigned int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
1740                 if (Object::objects[i]->type != rocktype ||
1741                     Object::objects[i]->scale > .5 && Person::players[k]->aitype == playercontrolled ||
1742                     Object::objects[i]->position.y > Person::players[k]->coords.y) {
1743                     lowpoint = Person::players[k]->coords;
1744                     if (Person::players[k]->animTarget != jumpupanim &&
1745                         Person::players[k]->animTarget != jumpdownanim &&
1746                         !Person::players[k]->isFlip())
1747                         lowpoint.y += 1.25;
1748                     else
1749                         lowpoint.y += 1.3;
1750                     if (Person::players[k]->coords.y < terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) &&
1751                         Person::players[k]->coords.y > terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) - .1)
1752                         Person::players[k]->coords.y = terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z);
1753                     if (Person::players[k]->SphereCheck(&lowpoint, 1.3, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
1754                         flatfacing = lowpoint - Person::players[k]->coords;
1755                         Person::players[k]->coords = lowpoint;
1756                         Person::players[k]->coords.y -= 1.3;
1757                         Person::players[k]->collide = 1;
1758                         tempcollide = 1;
1759                         //wall jumps
1760                         //TODO: refactor four similar blocks
1761                         if (Person::players[k]->aitype == playercontrolled &&
1762                             (Person::players[k]->animTarget == jumpupanim ||
1763                              Person::players[k]->animTarget == jumpdownanim ||
1764                              Person::players[k]->isFlip()) &&
1765                             !Person::players[k]->jumptogglekeydown &&
1766                             Person::players[k]->jumpkeydown) {
1767                             lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, -90, 0) * 1.5;
1768                             XYZ tempcoords1 = lowpoint;
1769                             whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1770                             if (whichhit != -1 && fabs(Object::objects[i]->model.Triangles[whichhit].facenormal.y) < .3) {
1771                                 Person::players[k]->setTargetAnimation(walljumpleftanim);
1772                                 emit_sound_at(movewhooshsound, Person::players[k]->coords);
1773                                 if (k == 0)
1774                                     pause_sound(whooshsound);
1775
1776                                 lowpointtarget = DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[i]->yaw, 0);
1777                                 Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
1778                                 if (lowpointtarget.z < 0)
1779                                     Person::players[k]->yaw = 180 - Person::players[k]->yaw;
1780                                 Person::players[k]->targetyaw = Person::players[k]->yaw;
1781                                 Person::players[k]->lowyaw = Person::players[k]->yaw;
1782                                 if (k == 0)
1783                                     numwallflipped++;
1784                             } else {
1785                                 lowpoint = tempcoords1;
1786                                 lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, 90, 0) * 1.5;
1787                                 whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1788                                 if (whichhit != -1 && fabs(Object::objects[i]->model.Triangles[whichhit].facenormal.y) < .3) {
1789                                     Person::players[k]->setTargetAnimation(walljumprightanim);
1790                                     emit_sound_at(movewhooshsound, Person::players[k]->coords);
1791                                     if (k == 0)
1792                                         pause_sound(whooshsound);
1793
1794                                     lowpointtarget = DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[i]->yaw, 0);
1795                                     Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
1796                                     if (lowpointtarget.z < 0)
1797                                         Person::players[k]->yaw = 180 - Person::players[k]->yaw;
1798                                     Person::players[k]->targetyaw = Person::players[k]->yaw;
1799                                     Person::players[k]->lowyaw = Person::players[k]->yaw;
1800                                     if (k == 0)
1801                                         numwallflipped++;
1802                                 } else {
1803                                     lowpoint = tempcoords1;
1804                                     lowpointtarget = lowpoint + Person::players[k]->facing * 2;
1805                                     whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1806                                     if (whichhit != -1 && fabs(Object::objects[i]->model.Triangles[whichhit].facenormal.y) < .3) {
1807                                         Person::players[k]->setTargetAnimation(walljumpbackanim);
1808                                         emit_sound_at(movewhooshsound, Person::players[k]->coords);
1809                                         if (k == 0)
1810                                             pause_sound(whooshsound);
1811
1812                                         lowpointtarget = DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[i]->yaw, 0);
1813                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
1814                                         if (lowpointtarget.z < 0)
1815                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
1816                                         Person::players[k]->targetyaw = Person::players[k]->yaw;
1817                                         Person::players[k]->lowyaw = Person::players[k]->yaw;
1818                                         if (k == 0)
1819                                             numwallflipped++;
1820                                     } else {
1821                                         lowpoint = tempcoords1;
1822                                         lowpointtarget = lowpoint - Person::players[k]->facing * 2;
1823                                         whichhit = Object::objects[i]->model.LineCheck(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1824                                         if (whichhit != -1 && fabs(Object::objects[i]->model.Triangles[whichhit].facenormal.y) < .3) {
1825                                             Person::players[k]->setTargetAnimation(walljumpfrontanim);
1826                                             emit_sound_at(movewhooshsound, Person::players[k]->coords);
1827                                             if (k == 0)
1828                                                 pause_sound(whooshsound);
1829
1830                                             lowpointtarget = DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[i]->yaw, 0);
1831                                             Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
1832                                             if (lowpointtarget.z < 0)
1833                                                 Person::players[k]->yaw = 180 - Person::players[k]->yaw;
1834                                             Person::players[k]->yaw += 180;
1835                                             Person::players[k]->targetyaw = Person::players[k]->yaw;
1836                                             Person::players[k]->lowyaw = Person::players[k]->yaw;
1837                                             if (k == 0)
1838                                                 numwallflipped++;
1839                                         }
1840                                     }
1841                                 }
1842                             }
1843                         }
1844                     }
1845                 } else if (Object::objects[i]->type == rocktype) {
1846                     lowpoint2 = Person::players[k]->coords;
1847                     lowpoint = Person::players[k]->coords;
1848                     lowpoint.y += 2;
1849                     if (Object::objects[i]->model.LineCheck(&lowpoint, &lowpoint2, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1) {
1850                         Person::players[k]->coords = colpoint;
1851                         Person::players[k]->collide = 1;
1852                         tempcollide = 1;
1853
1854                         if (Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) {
1855                             //flipped into a rock
1856                             if (Person::players[k]->isFlip() && Person::players[k]->targetFrame().label == 7)
1857                                 Person::players[k]->RagDoll(0);
1858
1859                             if (Person::players[k]->animTarget == jumpupanim) {
1860                                 Person::players[k]->jumppower = -4;
1861                                 Person::players[k]->animTarget = Person::players[k]->getIdle();
1862                             }
1863                             Person::players[k]->target = 0;
1864                             Person::players[k]->frameTarget = 0;
1865                             Person::players[k]->onterrain = 1;
1866
1867                             if (Person::players[k]->id == 0) {
1868                                 pause_sound(whooshsound);
1869                                 OPENAL_SetVolume(channels[whooshsound], 0);
1870                             }
1871
1872                             //landing
1873                             if ((Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) && !Person::players[k]->wasLanding()) {
1874                                 if (Person::players[k]->isFlip())
1875                                     Person::players[k]->jumppower = -4;
1876                                 Person::players[k]->animTarget = Person::players[k]->getLanding();
1877                                 emit_sound_at(landsound, Person::players[k]->coords, 128.);
1878                                 if (k == 0) {
1879                                     addEnvSound(Person::players[k]->coords);
1880                                 }
1881                             }
1882                         }
1883                     }
1884                 }
1885             }
1886
1887             if (tempcollide)
1888                 for (unsigned int l = 0; l < terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz].size(); l++) {
1889                     int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
1890                     lowpoint = Person::players[k]->coords;
1891                     lowpoint.y += 1.35;
1892                     if (Object::objects[i]->type != rocktype)
1893                         if (Person::players[k]->SphereCheck(&lowpoint, 1.33, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw, &Object::objects[i]->model) != -1) {
1894                             if (Person::players[k]->animTarget != jumpupanim &&
1895                                 Person::players[k]->animTarget != jumpdownanim &&
1896                                 Person::players[k]->onterrain)
1897                                 Person::players[k]->avoidcollided = 1;
1898                             Person::players[k]->coords = lowpoint;
1899                             Person::players[k]->coords.y -= 1.35;
1900                             Person::players[k]->collide = 1;
1901
1902                             if ((Person::players[k]->grabdelay <= 0 || Person::players[k]->aitype != playercontrolled) &&
1903                                 (Person::players[k]->animCurrent != climbanim &&
1904                                      Person::players[k]->animCurrent != hanganim &&
1905                                      !Person::players[k]->isWallJump() ||
1906                                  Person::players[k]->animTarget == jumpupanim ||
1907                                  Person::players[k]->animTarget == jumpdownanim)) {
1908                                 lowpoint = Person::players[k]->coords;
1909                                 Object::objects[i]->model.SphereCheckPossible(&lowpoint, 1.5, &Object::objects[i]->position, &Object::objects[i]->yaw);
1910                                 lowpoint = Person::players[k]->coords;
1911                                 lowpoint.y += .05;
1912                                 facing = 0;
1913                                 facing.z = -1;
1914                                 facing = DoRotation(facing, 0, Person::players[k]->targetyaw + 180, 0);
1915                                 lowpointtarget = lowpoint + facing * 1.4;
1916                                 whichhit = Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1917                                 if (whichhit != -1) {
1918                                     lowpoint = Person::players[k]->coords;
1919                                     lowpoint.y += .1;
1920                                     lowpointtarget = lowpoint + facing * 1.4;
1921                                     lowpoint2 = lowpoint;
1922                                     lowpointtarget2 = lowpointtarget;
1923                                     lowpoint3 = lowpoint;
1924                                     lowpointtarget3 = lowpointtarget;
1925                                     lowpoint4 = lowpoint;
1926                                     lowpointtarget4 = lowpointtarget;
1927                                     lowpoint5 = lowpoint;
1928                                     lowpointtarget5 = lowpointtarget;
1929                                     lowpoint6 = lowpoint;
1930                                     lowpointtarget6 = lowpointtarget;
1931                                     lowpoint7 = lowpoint;
1932                                     lowpointtarget7 = lowpoint;
1933                                     lowpoint2.x += .1;
1934                                     lowpointtarget2.x += .1;
1935                                     lowpoint3.z += .1;
1936                                     lowpointtarget3.z += .1;
1937                                     lowpoint4.x -= .1;
1938                                     lowpointtarget4.x -= .1;
1939                                     lowpoint5.z -= .1;
1940                                     lowpointtarget5.z -= .1;
1941                                     lowpoint6.y += 45 / 13;
1942                                     lowpointtarget6.y += 45 / 13;
1943                                     lowpointtarget6 += facing * .6;
1944                                     lowpointtarget7.y += 90 / 13;
1945                                     whichhit = Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw);
1946                                     if (Object::objects[i]->friction > .5)
1947                                         if (whichhit != -1) {
1948                                             if (Person::players[k]->animTarget != jumpupanim && Person::players[k]->animTarget != jumpdownanim)
1949                                                 Person::players[k]->collided = 1;
1950                                             if (Object::checkcollide(lowpoint7, lowpointtarget7) == -1)
1951                                                 if (Object::checkcollide(lowpoint6, lowpointtarget6) == -1)
1952                                                     if (Object::objects[i]->model.LineCheckPossible(&lowpoint2, &lowpointtarget2,
1953                                                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
1954                                                         Object::objects[i]->model.LineCheckPossible(&lowpoint3, &lowpointtarget3,
1955                                                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
1956                                                         Object::objects[i]->model.LineCheckPossible(&lowpoint4, &lowpointtarget4,
1957                                                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1 &&
1958                                                         Object::objects[i]->model.LineCheckPossible(&lowpoint5, &lowpointtarget5,
1959                                                                                                     &colpoint, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1)
1960                                                         for (int j = 0; j < 45; j++) {
1961                                                             lowpoint = Person::players[k]->coords;
1962                                                             lowpoint.y += (float)j / 13;
1963                                                             lowpointtarget = lowpoint + facing * 1.4;
1964                                                             if (Object::objects[i]->model.LineCheckPossible(&lowpoint, &lowpointtarget,
1965                                                                                                             &colpoint2, &Object::objects[i]->position, &Object::objects[i]->yaw) == -1) {
1966                                                                 if (j <= 6 || j <= 25 && Person::players[k]->animTarget == jumpdownanim)
1967                                                                     break;
1968                                                                 if (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim) {
1969                                                                     lowpoint = Person::players[k]->coords;
1970                                                                     lowpoint.y += (float)j / 13;
1971                                                                     lowpointtarget = lowpoint + facing * 1.3;
1972                                                                     flatfacing = Person::players[k]->coords;
1973                                                                     Person::players[k]->coords = colpoint - DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[k]->yaw, 0) * .01;
1974                                                                     Person::players[k]->coords.y = lowpointtarget.y - .07;
1975                                                                     Person::players[k]->currentoffset = (flatfacing - Person::players[k]->coords) / Person::players[k]->scale;
1976
1977                                                                     if (j > 10 || !Person::players[k]->isRun()) {
1978                                                                         if (Person::players[k]->animTarget == jumpdownanim || Person::players[k]->animTarget == jumpupanim) {
1979                                                                             if (k == 0)
1980                                                                                 pause_sound(whooshsound);
1981                                                                         }
1982                                                                         emit_sound_at(jumpsound, Person::players[k]->coords, 128.);
1983
1984                                                                         lowpointtarget = DoRotation(Object::objects[i]->model.Triangles[whichhit].facenormal, 0, Object::objects[i]->yaw, 0);
1985                                                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
1986                                                                         if (lowpointtarget.z < 0)
1987                                                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
1988                                                                         Person::players[k]->targetyaw = Person::players[k]->yaw;
1989                                                                         Person::players[k]->lowyaw = Person::players[k]->yaw;
1990
1991                                                                         //Person::players[k]->velocity=lowpointtarget*.03;
1992                                                                         Person::players[k]->velocity = 0;
1993
1994                                                                         //climb ledge (?)
1995                                                                         if (Person::players[k]->animTarget == jumpupanim) {
1996                                                                             Person::players[k]->animTarget = climbanim;
1997                                                                             Person::players[k]->jumppower = 0;
1998                                                                             Person::players[k]->jumpclimb = 1;
1999                                                                         }
2000                                                                         Person::players[k]->transspeed = 6;
2001                                                                         Person::players[k]->target = 0;
2002                                                                         Person::players[k]->frameTarget = 1;
2003                                                                         //hang ledge (?)
2004                                                                         if (j > 25) {
2005                                                                             Person::players[k]->setTargetAnimation(hanganim);
2006                                                                             Person::players[k]->jumppower = 0;
2007                                                                         }
2008                                                                     }
2009                                                                     break;
2010                                                                 }
2011                                                             }
2012                                                         }
2013                                         }
2014                                 }
2015                             }
2016                         }
2017                 }
2018             if (Person::players[k]->collide <= 0) {
2019                 //in the air
2020                 if (!Person::players[k]->onterrain &&
2021                     Person::players[k]->animTarget != jumpupanim &&
2022                     Person::players[k]->animTarget != jumpdownanim &&
2023                     Person::players[k]->animTarget != climbanim &&
2024                     Person::players[k]->animTarget != hanganim &&
2025                     !Person::players[k]->isWallJump() &&
2026                     !Person::players[k]->isFlip()) {
2027                     if (Person::players[k]->animCurrent != climbanim &&
2028                         Person::players[k]->animCurrent != tempanim &&
2029                         Person::players[k]->animTarget != backhandspringanim &&
2030                         (Person::players[k]->animTarget != rollanim ||
2031                          Person::players[k]->frameTarget < 2 ||
2032                          Person::players[k]->frameTarget > 6)) {
2033                         //stagger off ledge (?)
2034                         if (Person::players[k]->animTarget == staggerbackhighanim || Person::players[k]->animTarget == staggerbackhardanim)
2035                             Person::players[k]->RagDoll(0);
2036                         Person::players[k]->setTargetAnimation(jumpdownanim);
2037
2038                         if (!k)
2039                             emit_sound_at(whooshsound, Person::players[k]->coords, 128.);
2040                     }
2041                     //gravity
2042                     Person::players[k]->velocity.y += gravity;
2043                 }
2044             }
2045         }
2046         Person::players[k]->realoldcoords = Person::players[k]->coords;
2047     }
2048 }
2049
2050 void doAttacks()
2051 {
2052     static int randattack;
2053     static bool playerrealattackkeydown = 0;
2054
2055     if (!Input::isKeyDown(attackkey))
2056         oldattackkey = 0;
2057     if (oldattackkey)
2058         Person::players[0]->attackkeydown = 0;
2059     if (oldattackkey)
2060         playerrealattackkeydown = 0;
2061     if (!oldattackkey)
2062         playerrealattackkeydown = Input::isKeyDown(attackkey);
2063     if ((Person::players[0]->parriedrecently <= 0 ||
2064          Person::players[0]->weaponactive == -1) &&
2065         (!oldattackkey ||
2066          (realthreat &&
2067           Person::players[0]->lastattack != swordslashanim &&
2068           Person::players[0]->lastattack != knifeslashstartanim &&
2069           Person::players[0]->lastattack != staffhitanim &&
2070           Person::players[0]->lastattack != staffspinhitanim)))
2071         Person::players[0]->attackkeydown = Input::isKeyDown(attackkey);
2072     if (Input::isKeyDown(attackkey) &&
2073         !oldattackkey &&
2074         !Person::players[0]->backkeydown) {
2075         for (unsigned k = 0; k < Person::players.size(); k++) {
2076             if ((Person::players[k]->animTarget == swordslashanim ||
2077                  Person::players[k]->animTarget == staffhitanim ||
2078                  Person::players[k]->animTarget == staffspinhitanim) &&
2079                 Person::players[0]->animCurrent != dodgebackanim &&
2080                 !Person::players[k]->skeleton.free)
2081                 Person::players[k]->Reverse();
2082         }
2083     }
2084
2085     if (!hostile || Dialog::inDialog())
2086         Person::players[0]->attackkeydown = 0;
2087
2088     for (unsigned k = 0; k < Person::players.size(); k++) {
2089         if (Dialog::inDialog())
2090             Person::players[k]->attackkeydown = 0;
2091         if (Person::players[k]->animTarget != rabbitrunninganim && Person::players[k]->animTarget != wolfrunninganim) {
2092             if (Person::players[k]->aitype != playercontrolled)
2093                 Person::players[k]->victim = Person::players[0];
2094             //attack key pressed
2095             if (Person::players[k]->attackkeydown) {
2096                 //dodge backward
2097                 if (Person::players[k]->backkeydown &&
2098                     Person::players[k]->animTarget != backhandspringanim &&
2099                     (Person::players[k]->isIdle() ||
2100                      Person::players[k]->isStop() ||
2101                      Person::players[k]->isRun() ||
2102                      Person::players[k]->animTarget == walkanim)) {
2103                     if (Person::players[k]->jumppower <= 1) {
2104                         Person::players[k]->jumppower -= 2;
2105                     } else {
2106                         for (unsigned i = 0; i < Person::players.size(); i++) {
2107                             if (i == k)
2108                                 continue;
2109                             if (Person::players[i]->animTarget == swordslashanim ||
2110                                 Person::players[i]->animTarget == knifeslashstartanim ||
2111                                 Person::players[i]->animTarget == staffhitanim ||
2112                                 Person::players[i]->animTarget == staffspinhitanim)
2113                                 if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < 6.5 && !Person::players[i]->skeleton.free) {
2114                                     Person::players[k]->setTargetAnimation(dodgebackanim);
2115                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
2116                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
2117                                 }
2118                         }
2119                         if (Person::players[k]->animTarget != dodgebackanim) {
2120                             if (k == 0)
2121                                 numflipped++;
2122                             Person::players[k]->setTargetAnimation(backhandspringanim);
2123                             Person::players[k]->targetyaw = -yaw + 180;
2124                             if (Person::players[k]->leftkeydown)
2125                                 Person::players[k]->targetyaw -= 45;
2126                             if (Person::players[k]->rightkeydown)
2127                                 Person::players[k]->targetyaw += 45;
2128                             Person::players[k]->yaw = Person::players[k]->targetyaw;
2129                             Person::players[k]->jumppower -= 2;
2130                         }
2131                     }
2132                 }
2133                 //attack
2134                 if (!Animation::animations[Person::players[k]->animTarget].attack &&
2135                     !Person::players[k]->backkeydown &&
2136                     (Person::players[k]->isIdle() ||
2137                      Person::players[k]->isRun() ||
2138                      Person::players[k]->animTarget == walkanim ||
2139                      Person::players[k]->animTarget == sneakanim ||
2140                      Person::players[k]->isCrouch())) {
2141                     const int attackweapon = Person::players[k]->weaponactive == -1 ? 0 : weapons[Person::players[k]->weaponids[Person::players[k]->weaponactive]].getType();
2142                     //normal attacks (?)
2143                     Person::players[k]->hasvictim = 0;
2144                     if (Person::players.size() > 1)
2145                         for (unsigned i = 0; i < Person::players.size(); i++) {
2146                             if (i == k || !(k == 0 || i == 0))
2147                                 continue;
2148                             if (!Person::players[k]->hasvictim)
2149                                 if (Animation::animations[Person::players[k]->animTarget].attack != reversal) {
2150                                     //choose an attack
2151                                     const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
2152                                     if (distance < 4.5 &&
2153                                         !Person::players[i]->skeleton.free &&
2154                                         Person::players[i]->howactive < typedead1 &&
2155                                         Person::players[i]->animTarget != jumpreversedanim &&
2156                                         Person::players[i]->animTarget != rabbitkickreversedanim &&
2157                                         Person::players[i]->animTarget != rabbitkickanim &&
2158                                         Person::players[k]->animTarget != rabbitkickanim &&
2159                                         Person::players[i]->animTarget != getupfrombackanim &&
2160                                         (Person::players[i]->animTarget != staggerbackhighanim &&
2161                                          (Person::players[i]->animTarget != staggerbackhardanim || Person::players[i]->targetFrame().label == 6)) &&
2162                                         Person::players[i]->animTarget != jumpdownanim &&
2163                                         Person::players[i]->animTarget != jumpupanim &&
2164                                         Person::players[i]->animTarget != getupfromfrontanim) {
2165                                         Person::players[k]->victim = Person::players[i];
2166                                         Person::players[k]->hasvictim = 1;
2167                                         if (Person::players[k]->aitype == playercontrolled) { //human player
2168                                             //sweep
2169                                             if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2170                                                 Person::players[k]->crouchkeydown &&
2171                                                 Animation::animations[Person::players[i]->animTarget].height != lowheight)
2172                                                 Person::players[k]->animTarget = sweepanim;
2173                                             //winduppunch
2174                                             else if (distance < 1.5 * sq(Person::players[k]->scale * 5) &&
2175                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2176                                                      !Person::players[k]->forwardkeydown &&
2177                                                      !Person::players[k]->leftkeydown &&
2178                                                      !Person::players[k]->rightkeydown &&
2179                                                      !Person::players[k]->crouchkeydown &&
2180                                                      !attackweapon &&
2181                                                      !reversaltrain)
2182                                                 Person::players[k]->animTarget = winduppunchanim;
2183                                             //upunch
2184                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2185                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2186                                                      !Person::players[k]->forwardkeydown &&
2187                                                      !Person::players[k]->leftkeydown &&
2188                                                      !Person::players[k]->rightkeydown &&
2189                                                      !Person::players[k]->crouchkeydown &&
2190                                                      !attackweapon)
2191                                                 Person::players[k]->animTarget = upunchanim;
2192                                             //knifefollow
2193                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2194                                                      Person::players[i]->staggerdelay > 0 &&
2195                                                      attackweapon == knife &&
2196                                                      Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2)
2197                                                 Person::players[k]->animTarget = knifefollowanim;
2198                                             //knifeslashstart
2199                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2200                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2201                                                      !Person::players[k]->forwardkeydown &&
2202                                                      !Person::players[k]->leftkeydown &&
2203                                                      !Person::players[k]->rightkeydown &&
2204                                                      !Person::players[k]->crouchkeydown &&
2205                                                      attackweapon == knife &&
2206                                                      Person::players[k]->weaponmissdelay <= 0)
2207                                                 Person::players[k]->animTarget = knifeslashstartanim;
2208                                             //swordslash
2209                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
2210                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2211                                                      !Person::players[k]->crouchkeydown &&
2212                                                      attackweapon == sword &&
2213                                                      Person::players[k]->weaponmissdelay <= 0)
2214                                                 Person::players[k]->animTarget = swordslashanim;
2215                                             //staffhit
2216                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
2217                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2218                                                      !Person::players[k]->crouchkeydown &&
2219                                                      attackweapon == staff &&
2220                                                      Person::players[k]->weaponmissdelay <= 0 &&
2221                                                      !Person::players[k]->leftkeydown &&
2222                                                      !Person::players[k]->rightkeydown &&
2223                                                      !Person::players[k]->forwardkeydown)
2224                                                 Person::players[k]->animTarget = staffhitanim;
2225                                             //staffspinhit
2226                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
2227                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2228                                                      !Person::players[k]->crouchkeydown &&
2229                                                      attackweapon == staff &&
2230                                                      Person::players[k]->weaponmissdelay <= 0)
2231                                                 Person::players[k]->animTarget = staffspinhitanim;
2232                                             //spinkick
2233                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2234                                                      Animation::animations[Person::players[i]->animTarget].height != lowheight)
2235                                                 Person::players[k]->animTarget = spinkickanim;
2236                                             //lowkick
2237                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2238                                                      Animation::animations[Person::players[i]->animTarget].height == lowheight &&
2239                                                      Animation::animations[Person::players[k]->animTarget].attack != normalattack)
2240                                                 Person::players[k]->animTarget = lowkickanim;
2241                                         } else { //AI player
2242                                             if (distance < 4.5 * sq(Person::players[k]->scale * 5)) {
2243                                                 randattack = abs(Random() % 5);
2244                                                 if (!attackweapon && distance < 2.5 * sq(Person::players[k]->scale * 5)) {
2245                                                     //sweep
2246                                                     if (randattack == 0 && Animation::animations[Person::players[i]->animTarget].height != lowheight)
2247                                                         Person::players[k]->animTarget = sweepanim;
2248                                                     //upunch
2249                                                     else if (randattack == 1 && Animation::animations[Person::players[i]->animTarget].height != lowheight &&
2250                                                              !attackweapon)
2251                                                         Person::players[k]->animTarget = upunchanim;
2252                                                     //spinkick
2253                                                     else if (randattack == 2 && Animation::animations[Person::players[i]->animTarget].height != lowheight)
2254                                                         Person::players[k]->animTarget = spinkickanim;
2255                                                     //lowkick
2256                                                     else if (Animation::animations[Person::players[i]->animTarget].height == lowheight)
2257                                                         Person::players[k]->animTarget = lowkickanim;
2258                                                 }
2259                                                 if (attackweapon) {
2260                                                     //sweep
2261                                                     if ((!Tutorial::active || !attackweapon) &&
2262                                                         distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2263                                                         randattack == 0 &&
2264                                                         Animation::animations[Person::players[i]->animTarget].height != lowheight)
2265                                                         Person::players[k]->animTarget = sweepanim;
2266                                                     //knifeslashstart
2267                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2268                                                              attackweapon == knife &&
2269                                                              Person::players[k]->weaponmissdelay <= 0)
2270                                                         Person::players[k]->animTarget = knifeslashstartanim;
2271                                                     //swordslash
2272                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
2273                                                                Person::players[0]->hasvictim &&
2274                                                                Person::players[0]->animTarget == swordslashanim) &&
2275                                                              attackweapon == sword &&
2276                                                              Person::players[k]->weaponmissdelay <= 0)
2277                                                         Person::players[k]->animTarget = swordslashanim;
2278                                                     //staffhit
2279                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
2280                                                                Person::players[0]->hasvictim &&
2281                                                                Person::players[0]->animTarget == swordslashanim) &&
2282                                                              attackweapon == staff &&
2283                                                              Person::players[k]->weaponmissdelay <= 0 &&
2284                                                              randattack < 3)
2285                                                         Person::players[k]->animTarget = staffhitanim;
2286                                                     //staffspinhit
2287                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
2288                                                                Person::players[0]->hasvictim &&
2289                                                                Person::players[0]->animTarget == swordslashanim) &&
2290                                                              attackweapon == staff &&
2291                                                              Person::players[k]->weaponmissdelay <= 0 &&
2292                                                              randattack >= 3)
2293                                                         Person::players[k]->animTarget = staffspinhitanim;
2294                                                     //spinkick
2295                                                     else if ((!Tutorial::active || !attackweapon) &&
2296                                                              distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2297                                                              randattack == 1 &&
2298                                                              Animation::animations[Person::players[i]->animTarget].height != lowheight)
2299                                                         Person::players[k]->animTarget = spinkickanim;
2300                                                     //lowkick
2301                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
2302                                                              Animation::animations[Person::players[i]->animTarget].height == lowheight &&
2303                                                              Animation::animations[Person::players[k]->animTarget].attack != normalattack)
2304                                                         Person::players[k]->animTarget = lowkickanim;
2305                                                 }
2306                                             }
2307                                         }
2308                                         //upunch becomes wolfslap
2309                                         if (Person::players[k]->animTarget == upunchanim && Person::players[k]->creature == wolftype)
2310                                             Person::players[k]->animTarget = wolfslapanim;
2311                                     }
2312                                     //sneak attacks
2313                                     if ((k == 0) && (!Tutorial::active || Tutorial::stage == 22) &&
2314                                         Person::players[i]->howactive < typedead1 &&
2315                                         distance < 1.5 * sq(Person::players[k]->scale * 5) &&
2316                                         !Person::players[i]->skeleton.free &&
2317                                         Person::players[i]->animTarget != getupfrombackanim &&
2318                                         Person::players[i]->animTarget != getupfromfrontanim &&
2319                                         (Person::players[i]->surprised > 0 ||
2320                                          Person::players[i]->aitype == passivetype ||
2321                                          attackweapon && Person::players[i]->stunned > 0) &&
2322                                         normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[k]->coords) > 0) {
2323                                         //sneakattack
2324                                         if (!attackweapon) {
2325                                             Person::players[k]->animCurrent = sneakattackanim;
2326                                             Person::players[k]->animTarget = sneakattackanim;
2327                                             Person::players[i]->animCurrent = sneakattackedanim;
2328                                             Person::players[i]->animTarget = sneakattackedanim;
2329                                             Person::players[k]->oldcoords = Person::players[k]->coords;
2330                                             Person::players[k]->coords = Person::players[i]->coords;
2331                                         }
2332                                         //knifesneakattack
2333                                         if (attackweapon == knife) {
2334                                             Person::players[k]->animCurrent = knifesneakattackanim;
2335                                             Person::players[k]->animTarget = knifesneakattackanim;
2336                                             Person::players[i]->animCurrent = knifesneakattackedanim;
2337                                             Person::players[i]->animTarget = knifesneakattackedanim;
2338                                             Person::players[i]->oldcoords = Person::players[i]->coords;
2339                                             Person::players[i]->coords = Person::players[k]->coords;
2340                                         }
2341                                         //swordsneakattack
2342                                         if (attackweapon == sword) {
2343                                             Person::players[k]->animCurrent = swordsneakattackanim;
2344                                             Person::players[k]->animTarget = swordsneakattackanim;
2345                                             Person::players[i]->animCurrent = swordsneakattackedanim;
2346                                             Person::players[i]->animTarget = swordsneakattackedanim;
2347                                             Person::players[i]->oldcoords = Person::players[i]->coords;
2348                                             Person::players[i]->coords = Person::players[k]->coords;
2349                                         }
2350                                         if (attackweapon != staff) {
2351                                             Person::players[k]->victim = Person::players[i];
2352                                             Person::players[k]->hasvictim = 1;
2353                                             Person::players[i]->targettilt2 = 0;
2354                                             Person::players[i]->frameTarget = 1;
2355                                             Person::players[i]->frameCurrent = 0;
2356                                             Person::players[i]->target = 0;
2357                                             Person::players[i]->velocity = 0;
2358                                             Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
2359                                             Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
2360                                             Person::players[k]->frameTarget = Person::players[i]->frameTarget;
2361                                             Person::players[k]->target = Person::players[i]->target;
2362                                             Person::players[k]->velocity = 0;
2363                                             Person::players[k]->targetyaw = Person::players[i]->yaw;
2364                                             Person::players[k]->yaw = Person::players[i]->yaw;
2365                                             Person::players[i]->targetyaw = Person::players[i]->yaw;
2366                                         }
2367                                     }
2368                                     if (Animation::animations[Person::players[k]->animTarget].attack == normalattack &&
2369                                         Person::players[k]->victim == Person::players[i] &&
2370                                         (!Person::players[i]->skeleton.free)) {
2371                                         oldattackkey = 1;
2372                                         Person::players[k]->frameTarget = 0;
2373                                         Person::players[k]->target = 0;
2374
2375                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
2376                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
2377                                         Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
2378                                         Person::players[k]->lastattack2 = Person::players[k]->lastattack;
2379                                         Person::players[k]->lastattack = Person::players[k]->animTarget;
2380                                     }
2381                                     if (Person::players[k]->animTarget == knifefollowanim &&
2382                                         Person::players[k]->victim == Person::players[i]) {
2383                                         oldattackkey = 1;
2384                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
2385                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
2386                                         Person::players[k]->victim = Person::players[i];
2387                                         Person::players[k]->hasvictim = 1;
2388                                         Person::players[i]->animTarget = knifefollowedanim;
2389                                         Person::players[i]->animCurrent = knifefollowedanim;
2390                                         Person::players[i]->targettilt2 = 0;
2391                                         Person::players[i]->targettilt2 = Person::players[k]->targettilt2;
2392                                         Person::players[i]->frameTarget = 1;
2393                                         Person::players[i]->frameCurrent = 0;
2394                                         Person::players[i]->target = 0;
2395                                         Person::players[i]->velocity = 0;
2396                                         Person::players[k]->animCurrent = knifefollowanim;
2397                                         Person::players[k]->animTarget = knifefollowanim;
2398                                         Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
2399                                         Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
2400                                         Person::players[k]->frameTarget = Person::players[i]->frameTarget;
2401                                         Person::players[k]->target = Person::players[i]->target;
2402                                         Person::players[k]->velocity = 0;
2403                                         Person::players[k]->oldcoords = Person::players[k]->coords;
2404                                         Person::players[i]->coords = Person::players[k]->coords;
2405                                         Person::players[i]->targetyaw = Person::players[k]->targetyaw;
2406                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
2407                                         Person::players[k]->yaw = Person::players[k]->targetyaw;
2408                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
2409                                     }
2410                                 }
2411                         }
2412                     const bool hasstaff = attackweapon == staff;
2413                     if (k == 0 && Person::players.size() > 1)
2414                         for (unsigned i = 0; i < Person::players.size(); i++) {
2415                             if (i == k)
2416                                 continue;
2417                             if ((playerrealattackkeydown || Person::players[i]->dead || !hasstaff) &&
2418                                 Animation::animations[Person::players[k]->animTarget].attack == neutral) {
2419                                 const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
2420                                 if (!Person::players[i]->dead || !realthreat || (!attackweapon && Person::players[k]->crouchkeydown))
2421                                     if (Person::players[i]->skeleton.free)
2422                                         if (distance < 3.5 * sq(Person::players[k]->scale * 5) &&
2423                                             (Person::players[i]->dead ||
2424                                              Person::players[i]->skeleton.longdead > 1000 ||
2425                                              Person::players[k]->isRun() ||
2426                                              hasstaff ||
2427                                              (attackweapon &&
2428                                               (Person::players[i]->skeleton.longdead > 2000 ||
2429                                                Person::players[i]->damage > Person::players[i]->damagetolerance / 8 ||
2430                                                Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2) &&
2431                                               distance < 1.5 * sq(Person::players[k]->scale * 5)))) {
2432                                             Person::players[k]->victim = Person::players[i];
2433                                             Person::players[k]->hasvictim = 1;
2434                                             if (attackweapon && !Tutorial::active) {
2435                                                 //crouchstab
2436                                                 if (Person::players[k]->crouchkeydown && attackweapon == knife && distance < 1.5 * sq(Person::players[k]->scale * 5))
2437                                                     Person::players[k]->animTarget = crouchstabanim;
2438                                                 //swordgroundstab
2439                                                 if (Person::players[k]->crouchkeydown && distance < 1.5 * sq(Person::players[k]->scale * 5) && attackweapon == sword)
2440                                                     Person::players[k]->animTarget = swordgroundstabanim;
2441                                                 //staffgroundsmash
2442                                                 if (distance < 3.5 * sq(Person::players[k]->scale * 5) && attackweapon == staff)
2443                                                     Person::players[k]->animTarget = staffgroundsmashanim;
2444                                             }
2445                                             if (distance < 2.5 &&
2446                                                 Person::players[k]->crouchkeydown &&
2447                                                 Person::players[k]->animTarget != crouchstabanim &&
2448                                                 !attackweapon &&
2449                                                 Person::players[i]->dead &&
2450                                                 Person::players[i]->skeleton.free &&
2451                                                 Person::players[i]->skeleton.longdead > 1000) {
2452                                                 Person::players[k]->animTarget = killanim;
2453                                                 terrain.deleteDeadDecals();
2454                                                 for (unsigned int l = 0; l < Object::objects.size(); l++) {
2455                                                     if (Object::objects[l]->model.type == decalstype) {
2456                                                         Object::objects[l]->model.deleteDeadDecals();
2457                                                     }
2458                                                 }
2459                                             }
2460                                             if (!Person::players[i]->dead || musictype != 2)
2461                                                 if (distance < 3.5 &&
2462                                                     (Person::players[k]->isRun() || Person::players[k]->isIdle() && Person::players[k]->attackkeydown) &&
2463                                                     Person::players[k]->staggerdelay <= 0 &&
2464                                                     (Person::players[i]->dead ||
2465                                                      Person::players[i]->skeleton.longdead < 300 &&
2466                                                          Person::players[k]->lastattack != spinkickanim &&
2467                                                          Person::players[i]->skeleton.free) &&
2468                                                     (!Person::players[i]->dead || musictype != stream_fighttheme)) {
2469                                                     Person::players[k]->animTarget = dropkickanim;
2470                                                     terrain.deleteDeadDecals();
2471                                                     for (unsigned int l = 0; l < Object::objects.size(); l++) {
2472                                                         if (Object::objects[l]->model.type == decalstype) {
2473                                                             Object::objects[l]->model.deleteDeadDecals();
2474                                                         }
2475                                                     }
2476                                                 }
2477                                         }
2478                                 if (Animation::animations[Person::players[k]->animTarget].attack == normalattack &&
2479                                     Person::players[k]->victim == Person::players[i] &&
2480                                     (!Person::players[i]->skeleton.free ||
2481                                      Person::players[k]->animTarget == killanim ||
2482                                      Person::players[k]->animTarget == crouchstabanim ||
2483                                      Person::players[k]->animTarget == swordgroundstabanim ||
2484                                      Person::players[k]->animTarget == staffgroundsmashanim ||
2485                                      Person::players[k]->animTarget == dropkickanim)) {
2486                                     oldattackkey = 1;
2487                                     Person::players[k]->frameTarget = 0;
2488                                     Person::players[k]->target = 0;
2489
2490                                     XYZ targetpoint = Person::players[i]->coords;
2491                                     if (Person::players[k]->animTarget == crouchstabanim ||
2492                                         Person::players[k]->animTarget == swordgroundstabanim ||
2493                                         Person::players[k]->animTarget == staffgroundsmashanim) {
2494                                         targetpoint += (Person::players[i]->jointPos(abdomen) +
2495                                                         Person::players[i]->jointPos(neck)) /
2496                                                        2 *
2497                                                        Person::players[i]->scale;
2498                                     }
2499                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, targetpoint);
2500                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, targetpoint);
2501
2502                                     if (Person::players[k]->animTarget == crouchstabanim || Person::players[k]->animTarget == swordgroundstabanim) {
2503                                         Person::players[k]->targetyaw += (float)(abs(Random() % 100) - 50) / 4;
2504                                     }
2505
2506                                     if (Person::players[k]->animTarget == staffgroundsmashanim)
2507                                         Person::players[k]->targettilt2 += 10;
2508
2509                                     Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
2510                                     Person::players[k]->lastattack2 = Person::players[k]->lastattack;
2511                                     Person::players[k]->lastattack = Person::players[k]->animTarget;
2512
2513                                     if (Person::players[k]->animTarget == swordgroundstabanim) {
2514                                         Person::players[k]->targetyaw += 30;
2515                                     }
2516                                 }
2517                             }
2518                         }
2519                     if (!Person::players[k]->hasvictim) {
2520                         //find victim
2521                         for (unsigned i = 0; i < Person::players.size(); i++) {
2522                             if (i == k || !(i == 0 || k == 0))
2523                                 continue;
2524                             if (!Person::players[i]->skeleton.free) {
2525                                 if (Person::players[k]->hasvictim) {
2526                                     if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) <
2527                                         distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords))
2528                                         Person::players[k]->victim = Person::players[i];
2529                                 } else {
2530                                     Person::players[k]->victim = Person::players[i];
2531                                     Person::players[k]->hasvictim = 1;
2532                                 }
2533                             }
2534                         }
2535                     }
2536                     if (Person::players[k]->aitype == playercontrolled)
2537                         //rabbit kick
2538                         if (Person::players[k]->attackkeydown &&
2539                             Person::players[k]->isRun() &&
2540                             Person::players[k]->wasRun() &&
2541                             ((Person::players[k]->hasvictim &&
2542                               distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) < 12 * sq(Person::players[k]->scale * 5) &&
2543                               distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) > 7 * sq(Person::players[k]->scale * 5) &&
2544                               !Person::players[k]->victim->skeleton.free &&
2545                               Person::players[k]->victim->animTarget != getupfrombackanim &&
2546                               Person::players[k]->victim->animTarget != getupfromfrontanim &&
2547                               Animation::animations[Person::players[k]->victim->animTarget].height != lowheight &&
2548                               Person::players[k]->aitype != playercontrolled && //wat???
2549                               normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
2550                               Person::players[k]->rabbitkickenabled) ||
2551                              Person::players[k]->jumpkeydown)) {
2552                             oldattackkey = 1;
2553                             Person::players[k]->setTargetAnimation(rabbitkickanim);
2554                         }
2555                     //update counts
2556                     if (Animation::animations[Person::players[k]->animTarget].attack && k == 0) {
2557                         numattacks++;
2558                         switch (attackweapon) {
2559                             case 0:
2560                                 numunarmedattack++;
2561                                 break;
2562                             case knife:
2563                                 numknifeattack++;
2564                                 break;
2565                             case sword:
2566                                 numswordattack++;
2567                                 break;
2568                             case staff:
2569                                 numstaffattack++;
2570                                 break;
2571                         }
2572                     }
2573                 }
2574             }
2575         }
2576     }
2577 }
2578
2579 void doPlayerCollisions()
2580 {
2581     static XYZ rotatetarget;
2582     static float collisionradius;
2583     if (Person::players.size() > 1)
2584         for (unsigned k = 0; k < Person::players.size(); k++)
2585             for (unsigned i = k + 1; i < Person::players.size(); i++) {
2586                 //neither player is part of a reversal
2587                 if ((Animation::animations[Person::players[i]->animTarget].attack != reversed &&
2588                      Animation::animations[Person::players[i]->animTarget].attack != reversal &&
2589                      Animation::animations[Person::players[k]->animTarget].attack != reversed &&
2590                      Animation::animations[Person::players[k]->animTarget].attack != reversal) ||
2591                     (i != 0 && k != 0))
2592                     if ((Animation::animations[Person::players[i]->animCurrent].attack != reversed &&
2593                          Animation::animations[Person::players[i]->animCurrent].attack != reversal &&
2594                          Animation::animations[Person::players[k]->animCurrent].attack != reversed &&
2595                          Animation::animations[Person::players[k]->animCurrent].attack != reversal) ||
2596                         (i != 0 && k != 0))
2597                         //neither is sleeping
2598                         if (Person::players[i]->howactive <= typesleeping && Person::players[k]->howactive <= typesleeping)
2599                             if (Person::players[i]->howactive != typesittingwall && Person::players[k]->howactive != typesittingwall)
2600                                 //in same patch, neither is climbing
2601                                 if (Person::players[i]->whichpatchx == Person::players[k]->whichpatchx &&
2602                                     Person::players[i]->whichpatchz == Person::players[k]->whichpatchz &&
2603                                     Person::players[k]->skeleton.oldfree == Person::players[k]->skeleton.free &&
2604                                     Person::players[i]->skeleton.oldfree == Person::players[i]->skeleton.free &&
2605                                     Person::players[i]->animTarget != climbanim &&
2606                                     Person::players[i]->animTarget != hanganim &&
2607                                     Person::players[k]->animTarget != climbanim &&
2608                                     Person::players[k]->animTarget != hanganim)
2609                                     //players are close (bounding box test)
2610                                     if (Person::players[i]->coords.y > Person::players[k]->coords.y - 3)
2611                                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 3)
2612                                             if (Person::players[i]->coords.x > Person::players[k]->coords.x - 3)
2613                                                 if (Person::players[i]->coords.x < Person::players[k]->coords.x + 3)
2614                                                     if (Person::players[i]->coords.z > Person::players[k]->coords.z - 3)
2615                                                         if (Person::players[i]->coords.z < Person::players[k]->coords.z + 3) {
2616                                                             //spread fire from player to player
2617                                                             if (distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 3 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
2618                                                                 if (Person::players[i]->onfire || Person::players[k]->onfire) {
2619                                                                     if (!Person::players[i]->onfire)
2620                                                                         Person::players[i]->CatchFire();
2621                                                                     if (!Person::players[k]->onfire)
2622                                                                         Person::players[k]->CatchFire();
2623                                                                 }
2624                                                             }
2625
2626                                                             XYZ tempcoords1 = Person::players[i]->coords;
2627                                                             XYZ tempcoords2 = Person::players[k]->coords;
2628                                                             if (!Person::players[i]->skeleton.oldfree)
2629                                                                 tempcoords1.y += Person::players[i]->jointPos(abdomen).y * Person::players[i]->scale;
2630                                                             if (!Person::players[k]->skeleton.oldfree)
2631                                                                 tempcoords2.y += Person::players[k]->jointPos(abdomen).y * Person::players[k]->scale;
2632                                                             collisionradius = 1.2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
2633                                                             if (Person::players[0]->hasvictim)
2634                                                                 if (Person::players[0]->animTarget == rabbitkickanim && (k == 0 || i == 0) && !Person::players[0]->victim->skeleton.free)
2635                                                                     collisionradius = 3;
2636                                                             if ((!Person::players[i]->skeleton.oldfree || !Person::players[k]->skeleton.oldfree) &&
2637                                                                 (distsq(&tempcoords1, &tempcoords2) < collisionradius ||
2638                                                                  distsq(&Person::players[i]->coords, &Person::players[k]->coords) < collisionradius)) {
2639                                                                 //jump down on a dead body
2640                                                                 if (k == 0 || i == 0) {
2641                                                                     int l = i ? i : k;
2642                                                                     if (Person::players[0]->animTarget == jumpdownanim &&
2643                                                                         !Person::players[0]->skeleton.oldfree &&
2644                                                                         !Person::players[0]->skeleton.free &&
2645                                                                         Person::players[l]->skeleton.oldfree &&
2646                                                                         Person::players[l]->skeleton.free &&
2647                                                                         Person::players[l]->dead &&
2648                                                                         Person::players[0]->lastcollide <= 0 &&
2649                                                                         fabs(Person::players[l]->coords.y - Person::players[0]->coords.y) < .2 &&
2650                                                                         distsq(&Person::players[0]->coords, &Person::players[l]->coords) < .7 * sq((Person::players[l]->scale + Person::players[0]->scale) * 2.5)) {
2651                                                                         Person::players[0]->coords.y = Person::players[l]->coords.y;
2652                                                                         Person::players[l]->velocity = Person::players[0]->velocity;
2653                                                                         Person::players[l]->skeleton.free = 0;
2654                                                                         Person::players[l]->yaw = 0;
2655                                                                         Person::players[l]->RagDoll(0);
2656                                                                         Person::players[l]->DoDamage(20);
2657                                                                         camerashake += .3;
2658                                                                         Person::players[l]->skeleton.longdead = 0;
2659                                                                         Person::players[0]->lastcollide = 1;
2660                                                                     }
2661                                                                 }
2662
2663                                                                 if ((Person::players[i]->skeleton.oldfree == 1 && findLengthfast(&Person::players[i]->velocity) > 1) ||
2664                                                                     (Person::players[k]->skeleton.oldfree == 1 && findLengthfast(&Person::players[k]->velocity) > 1) ||
2665                                                                     (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0)) {
2666                                                                     rotatetarget = Person::players[k]->velocity - Person::players[i]->velocity;
2667                                                                     if ((Person::players[i]->animTarget != getupfrombackanim && Person::players[i]->animTarget != getupfromfrontanim ||
2668                                                                          Person::players[i]->skeleton.free) &&
2669                                                                         (Person::players[k]->animTarget != getupfrombackanim && Person::players[k]->animTarget != getupfromfrontanim ||
2670                                                                          Person::players[k]->skeleton.free))
2671                                                                         if ((((k != 0 && findLengthfast(&rotatetarget) > 150 ||
2672                                                                                k == 0 && findLengthfast(&rotatetarget) > 50 && Person::players[0]->rabbitkickragdoll) &&
2673                                                                               normaldotproduct(rotatetarget, Person::players[k]->coords - Person::players[i]->coords) > 0) &&
2674                                                                              (k == 0 ||
2675                                                                               k != 0 && Person::players[i]->skeleton.oldfree == 1 && Animation::animations[Person::players[k]->animCurrent].attack == neutral ||
2676                                                                               /*i!=0&&*/ Person::players[k]->skeleton.oldfree == 1 && Animation::animations[Person::players[i]->animCurrent].attack == neutral)) ||
2677                                                                             (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) &&
2678                                                                                 (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) &&
2679                                                                                 k == 0 && !Person::players[i]->skeleton.oldfree && !Person::players[k]->skeleton.oldfree) {
2680                                                                             //If hit by body
2681                                                                             if ((i != 0 || Person::players[i]->skeleton.free) &&
2682                                                                                     (k != 0 || Person::players[k]->skeleton.free) ||
2683                                                                                 (Animation::animations[Person::players[i]->animTarget].height == highheight &&
2684                                                                                  Animation::animations[Person::players[k]->animTarget].height == highheight)) {
2685                                                                                 if (!Tutorial::active) {
2686                                                                                     emit_sound_at(heavyimpactsound, Person::players[i]->coords);
2687                                                                                 }
2688
2689                                                                                 Person::players[i]->RagDoll(0);
2690                                                                                 if (Person::players[i]->damage > Person::players[i]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[i]->dead) {
2691                                                                                     award_bonus(0, aimbonus);
2692                                                                                 }
2693                                                                                 Person::players[i]->DoDamage(findLengthfast(&rotatetarget) / 4);
2694                                                                                 Person::players[k]->RagDoll(0);
2695                                                                                 if (Person::players[k]->damage > Person::players[k]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[k]->dead) {
2696                                                                                     award_bonus(0, aimbonus); // Huh, again?
2697                                                                                 }
2698                                                                                 Person::players[k]->DoDamage(findLengthfast(&rotatetarget) / 4);
2699
2700                                                                                 for (unsigned j = 0; j < Person::players[i]->skeleton.joints.size(); j++) {
2701                                                                                     Person::players[i]->skeleton.joints[j].velocity = Person::players[i]->skeleton.joints[j].velocity / 5 + Person::players[k]->velocity;
2702                                                                                 }
2703                                                                                 for (unsigned j = 0; j < Person::players[k]->skeleton.joints.size(); j++) {
2704                                                                                     Person::players[k]->skeleton.joints[j].velocity = Person::players[k]->skeleton.joints[j].velocity / 5 + Person::players[i]->velocity;
2705                                                                                 }
2706                                                                             }
2707                                                                         }
2708                                                                     if ((Animation::animations[Person::players[i]->animTarget].attack == neutral ||
2709                                                                          Animation::animations[Person::players[i]->animTarget].attack == normalattack) &&
2710                                                                         (Animation::animations[Person::players[k]->animTarget].attack == neutral ||
2711                                                                          Animation::animations[Person::players[k]->animTarget].attack == normalattack)) {
2712                                                                         //If bumped
2713                                                                         if (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0) {
2714                                                                             if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < .5 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
2715                                                                                 rotatetarget = Person::players[k]->coords - Person::players[i]->coords;
2716                                                                                 Normalise(&rotatetarget);
2717                                                                                 Person::players[k]->coords = (Person::players[k]->coords + Person::players[i]->coords) / 2;
2718                                                                                 Person::players[i]->coords = Person::players[k]->coords - rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
2719                                                                                 Person::players[k]->coords += rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
2720                                                                                 if (Person::players[k]->howactive == typeactive || hostile)
2721                                                                                     if (Person::players[k]->isIdle()) {
2722                                                                                         if (Person::players[k]->howactive < typesleeping)
2723                                                                                             Person::players[k]->setTargetAnimation(Person::players[k]->getStop());
2724                                                                                         else if (Person::players[k]->howactive == typesleeping)
2725                                                                                             Person::players[k]->setTargetAnimation(getupfromfrontanim);
2726                                                                                         if (!editorenabled)
2727                                                                                             Person::players[k]->howactive = typeactive;
2728                                                                                     }
2729                                                                                 if (Person::players[i]->howactive == typeactive || hostile)
2730                                                                                     if (Person::players[i]->isIdle()) {
2731                                                                                         if (Person::players[i]->howactive < typesleeping)
2732                                                                                             Person::players[i]->setTargetAnimation(Person::players[k]->getStop());
2733                                                                                         else
2734                                                                                             Person::players[i]->setTargetAnimation(getupfromfrontanim);
2735                                                                                         if (!editorenabled)
2736                                                                                             Person::players[i]->howactive = typeactive;
2737                                                                                     }
2738                                                                             }
2739                                                                             //jump down on player
2740                                                                             if (hostile) {
2741                                                                                 if (k == 0 && i != 0 && Person::players[k]->animTarget == jumpdownanim &&
2742                                                                                     !Person::players[i]->isCrouch() &&
2743                                                                                     Person::players[i]->animTarget != rollanim &&
2744                                                                                     !Person::players[k]->skeleton.oldfree && !Person::players[k]->skeleton.free &&
2745                                                                                     Person::players[k]->lastcollide <= 0 &&
2746                                                                                     Person::players[k]->velocity.y < -10) {
2747                                                                                     Person::players[i]->velocity = Person::players[k]->velocity;
2748                                                                                     Person::players[k]->velocity = Person::players[k]->velocity * -.5;
2749                                                                                     Person::players[k]->velocity.y = Person::players[i]->velocity.y;
2750                                                                                     Person::players[i]->DoDamage(20);
2751                                                                                     Person::players[i]->RagDoll(0);
2752                                                                                     Person::players[k]->lastcollide = 1;
2753                                                                                     award_bonus(k, AboveBonus);
2754                                                                                 }
2755                                                                                 if (i == 0 && k != 0 && Person::players[i]->animTarget == jumpdownanim &&
2756                                                                                     !Person::players[k]->isCrouch() &&
2757                                                                                     Person::players[k]->animTarget != rollanim &&
2758                                                                                     !Person::players[i]->skeleton.oldfree &&
2759                                                                                     !Person::players[i]->skeleton.free &&
2760                                                                                     Person::players[i]->lastcollide <= 0 &&
2761                                                                                     Person::players[i]->velocity.y < -10) {
2762                                                                                     Person::players[k]->velocity = Person::players[i]->velocity;
2763                                                                                     Person::players[i]->velocity = Person::players[i]->velocity * -.3;
2764                                                                                     Person::players[i]->velocity.y = Person::players[k]->velocity.y;
2765                                                                                     Person::players[k]->DoDamage(20);
2766                                                                                     Person::players[k]->RagDoll(0);
2767                                                                                     Person::players[i]->lastcollide = 1;
2768                                                                                     award_bonus(i, AboveBonus);
2769                                                                                 }
2770                                                                             }
2771                                                                         }
2772                                                                     }
2773                                                                 }
2774                                                                 Person::players[i]->CheckKick();
2775                                                                 Person::players[k]->CheckKick();
2776                                                             }
2777                                                         }
2778             }
2779 }
2780
2781 void Game::Tick()
2782 {
2783     static XYZ facing, flatfacing;
2784     static int target;
2785
2786     Input::Tick();
2787
2788     if (Input::isKeyPressed(SDL_SCANCODE_F6)) {
2789         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
2790             stereoreverse = true;
2791         else
2792             stereoreverse = false;
2793
2794         if (stereoreverse)
2795             printf("Stereo reversed\n");
2796         else
2797             printf("Stereo unreversed\n");
2798     }
2799
2800     if (Input::isKeyDown(SDL_SCANCODE_F7)) {
2801         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
2802             stereoseparation -= 0.001;
2803         else
2804             stereoseparation -= 0.010;
2805         printf("Stereo decreased increased to %f\n", stereoseparation);
2806     }
2807
2808     if (Input::isKeyDown(SDL_SCANCODE_F8)) {
2809         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
2810             stereoseparation += 0.001;
2811         else
2812             stereoseparation += 0.010;
2813         printf("Stereo separation increased to %f\n", stereoseparation);
2814     }
2815
2816     if (Input::isKeyPressed(SDL_SCANCODE_TAB) && Tutorial::active) {
2817         if (Tutorial::stage != 51) {
2818             Tutorial::stagetime = Tutorial::maxtime;
2819         }
2820         emit_sound_np(consolefailsound, 128.);
2821     }
2822
2823     /*
2824     Values of mainmenu :
2825     1 Main menu
2826     2 Menu pause (resume/end game)
2827     3 Option menu
2828     4 Controls configuration menu
2829     5 Main game menu (choose level or challenge)
2830     6 Deleting user menu
2831     7 User managment menu (select/add)
2832     8 Choose difficulty menu
2833     9 Challenge level selection menu
2834     10 End of the campaign congratulation (is that really a menu?)
2835     11 Same that 9 ??? => unused
2836     18 stereo configuration
2837     */
2838
2839     if (!console) {
2840         //campaign over?
2841         if (mainmenu && endgame == 1)
2842             mainmenu = 10;
2843         //go to level select after completing a campaign level
2844         if (campaign && winfreeze && mainmenu == 0 && campaignlevels[actuallevel].choosenext == 1) {
2845             mainmenu = 5;
2846             gameon = 0;
2847             winfreeze = 0;
2848             fireSound();
2849             flash();
2850             if (musictoggle) {
2851                 OPENAL_SetFrequency(OPENAL_ALL);
2852                 emit_stream_np(stream_menutheme);
2853                 pause_sound(leveltheme);
2854             }
2855             Menu::Load();
2856         }
2857         //escape key pressed
2858         if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
2859             (gameon || mainmenu == 0)) {
2860             selected = -1;
2861             if (mainmenu == 0 && !winfreeze)
2862                 mainmenu = 2; //pause
2863             else if (mainmenu == 1 || mainmenu == 2) {
2864                 mainmenu = 0; //unpause
2865             }
2866             //play menu theme
2867             if (musictoggle && (mainmenu == 1 || mainmenu == 2)) {
2868                 OPENAL_SetFrequency(OPENAL_ALL);
2869                 emit_stream_np(stream_menutheme);
2870                 pause_sound(leveltheme);
2871             }
2872             //on resume, play level music
2873             if (!mainmenu) {
2874                 pause_sound(stream_menutheme);
2875                 resume_stream(leveltheme);
2876             }
2877         }
2878     }
2879
2880     if (mainmenu) {
2881         Menu::Tick();
2882     }
2883
2884     if (!mainmenu) {
2885         if (hostile == 1)
2886             hostiletime += multiplier;
2887         else
2888             hostiletime = 0;
2889         if (!winfreeze)
2890             leveltime += multiplier;
2891
2892         //keys
2893         if (Input::isKeyDown(SDL_SCANCODE_LALT) && Input::isKeyPressed(SDL_SCANCODE_V) && devtools) {
2894             freeze = !freeze;
2895             if (freeze) {
2896                 OPENAL_SetFrequency(OPENAL_ALL);
2897             }
2898         }
2899
2900         if (Input::isKeyPressed(consolekey) && devtools) {
2901             console = !console;
2902             if (console) {
2903                 OPENAL_SetFrequency(OPENAL_ALL);
2904             } else {
2905                 freeze = 0;
2906                 waiting = false;
2907             }
2908         }
2909
2910         if (console)
2911             freeze = 1;
2912         if (console && !Input::isKeyDown(SDL_SCANCODE_LGUI)) {
2913             inputText(consoletext[0], &consoleselected);
2914             if (!waiting) {
2915                 if (!consoletext[0].empty()) {
2916                     cmd_dispatch(consoletext[0]);
2917                     for (int k = 14; k >= 1; k--) {
2918                         consoletext[k] = consoletext[k - 1];
2919                     }
2920                     consoletext[0].clear();
2921                     consoleselected = 0;
2922                 }
2923             }
2924
2925             consoleblinkdelay -= multiplier;
2926             if (consoleblinkdelay <= 0) {
2927                 consoleblinkdelay = .3;
2928                 consoleblink = !consoleblink;
2929             }
2930         }
2931
2932         static int oldwinfreeze;
2933         if (winfreeze && !oldwinfreeze) {
2934             OPENAL_SetFrequency(OPENAL_ALL);
2935             emit_sound_np(consolesuccesssound);
2936         }
2937         if (winfreeze == 0)
2938             oldwinfreeze = winfreeze;
2939         else
2940             oldwinfreeze++;
2941
2942         if ((Input::isKeyPressed(jumpkey) || Input::isKeyPressed(SDL_SCANCODE_SPACE)) && !campaign)
2943             if (winfreeze)
2944                 winfreeze = 0;
2945         if ((Input::isKeyDown(SDL_SCANCODE_ESCAPE)) && !campaign && gameon) {
2946             if (console) {
2947                 console = false;
2948                 freeze = 0;
2949             } else if (winfreeze) {
2950                 mainmenu = 9;
2951                 gameon = 0;
2952             }
2953         }
2954
2955         if (!freeze && !winfreeze && !(mainmenu && gameon) && (gameon || !gamestarted)) {
2956
2957             //dialogues
2958             static float talkdelay = 0;
2959
2960             if (Dialog::inDialog())
2961                 talkdelay = 1;
2962             talkdelay -= multiplier;
2963
2964             if (talkdelay <= 0 && !Dialog::inDialog() && Animation::animations[Person::players[0]->animTarget].height != highheight) {
2965                 for (unsigned i = 0; i < Dialog::dialogs.size(); i++) {
2966                     Dialog::dialogs[i].tick(i);
2967                 }
2968             }
2969
2970             windvar += multiplier;
2971             smoketex += multiplier;
2972             Tutorial::stagetime += multiplier;
2973
2974             //hotspots
2975             static float hotspotvisual[40];
2976             if (Hotspot::hotspots.size()) {
2977                 XYZ hotspotsprite;
2978                 if (editorenabled) {
2979                     for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
2980                         hotspotvisual[i] -= multiplier / 320;
2981                     }
2982                 }
2983
2984                 for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
2985                     while (hotspotvisual[i] < 0) {
2986                         hotspotsprite = 0;
2987                         hotspotsprite.x = float(abs(Random() % 100000)) / 100000 * Hotspot::hotspots[i].size;
2988                         hotspotsprite = DoRotation(hotspotsprite, 0, 0, Random() % 360);
2989                         hotspotsprite = DoRotation(hotspotsprite, 0, Random() % 360, 0);
2990                         hotspotsprite += Hotspot::hotspots[i].position;
2991                         Sprite::MakeSprite(breathsprite, hotspotsprite, hotspotsprite * 0, 1, 0.5, 0, 7, 0.4);
2992                         hotspotvisual[i] += 0.1 / Hotspot::hotspots[i].size / Hotspot::hotspots[i].size / Hotspot::hotspots[i].size;
2993                     }
2994                 }
2995
2996                 for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
2997                     if (Hotspot::hotspots[i].type <= 10 && Hotspot::hotspots[i].type > 0) {
2998                         Hotspot::hotspots[i].position = Person::players[Hotspot::hotspots[i].type]->coords;
2999                     }
3000                 }
3001             }
3002
3003             //Tutorial
3004             if (Tutorial::active) {
3005                 Tutorial::Do(multiplier);
3006             }
3007
3008             //bonuses
3009             if (!Tutorial::active) {
3010                 if (bonustime == 0 &&
3011                     bonus != solidhit &&
3012                     bonus != spinecrusher &&
3013                     bonus != tracheotomy &&
3014                     bonus != backstab &&
3015                     bonusvalue > 10) {
3016                     emit_sound_np(consolesuccesssound);
3017                 }
3018             } else if (bonustime == 0) {
3019                 emit_sound_np(fireendsound);
3020             }
3021             if (bonustime == 0) {
3022                 if (bonus != solidhit &&
3023                     bonus != twoxcombo &&
3024                     bonus != threexcombo &&
3025                     bonus != fourxcombo &&
3026                     bonus != megacombo)
3027                     bonusnum[bonus]++;
3028                 else
3029                     bonusnum[bonus] += 0.15;
3030                 if (Tutorial::active)
3031                     bonusvalue = 0;
3032                 bonusvalue /= bonusnum[bonus];
3033                 bonustotal += bonusvalue;
3034             }
3035             bonustime += multiplier;
3036
3037             //snow effects
3038             if (environment == snowyenvironment) {
3039                 precipdelay -= multiplier;
3040                 while (precipdelay < 0) {
3041                     precipdelay += .04;
3042                     if (!detail)
3043                         precipdelay += .04;
3044                     XYZ footvel, footpoint;
3045
3046                     footvel = 0;
3047                     footpoint = viewer + viewerfacing * 6;
3048                     footpoint.y += ((float)abs(Random() % 1200)) / 100 - 6;
3049                     footpoint.x += ((float)abs(Random() % 1200)) / 100 - 6;
3050                     footpoint.z += ((float)abs(Random() % 1200)) / 100 - 6;
3051                     Sprite::MakeSprite(snowsprite, footpoint, footvel, 1, 1, 1, .1, 1);
3052                 }
3053             }
3054
3055             doAerialAcrobatics();
3056
3057             static XYZ oldviewer;
3058
3059             //control keys
3060             if (!Dialog::inDialog()) {
3061                 Person::players[0]->forwardkeydown = Input::isKeyDown(forwardkey);
3062                 Person::players[0]->leftkeydown = Input::isKeyDown(leftkey);
3063                 Person::players[0]->backkeydown = Input::isKeyDown(backkey);
3064                 Person::players[0]->rightkeydown = Input::isKeyDown(rightkey);
3065                 Person::players[0]->jumpkeydown = Input::isKeyDown(jumpkey);
3066                 Person::players[0]->crouchkeydown = Input::isKeyDown(crouchkey);
3067                 Person::players[0]->drawkeydown = Input::isKeyDown(drawkey);
3068                 Person::players[0]->throwkeydown = Input::isKeyDown(throwkey);
3069             } else {
3070                 Person::players[0]->forwardkeydown = 0;
3071                 Person::players[0]->leftkeydown = 0;
3072                 Person::players[0]->backkeydown = 0;
3073                 Person::players[0]->rightkeydown = 0;
3074                 Person::players[0]->jumpkeydown = 0;
3075                 Person::players[0]->crouchkeydown = 0;
3076                 Person::players[0]->drawkeydown = 0;
3077                 Person::players[0]->throwkeydown = 0;
3078             }
3079
3080             if (!Person::players[0]->jumpkeydown)
3081                 Person::players[0]->jumpclimb = 0;
3082
3083             if (Dialog::inDialog()) {
3084                 cameramode = 1;
3085                 if (Dialog::directing) {
3086                     facing = 0;
3087                     facing.z = -1;
3088
3089                     facing = DoRotation(facing, -pitch, 0, 0);
3090                     facing = DoRotation(facing, 0, 0 - yaw, 0);
3091
3092                     flatfacing = 0;
3093                     flatfacing.z = -1;
3094
3095                     flatfacing = DoRotation(flatfacing, 0, -yaw, 0);
3096
3097                     if (Input::isKeyDown(forwardkey))
3098                         viewer += facing * multiplier * 4;
3099                     if (Input::isKeyDown(backkey))
3100                         viewer -= facing * multiplier * 4;
3101                     if (Input::isKeyDown(leftkey))
3102                         viewer += DoRotation(flatfacing * multiplier, 0, 90, 0) * 4;
3103                     if (Input::isKeyDown(rightkey))
3104                         viewer += DoRotation(flatfacing * multiplier, 0, -90, 0) * 4;
3105                     if (Input::isKeyDown(jumpkey))
3106                         viewer.y += multiplier * 4;
3107                     if (Input::isKeyDown(crouchkey))
3108                         viewer.y -= multiplier * 4;
3109                     if (Input::isKeyPressed(SDL_SCANCODE_1) ||
3110                         Input::isKeyPressed(SDL_SCANCODE_2) ||
3111                         Input::isKeyPressed(SDL_SCANCODE_3) ||
3112                         Input::isKeyPressed(SDL_SCANCODE_4) ||
3113                         Input::isKeyPressed(SDL_SCANCODE_5) ||
3114                         Input::isKeyPressed(SDL_SCANCODE_6) ||
3115                         Input::isKeyPressed(SDL_SCANCODE_7) ||
3116                         Input::isKeyPressed(SDL_SCANCODE_8) ||
3117                         Input::isKeyPressed(SDL_SCANCODE_9) ||
3118                         Input::isKeyPressed(SDL_SCANCODE_0) ||
3119                         Input::isKeyPressed(SDL_SCANCODE_MINUS)) {
3120                         int whichend;
3121                         if (Input::isKeyPressed(SDL_SCANCODE_1))
3122                             whichend = 1;
3123                         if (Input::isKeyPressed(SDL_SCANCODE_2))
3124                             whichend = 2;
3125                         if (Input::isKeyPressed(SDL_SCANCODE_3))
3126                             whichend = 3;
3127                         if (Input::isKeyPressed(SDL_SCANCODE_4))
3128                             whichend = 4;
3129                         if (Input::isKeyPressed(SDL_SCANCODE_5))
3130                             whichend = 5;
3131                         if (Input::isKeyPressed(SDL_SCANCODE_6))
3132                             whichend = 6;
3133                         if (Input::isKeyPressed(SDL_SCANCODE_7))
3134                             whichend = 7;
3135                         if (Input::isKeyPressed(SDL_SCANCODE_8))
3136                             whichend = 8;
3137                         if (Input::isKeyPressed(SDL_SCANCODE_9))
3138                             whichend = 9;
3139                         if (Input::isKeyPressed(SDL_SCANCODE_0))
3140                             whichend = 0;
3141                         if (Input::isKeyPressed(SDL_SCANCODE_MINUS))
3142                             whichend = -1;
3143                         if (whichend != -1) {
3144                             Dialog::currentScene().participantfocus = whichend;
3145                             Dialog::currentDialog().participantlocation[whichend] = Person::players[whichend]->coords;
3146                             Dialog::currentDialog().participantyaw[whichend] = Person::players[whichend]->yaw;
3147                         }
3148                         if (whichend == -1) {
3149                             Dialog::currentScene().participantfocus = -1;
3150                         }
3151                         /* FIXME: potentially accessing -1 in Person::players! */
3152                         if (Person::players[Dialog::currentScene().participantfocus]->dead) {
3153                             Dialog::indialogue = -1;
3154                             Dialog::directing = false;
3155                             cameramode = 0;
3156                         }
3157                         Dialog::currentScene().camera = viewer;
3158                         Dialog::currentScene().camerayaw = yaw;
3159                         Dialog::currentScene().camerapitch = pitch;
3160                         Dialog::indialogue++;
3161                         if (Dialog::indialogue < int(Dialog::currentDialog().scenes.size())) {
3162                             if (Dialog::currentScene().sound != 0) {
3163                                 playdialoguescenesound();
3164                             }
3165                         }
3166
3167                         for (unsigned j = 0; j < Person::players.size(); j++) {
3168                             Dialog::currentScene().participantfacing[j] = Dialog::currentDialog().scenes[Dialog::indialogue - 1].participantfacing[j];
3169                         }
3170                     }
3171                     //TODO: should these be KeyDown or KeyPressed?
3172                     if (Input::isKeyDown(SDL_SCANCODE_KP_1) ||
3173                         Input::isKeyDown(SDL_SCANCODE_KP_2) ||
3174                         Input::isKeyDown(SDL_SCANCODE_KP_3) ||
3175                         Input::isKeyDown(SDL_SCANCODE_KP_4) ||
3176                         Input::isKeyDown(SDL_SCANCODE_KP_5) ||
3177                         Input::isKeyDown(SDL_SCANCODE_KP_6) ||
3178                         Input::isKeyDown(SDL_SCANCODE_KP_7) ||
3179                         Input::isKeyDown(SDL_SCANCODE_KP_8) ||
3180                         Input::isKeyDown(SDL_SCANCODE_KP_9) ||
3181                         Input::isKeyDown(SDL_SCANCODE_KP_0)) {
3182                         int whichend;
3183                         if (Input::isKeyDown(SDL_SCANCODE_KP_1))
3184                             whichend = 1;
3185                         if (Input::isKeyDown(SDL_SCANCODE_KP_2))
3186                             whichend = 2;
3187                         if (Input::isKeyDown(SDL_SCANCODE_KP_3))
3188                             whichend = 3;
3189                         if (Input::isKeyDown(SDL_SCANCODE_KP_4))
3190                             whichend = 4;
3191                         if (Input::isKeyDown(SDL_SCANCODE_KP_5))
3192                             whichend = 5;
3193                         if (Input::isKeyDown(SDL_SCANCODE_KP_6))
3194                             whichend = 6;
3195                         if (Input::isKeyDown(SDL_SCANCODE_KP_7))
3196                             whichend = 7;
3197                         if (Input::isKeyDown(SDL_SCANCODE_KP_8))
3198                             whichend = 8;
3199                         if (Input::isKeyDown(SDL_SCANCODE_KP_9))
3200                             whichend = 9;
3201                         if (Input::isKeyDown(SDL_SCANCODE_KP_0))
3202                             whichend = 0;
3203                         Dialog::currentScene().participantfacing[whichend] = facing;
3204                     }
3205                     if (Dialog::indialogue >= int(Dialog::currentDialog().scenes.size())) {
3206                         Dialog::indialogue = -1;
3207                         Dialog::directing = false;
3208                         cameramode = 0;
3209                     }
3210                 }
3211                 if (!Dialog::directing) {
3212                     pause_sound(whooshsound);
3213                     viewer = Dialog::currentScene().camera;
3214                     viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .1);
3215                     yaw = Dialog::currentScene().camerayaw;
3216                     pitch = Dialog::currentScene().camerapitch;
3217                     if (Dialog::dialoguetime > 0.5) {
3218                         if (Input::isKeyPressed(attackkey)) {
3219                             Dialog::indialogue++;
3220                             if (Dialog::indialogue < int(Dialog::currentDialog().scenes.size())) {
3221                                 if (Dialog::currentScene().sound != 0) {
3222                                     playdialoguescenesound();
3223                                     if (Dialog::currentScene().sound == -5) {
3224                                         Hotspot::hotspots.emplace_back(Person::players[0]->coords, -1, 10);
3225                                     }
3226                                     if (Dialog::currentScene().sound == -6) {
3227                                         hostile = 1;
3228                                     }
3229
3230                                     if (Person::players.at(Dialog::currentScene().participantfocus)->dead) {
3231                                         Dialog::indialogue = -1;
3232                                         Dialog::directing = false;
3233                                         cameramode = 0;
3234                                     }
3235                                 }
3236                             }
3237                         }
3238                     }
3239                     if (Dialog::indialogue >= int(Dialog::currentDialog().scenes.size())) {
3240                         Dialog::indialogue = -1;
3241                         Dialog::directing = false;
3242                         cameramode = 0;
3243                         if (Dialog::currentDialog().type > 19 && Dialog::currentDialog().type < 30) {
3244                             hostile = 1;
3245                         }
3246                         if (Dialog::currentDialog().type > 29 && Dialog::currentDialog().type < 40) {
3247                             windialogue = true;
3248                         }
3249                         if (Dialog::currentDialog().type > 49 && Dialog::currentDialog().type < 60) {
3250                             hostile = 1;
3251                             for (unsigned i = 1; i < Person::players.size(); i++) {
3252                                 Person::players[i]->aitype = attacktypecutoff;
3253                             }
3254                         }
3255                     }
3256                 }
3257             }
3258
3259             if (!Person::players[0]->jumpkeydown) {
3260                 Person::players[0]->jumptogglekeydown = 0;
3261             }
3262             if (Person::players[0]->jumpkeydown &&
3263                 Person::players[0]->animTarget != jumpupanim &&
3264                 Person::players[0]->animTarget != jumpdownanim &&
3265                 !Person::players[0]->isFlip())
3266                 Person::players[0]->jumptogglekeydown = 1;
3267
3268             Dialog::dialoguetime += multiplier;
3269             hawkyaw += multiplier * 25;
3270             realhawkcoords = 0;
3271             realhawkcoords.x = 25;
3272             realhawkcoords = DoRotation(realhawkcoords, 0, hawkyaw, 0) + hawkcoords;
3273             hawkcalldelay -= multiplier / 2;
3274
3275             if (hawkcalldelay <= 0) {
3276                 emit_sound_at(hawksound, realhawkcoords);
3277
3278                 hawkcalldelay = 16 + abs(Random() % 8);
3279             }
3280
3281             doDevKeys();
3282
3283             doAttacks();
3284
3285             doPlayerCollisions();
3286
3287             doJumpReversals();
3288
3289             for (unsigned k = 0; k < Person::players.size(); k++)
3290                 if (k != 0 && Person::players[k]->immobile)
3291                     Person::players[k]->coords = Person::players[k]->realoldcoords;
3292
3293             for (unsigned k = 0; k < Person::players.size(); k++) {
3294                 if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
3295                     if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
3296                         Person::players[k]->DoDamage(1000);
3297                     }
3298                 }
3299             }
3300
3301             //respawn
3302             static bool respawnkeydown;
3303             if (!editorenabled &&
3304                 (whichlevel != -2 &&
3305                      (Input::isKeyDown(SDL_SCANCODE_Z) &&
3306                       Input::isKeyDown(SDL_SCANCODE_LGUI) &&
3307                       devtools) ||
3308                  (Input::isKeyDown(jumpkey) &&
3309                   !respawnkeydown &&
3310                   !oldattackkey &&
3311                   Person::players[0]->dead))) {
3312                 targetlevel = whichlevel;
3313                 loading = 1;
3314                 leveltime = 5;
3315             }
3316             respawnkeydown = Input::isKeyDown(jumpkey);
3317
3318             static bool movekey;
3319
3320             //?
3321             for (unsigned i = 0; i < Person::players.size(); i++) {
3322                 static float oldtargetyaw;
3323                 if (!Person::players[i]->skeleton.free) {
3324                     oldtargetyaw = Person::players[i]->targetyaw;
3325                     if (i == 0 && !Dialog::inDialog()) {
3326                         //TODO: refactor repetitive code
3327                         if (!Animation::animations[Person::players[0]->animTarget].attack &&
3328                             Person::players[0]->animTarget != staggerbackhighanim &&
3329                             Person::players[0]->animTarget != staggerbackhardanim &&
3330                             Person::players[0]->animTarget != crouchremoveknifeanim &&
3331                             Person::players[0]->animTarget != removeknifeanim &&
3332                             Person::players[0]->animTarget != backhandspringanim &&
3333                             Person::players[0]->animTarget != dodgebackanim &&
3334                             Person::players[0]->animTarget != walljumprightkickanim &&
3335                             Person::players[0]->animTarget != walljumpleftkickanim) {
3336                             if (cameramode)
3337                                 Person::players[0]->targetyaw = 0;
3338                             else
3339                                 Person::players[0]->targetyaw = -yaw + 180;
3340                         }
3341
3342                         facing = 0;
3343                         facing.z = -1;
3344
3345                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
3346                         if (cameramode) {
3347                             facing = flatfacing;
3348                         } else {
3349                             facing = DoRotation(facing, -pitch, 0, 0);
3350                             facing = DoRotation(facing, 0, 0 - yaw, 0);
3351                         }
3352
3353                         Person::players[0]->lookyaw = -yaw;
3354
3355                         Person::players[i]->targetheadyaw = yaw;
3356                         Person::players[i]->targetheadpitch = pitch;
3357                     }
3358                     if (i != 0 && Person::players[i]->aitype == playercontrolled && !Dialog::inDialog()) {
3359                         if (!Animation::animations[Person::players[i]->animTarget].attack &&
3360                             Person::players[i]->animTarget != staggerbackhighanim &&
3361                             Person::players[i]->animTarget != staggerbackhardanim &&
3362                             Person::players[i]->animTarget != crouchremoveknifeanim &&
3363                             Person::players[i]->animTarget != removeknifeanim &&
3364                             Person::players[i]->animTarget != backhandspringanim &&
3365                             Person::players[i]->animTarget != dodgebackanim &&
3366                             Person::players[i]->animTarget != walljumprightkickanim &&
3367                             Person::players[i]->animTarget != walljumpleftkickanim) {
3368                             Person::players[i]->targetyaw = -Person::players[i]->lookyaw + 180;
3369                         }
3370
3371                         facing = 0;
3372                         facing.z = -1;
3373
3374                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
3375
3376                         facing = DoRotation(facing, -Person::players[i]->lookpitch, 0, 0);
3377                         facing = DoRotation(facing, 0, 0 - Person::players[i]->lookyaw, 0);
3378
3379                         Person::players[i]->targetheadyaw = Person::players[i]->lookyaw;
3380                         Person::players[i]->targetheadpitch = Person::players[i]->lookpitch;
3381                     }
3382                     if (Dialog::inDialog()) {
3383                         Person::players[i]->targetheadyaw = 180 - roughDirection(Dialog::currentScene().participantfacing[i]);
3384                         Person::players[i]->targetheadpitch = pitchOf(Dialog::currentScene().participantfacing[i]);
3385                     }
3386
3387                     if (leveltime < .5)
3388                         numenvsounds = 0;
3389
3390                     Person::players[i]->avoidsomething = 0;
3391
3392                     //avoid flaming things
3393                     for (unsigned int j = 0; j < Object::objects.size(); j++)
3394                         if (Object::objects[j]->onfire)
3395                             if (distsq(&Person::players[i]->coords, &Object::objects[j]->position) < sq(Object::objects[j]->scale) * 200)
3396                                 if (distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
3397                                     distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
3398                                     Person::players[i]->collided = 0;
3399                                     Person::players[i]->avoidcollided = 1;
3400                                     if (Person::players[i]->avoidsomething == 0 ||
3401                                         distsq(&Person::players[i]->coords, &Object::objects[j]->position) <
3402                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
3403                                         Person::players[i]->avoidwhere = Object::objects[j]->position;
3404                                         Person::players[i]->avoidsomething = 1;
3405                                     }
3406                                 }
3407
3408                     //avoid flaming players
3409                     for (unsigned j = 0; j < Person::players.size(); j++)
3410                         if (Person::players[j]->onfire)
3411                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < sq(0.3) * 200)
3412                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
3413                                     distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
3414                                     Person::players[i]->collided = 0;
3415                                     Person::players[i]->avoidcollided = 1;
3416                                     if (Person::players[i]->avoidsomething == 0 ||
3417                                         distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
3418                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
3419                                         Person::players[i]->avoidwhere = Person::players[j]->coords;
3420                                         Person::players[i]->avoidsomething = 1;
3421                                     }
3422                                 }
3423
3424                     if (Person::players[i]->collided > .8)
3425                         Person::players[i]->avoidcollided = 0;
3426
3427                     Person::players[i]->doAI();
3428
3429                     if (Animation::animations[Person::players[i]->animTarget].attack == reversed) {
3430                         //Person::players[i]->targetyaw=Person::players[i]->yaw;
3431                         Person::players[i]->forwardkeydown = 0;
3432                         Person::players[i]->leftkeydown = 0;
3433                         Person::players[i]->backkeydown = 0;
3434                         Person::players[i]->rightkeydown = 0;
3435                         Person::players[i]->jumpkeydown = 0;
3436                         Person::players[i]->attackkeydown = 0;
3437                         //Person::players[i]->crouchkeydown=0;
3438                         Person::players[i]->throwkeydown = 0;
3439                     }
3440
3441                     if (Dialog::inDialog()) {
3442                         Person::players[i]->forwardkeydown = 0;
3443                         Person::players[i]->leftkeydown = 0;
3444                         Person::players[i]->backkeydown = 0;
3445                         Person::players[i]->rightkeydown = 0;
3446                         Person::players[i]->jumpkeydown = 0;
3447                         Person::players[i]->crouchkeydown = 0;
3448                         Person::players[i]->drawkeydown = 0;
3449                         Person::players[i]->throwkeydown = 0;
3450                     }
3451
3452                     if (Person::players[i]->collided < -.3)
3453                         Person::players[i]->collided = -.3;
3454                     if (Person::players[i]->collided > 1)
3455                         Person::players[i]->collided = 1;
3456                     Person::players[i]->collided -= multiplier * 4;
3457                     Person::players[i]->whichdirectiondelay -= multiplier;
3458                     if (Person::players[i]->avoidcollided < -.3 || Person::players[i]->whichdirectiondelay <= 0) {
3459                         Person::players[i]->avoidcollided = -.3;
3460                         Person::players[i]->whichdirection = abs(Random() % 2);
3461                         Person::players[i]->whichdirectiondelay = .4;
3462                     }
3463                     if (Person::players[i]->avoidcollided > 1)
3464                         Person::players[i]->avoidcollided = 1;
3465                     Person::players[i]->avoidcollided -= multiplier / 4;
3466                     if (!Person::players[i]->skeleton.free) {
3467                         Person::players[i]->stunned -= multiplier;
3468                         Person::players[i]->surprised -= multiplier;
3469                     }
3470                     if (i != 0 && Person::players[i]->surprised <= 0 &&
3471                         Person::players[i]->aitype == attacktypecutoff &&
3472                         !Person::players[i]->dead &&
3473                         !Person::players[i]->skeleton.free &&
3474                         Animation::animations[Person::players[i]->animTarget].attack == neutral)
3475                         numresponded = 1;
3476
3477                     if (!Person::players[i]->throwkeydown)
3478                         Person::players[i]->throwtogglekeydown = 0;
3479
3480                     //pick up weapon
3481                     if (Person::players[i]->throwkeydown && !Person::players[i]->throwtogglekeydown) {
3482                         if (Person::players[i]->weaponactive == -1 &&
3483                             Person::players[i]->num_weapons < 2 &&
3484                             (Person::players[i]->isIdle() ||
3485                              Person::players[i]->isCrouch() ||
3486                              Person::players[i]->animTarget == sneakanim ||
3487                              Person::players[i]->animTarget == rollanim ||
3488                              Person::players[i]->animTarget == backhandspringanim ||
3489                              Person::players[i]->isFlip() ||
3490                              Person::players[i]->aitype != playercontrolled)) {
3491                             for (unsigned j = 0; j < weapons.size(); j++) {
3492                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
3493                                      Person::players[i]->aitype == playercontrolled) &&
3494                                     weapons[j].owner == -1 &&
3495                                     Person::players[i]->weaponactive == -1)
3496                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2) {
3497                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 2) {
3498                                             if (Person::players[i]->isCrouch() ||
3499                                                 Person::players[i]->animTarget == sneakanim ||
3500                                                 Person::players[i]->isRun() ||
3501                                                 Person::players[i]->isIdle() ||
3502                                                 Person::players[i]->aitype != playercontrolled) {
3503                                                 Person::players[i]->throwtogglekeydown = 1;
3504                                                 Person::players[i]->setTargetAnimation(crouchremoveknifeanim);
3505                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
3506                                                 Person::players[i]->hasvictim = 0;
3507                                             }
3508                                             if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
3509                                                 Person::players[i]->throwtogglekeydown = 1;
3510                                                 Person::players[i]->hasvictim = 0;
3511
3512                                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
3513                                                      Person::players[i]->aitype == playercontrolled) &&
3514                                                         weapons[j].owner == -1 ||
3515                                                     Person::players[i]->victim &&
3516                                                         weapons[j].owner == int(Person::players[i]->victim->id))
3517                                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2 && Person::players[i]->weaponactive == -1)
3518                                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 1 || Person::players[i]->victim) {
3519                                                             if (weapons[j].getType() != staff)
3520                                                                 emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
3521
3522                                                             Person::players[i]->takeWeapon(j);
3523                                                         }
3524                                             }
3525                                         } else if ((Person::players[i]->isIdle() ||
3526                                                     Person::players[i]->isFlip() ||
3527                                                     Person::players[i]->aitype != playercontrolled) &&
3528                                                    distsq(&Person::players[i]->coords, &weapons[j].position) < 5 &&
3529                                                    Person::players[i]->coords.y < weapons[j].position.y) {
3530                                             if (!Person::players[i]->isFlip()) {
3531                                                 Person::players[i]->throwtogglekeydown = 1;
3532                                                 Person::players[i]->setTargetAnimation(removeknifeanim);
3533                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
3534                                             }
3535                                             if (Person::players[i]->isFlip()) {
3536                                                 Person::players[i]->throwtogglekeydown = 1;
3537                                                 Person::players[i]->hasvictim = 0;
3538
3539                                                 for (unsigned k = 0; k < weapons.size(); k++) {
3540                                                     if (Person::players[i]->weaponactive == -1)
3541                                                         if ((weapons[k].velocity.x == 0 && weapons[k].velocity.y == 0 && weapons[k].velocity.z == 0 ||
3542                                                              Person::players[i]->aitype == playercontrolled) &&
3543                                                                 weapons[k].owner == -1 ||
3544                                                             Person::players[i]->victim &&
3545                                                                 weapons[k].owner == int(Person::players[i]->victim->id))
3546                                                             if (distsqflat(&Person::players[i]->coords, &weapons[k].position) < 3 &&
3547                                                                 Person::players[i]->weaponactive == -1) {
3548                                                                 if (weapons[k].getType() != staff)
3549                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
3550
3551                                                                 Person::players[i]->takeWeapon(k);
3552                                                             }
3553                                                 }
3554                                             }
3555                                         }
3556                                     }
3557                             }
3558                             if (Person::players[i]->isCrouch() ||
3559                                 Person::players[i]->animTarget == sneakanim ||
3560                                 Person::players[i]->isRun() ||
3561                                 Person::players[i]->isIdle() || Person::players[i]->animTarget == rollanim ||
3562                                 Person::players[i]->animTarget == backhandspringanim) {
3563                                 if (Person::players.size() > 1)
3564                                     for (unsigned j = 0; j < Person::players.size(); j++) {
3565                                         if (Person::players[i]->weaponactive == -1)
3566                                             if (j != i)
3567                                                 if (Person::players[j]->num_weapons &&
3568                                                     Person::players[j]->skeleton.free &&
3569                                                     distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 2 /*&&Person::players[j]->dead*/ &&
3570                                                     (((Person::players[j]->skeleton.forward.y < 0 &&
3571                                                        Person::players[j]->weaponstuckwhere == 0) ||
3572                                                       (Person::players[j]->skeleton.forward.y > 0 &&
3573                                                        Person::players[j]->weaponstuckwhere == 1)) ||
3574                                                      Person::players[j]->weaponstuck == -1 ||
3575                                                      Person::players[j]->num_weapons > 1)) {
3576                                                     if (Person::players[i]->animTarget != rollanim && Person::players[i]->animTarget != backhandspringanim) {
3577                                                         Person::players[i]->throwtogglekeydown = 1;
3578                                                         Person::players[i]->victim = Person::players[j];
3579                                                         Person::players[i]->hasvictim = 1;
3580                                                         Person::players[i]->setTargetAnimation(crouchremoveknifeanim);
3581                                                         Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
3582                                                     }
3583                                                     if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
3584                                                         Person::players[i]->throwtogglekeydown = 1;
3585                                                         Person::players[i]->victim = Person::players[j];
3586                                                         Person::players[i]->hasvictim = 1;
3587                                                         int k = Person::players[j]->weaponids[0];
3588                                                         if (Person::players[i]->hasvictim) {
3589                                                             bool fleshstuck;
3590                                                             fleshstuck = 0;
3591                                                             if (Person::players[i]->victim->weaponstuck != -1) {
3592                                                                 if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
3593                                                                     fleshstuck = 1;
3594                                                                 }
3595                                                             }
3596                                                             if (!fleshstuck) {
3597                                                                 if (weapons[k].getType() != staff)
3598                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
3599                                                             }
3600                                                             if (fleshstuck)
3601                                                                 emit_sound_at(fleshstabremovesound, Person::players[i]->coords, 128.);
3602
3603                                                             if (weapons[k].owner != -1) {
3604                                                                 if (Person::players[i]->victim->num_weapons == 1)
3605                                                                     Person::players[i]->victim->num_weapons = 0;
3606                                                                 else
3607                                                                     Person::players[i]->victim->num_weapons = 1;
3608
3609                                                                 Person::players[i]->victim->skeleton.longdead = 0;
3610                                                                 Person::players[i]->victim->skeleton.free = 1;
3611                                                                 Person::players[i]->victim->skeleton.broken = 0;
3612
3613                                                                 for (unsigned l = 0; l < Person::players[i]->victim->skeleton.joints.size(); l++) {
3614                                                                     Person::players[i]->victim->skeleton.joints[l].velchange = 0;
3615                                                                     Person::players[i]->victim->skeleton.joints[l].locked = 0;
3616                                                                 }
3617
3618                                                                 XYZ relative;
3619                                                                 relative = 0;
3620                                                                 relative.y = 10;
3621                                                                 Normalise(&relative);
3622                                                                 XYZ footvel, footpoint;
3623                                                                 footvel = 0;
3624                                                                 footpoint = weapons[k].position;
3625                                                                 if (Person::players[i]->victim->weaponstuck != -1) {
3626                                                                     if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
3627                                                                         if (bloodtoggle)
3628                                                                             Sprite::MakeSprite(cloudimpactsprite, footpoint, footvel, 1, 0, 0, .8, .3);
3629                                                                         weapons[k].bloody = 2;
3630                                                                         weapons[k].blooddrip = 5;
3631                                                                         Person::players[i]->victim->weaponstuck = -1;
3632                                                                         Person::players[i]->victim->bloodloss += 2000;
3633                                                                         Person::players[i]->victim->DoDamage(2000);
3634                                                                     }
3635                                                                 }
3636                                                                 if (Person::players[i]->victim->num_weapons > 0) {
3637                                                                     if (Person::players[i]->victim->weaponstuck != 0 && Person::players[i]->victim->weaponstuck != -1)
3638                                                                         Person::players[i]->victim->weaponstuck = 0;
3639                                                                     if (Person::players[i]->victim->weaponids[0] == k)
3640                                                                         Person::players[i]->victim->weaponids[0] = Person::players[i]->victim->weaponids[Person::players[i]->victim->num_weapons];
3641                                                                 }
3642
3643                                                                 Person::players[i]->victim->weaponactive = -1;
3644
3645                                                                 Person::players[i]->victim->jointVel(abdomen) += relative * 6;
3646                                                                 Person::players[i]->victim->jointVel(neck) += relative * 6;
3647                                                                 Person::players[i]->victim->jointVel(rightshoulder) += relative * 6;
3648                                                                 Person::players[i]->victim->jointVel(leftshoulder) += relative * 6;
3649                                                             }
3650                                                             Person::players[i]->takeWeapon(k);
3651                                                         }
3652                                                     }
3653                                                 }
3654                                     }
3655                             }
3656                         }
3657                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
3658                             if (weapons[Person::players[i]->weaponids[0]].getType() == knife) {
3659                                 if (Person::players[i]->isIdle() ||
3660                                     Person::players[i]->isRun() ||
3661                                     Person::players[i]->isCrouch() ||
3662                                     Person::players[i]->animTarget == sneakanim ||
3663                                     Person::players[i]->isFlip())
3664                                     if (Person::players.size() > 1)
3665                                         for (unsigned j = 0; j < Person::players.size(); j++) {
3666                                             if (i != j)
3667                                                 if (!Tutorial::active || Tutorial::stage == 49)
3668                                                     if (hostile)
3669                                                         if (normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0 &&
3670                                                             distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
3671                                                             distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
3672                                                             !Person::players[j]->skeleton.free &&
3673                                                             -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)) {
3674                                                             if (!Person::players[i]->isFlip()) {
3675                                                                 Person::players[i]->throwtogglekeydown = 1;
3676                                                                 Person::players[i]->victim = Person::players[j];
3677                                                                 Person::players[i]->setTargetAnimation(knifethrowanim);
3678                                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
3679                                                                 Person::players[i]->targettilt2 = pitchTo(Person::players[i]->coords, Person::players[j]->coords);
3680                                                             }
3681                                                             if (Person::players[i]->isFlip()) {
3682                                                                 if (Person::players[i]->weaponactive != -1) {
3683                                                                     Person::players[i]->throwtogglekeydown = 1;
3684                                                                     Person::players[i]->victim = Person::players[j];
3685                                                                     XYZ aim;
3686                                                                     aim = Person::players[i]->victim->coords + DoRotation(Person::players[i]->victim->jointPos(abdomen), 0, Person::players[i]->victim->yaw, 0) * Person::players[i]->victim->scale + Person::players[i]->victim->velocity * findDistance(&Person::players[i]->victim->coords, &Person::players[i]->coords) / 50 - (Person::players[i]->coords + DoRotation(Person::players[i]->jointPos(righthand), 0, Person::players[i]->yaw, 0) * Person::players[i]->scale);
3687                                                                     Normalise(&aim);
3688
3689                                                                     aim = DoRotation(aim, (float)abs(Random() % 30) - 15, (float)abs(Random() % 30) - 15, 0);
3690
3691                                                                     weapons[Person::players[i]->weaponids[0]].thrown(aim * 50, false);
3692                                                                     Person::players[i]->num_weapons--;
3693                                                                     if (Person::players[i]->num_weapons) {
3694                                                                         Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
3695                                                                     }
3696                                                                     Person::players[i]->weaponactive = -1;
3697                                                                 }
3698                                                             }
3699                                                         }
3700                                         }
3701                             }
3702                         }
3703                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
3704                             if (Person::players[i]->isCrouch() || Person::players[i]->animTarget == sneakanim) {
3705                                 Person::players[i]->throwtogglekeydown = 1;
3706                                 XYZ tempVelocity = Person::players[i]->velocity * .2;
3707                                 if (tempVelocity.x == 0)
3708                                     tempVelocity.x = .1;
3709                                 weapons[Person::players[i]->weaponids[0]].drop(tempVelocity, tempVelocity, false);
3710                                 Person::players[i]->num_weapons--;
3711                                 if (Person::players[i]->num_weapons) {
3712                                     Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
3713                                     if (Person::players[i]->weaponstuck == Person::players[i]->num_weapons)
3714                                         Person::players[i]->weaponstuck = 0;
3715                                 }
3716
3717                                 Person::players[i]->weaponactive = -1;
3718                                 for (unsigned j = 0; j < Person::players.size(); j++) {
3719                                     Person::players[j]->wentforweapon = 0;
3720                                 }
3721                             }
3722                         }
3723                     }
3724
3725                     //draw weapon
3726                     if (i == 0 || !Person::players[0]->dead || (Person::players[i]->weaponactive != -1)) {
3727                         if (Person::players[i]->drawkeydown && !Person::players[i]->drawtogglekeydown ||
3728                             (Person::players[i]->num_weapons == 2) &&
3729                                 (Person::players[i]->weaponactive == -1) &&
3730                                 Person::players[i]->isIdle() ||
3731                             Person::players[0]->dead &&
3732                                 (Person::players[i]->weaponactive != -1) &&
3733                                 i != 0) {
3734                             bool isgood = true;
3735                             if (Person::players[i]->weaponactive != -1)
3736                                 if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == staff)
3737                                     isgood = false;
3738                             if (isgood && Person::players[i]->creature != wolftype) {
3739                                 if (Person::players[i]->isIdle() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
3740                                     Person::players[i]->setTargetAnimation(drawrightanim);
3741                                     Person::players[i]->drawtogglekeydown = 1;
3742                                 }
3743                                 if ((Person::players[i]->isIdle() ||
3744                                      (Person::players[i]->aitype != playercontrolled &&
3745                                       Person::players[0]->weaponactive != -1 &&
3746                                       Person::players[i]->isRun())) &&
3747                                     Person::players[i]->num_weapons &&
3748                                     weapons[Person::players[i]->weaponids[0]].getType() == sword) {
3749                                     Person::players[i]->setTargetAnimation(drawleftanim);
3750                                     Person::players[i]->drawtogglekeydown = 1;
3751                                 }
3752                                 if (Person::players[i]->isCrouch() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
3753                                     Person::players[i]->setTargetAnimation(crouchdrawrightanim);
3754                                     Person::players[i]->drawtogglekeydown = 1;
3755                                 }
3756                             }
3757                         }
3758                     }
3759
3760                     //clean weapon
3761                     if (Person::players[i]->weaponactive != -1) {
3762                         if (Person::players[i]->isCrouch() &&
3763                             weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
3764                             bloodtoggle &&
3765                             Person::players[i]->onterrain &&
3766                             Person::players[i]->num_weapons &&
3767                             Person::players[i]->attackkeydown &&
3768                             musictype != stream_fighttheme) {
3769                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == knife)
3770                                 Person::players[i]->setTargetAnimation(crouchstabanim);
3771                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == sword)
3772                                 Person::players[i]->setTargetAnimation(swordgroundstabanim);
3773                             Person::players[i]->hasvictim = 0;
3774                         }
3775                     }
3776
3777                     if (!Person::players[i]->drawkeydown)
3778                         Person::players[i]->drawtogglekeydown = 0;
3779
3780                     XYZ absflatfacing;
3781                     if (i == 0) {
3782                         absflatfacing = 0;
3783                         absflatfacing.z = -1;
3784
3785                         absflatfacing = DoRotation(absflatfacing, 0, -yaw, 0);
3786                     } else
3787                         absflatfacing = flatfacing;
3788
3789                     if (Dialog::inDialog()) {
3790                         Person::players[i]->forwardkeydown = 0;
3791                         Person::players[i]->leftkeydown = 0;
3792                         Person::players[i]->backkeydown = 0;
3793                         Person::players[i]->rightkeydown = 0;
3794                         Person::players[i]->jumpkeydown = 0;
3795                         Person::players[i]->crouchkeydown = 0;
3796                         Person::players[i]->drawkeydown = 0;
3797                         Person::players[i]->throwkeydown = 0;
3798                     }
3799                     movekey = 0;
3800                     //Do controls
3801                     if (!Animation::animations[Person::players[i]->animTarget].attack &&
3802                         Person::players[i]->animTarget != staggerbackhighanim &&
3803                         Person::players[i]->animTarget != staggerbackhardanim &&
3804                         Person::players[i]->animTarget != backhandspringanim &&
3805                         Person::players[i]->animTarget != dodgebackanim) {
3806                         if (!Person::players[i]->forwardkeydown)
3807                             Person::players[i]->forwardstogglekeydown = 0;
3808                         if (Person::players[i]->crouchkeydown) {
3809                             //Crouch
3810                             target = -2;
3811                             if (i == 0) {
3812                                 Person::players[i]->superruntoggle = 1;
3813                                 if (Person::players.size() > 1)
3814                                     for (unsigned j = 0; j < Person::players.size(); j++)
3815                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->aitype == passivetype)
3816                                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 16)
3817                                                 Person::players[i]->superruntoggle = 0;
3818                             }
3819
3820                             if (Person::players.size() > 1)
3821                                 for (unsigned j = 0; j < Person::players.size(); j++) {
3822                                     if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim && Person::players[i]->lowreversaldelay <= 0) {
3823                                         if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
3824                                             Person::players[j]->victim == Person::players[i] &&
3825                                             (Person::players[j]->animTarget == sweepanim ||
3826                                              Person::players[j]->animTarget == upunchanim ||
3827                                              Person::players[j]->animTarget == wolfslapanim ||
3828                                              ((Person::players[j]->animTarget == swordslashanim ||
3829                                                Person::players[j]->animTarget == knifeslashstartanim ||
3830                                                Person::players[j]->animTarget == staffhitanim ||
3831                                                Person::players[j]->animTarget == staffspinhitanim) &&
3832                                               distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2))) {
3833                                             if (target >= 0)
3834                                                 target = -1;
3835                                             else
3836                                                 target = j;
3837                                         }
3838                                     }
3839                                 }
3840                             if (target >= 0)
3841                                 Person::players[target]->Reverse();
3842                             Person::players[i]->lowreversaldelay = .5;
3843
3844                             if (Person::players[i]->isIdle()) {
3845                                 Person::players[i]->setTargetAnimation(Person::players[i]->getCrouch());
3846                                 Person::players[i]->transspeed = 10;
3847                             }
3848                             if (Person::players[i]->isRun() ||
3849                                 (Person::players[i]->isStop() &&
3850                                  (Person::players[i]->leftkeydown ||
3851                                   Person::players[i]->rightkeydown ||
3852                                   Person::players[i]->forwardkeydown ||
3853                                   Person::players[i]->backkeydown))) {
3854                                 Person::players[i]->setTargetAnimation(rollanim);
3855                                 Person::players[i]->transspeed = 20;
3856                             }
3857                         }
3858                         if (!Person::players[i]->crouchkeydown) {
3859                             //Uncrouch
3860                             if (!Person::players[i]->isRun() && Person::players[i]->animTarget != sneakanim && i == 0)
3861                                 Person::players[i]->superruntoggle = 0;
3862                             target = -2;
3863                             if (Person::players[i]->isCrouch()) {
3864                                 if (Person::players.size() > 1)
3865                                     for (unsigned j = 0; j < Person::players.size(); j++) {
3866                                         if (j != i &&
3867                                             !Person::players[j]->skeleton.free &&
3868                                             Person::players[j]->victim &&
3869                                             Person::players[i]->highreversaldelay <= 0) {
3870                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
3871                                                 Person::players[j]->victim == Person::players[i] &&
3872                                                 (Person::players[j]->animTarget == spinkickanim) &&
3873                                                 Person::players[i]->isCrouch()) {
3874                                                 if (target >= 0)
3875                                                     target = -1;
3876                                                 else
3877                                                     target = j;
3878                                             }
3879                                         }
3880                                     }
3881                                 if (target >= 0)
3882                                     Person::players[target]->Reverse();
3883                                 Person::players[i]->highreversaldelay = .5;
3884
3885                                 if (Person::players[i]->isCrouch()) {
3886                                     if (!Person::players[i]->wasCrouch()) {
3887                                         Person::players[i]->animCurrent = Person::players[i]->getCrouch();
3888                                         Person::players[i]->frameCurrent = 0;
3889                                     }
3890                                     Person::players[i]->setTargetAnimation(Person::players[i]->getIdle());
3891                                     Person::players[i]->transspeed = 10;
3892                                 }
3893                             }
3894                             if (Person::players[i]->animTarget == sneakanim) {
3895                                 Person::players[i]->setTargetAnimation(Person::players[i]->getIdle());
3896                                 Person::players[i]->transspeed = 10;
3897                             }
3898                         }
3899                         if (Person::players[i]->forwardkeydown) {
3900                             if (Person::players[i]->isIdle() ||
3901                                 (Person::players[i]->isStop() &&
3902                                  Person::players[i]->targetyaw == Person::players[i]->yaw) ||
3903                                 (Person::players[i]->isLanding() &&
3904                                  Person::players[i]->frameTarget > 0 &&
3905                                  !Person::players[i]->jumpkeydown) ||
3906                                 (Person::players[i]->isLandhard() &&
3907                                  Person::players[i]->frameTarget > 0 &&
3908                                  !Person::players[i]->jumpkeydown &&
3909                                  Person::players[i]->crouchkeydown)) {
3910                                 if (Person::players[i]->aitype == passivetype)
3911                                     Person::players[i]->setTargetAnimation(walkanim);
3912                                 else
3913                                     Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
3914                             }
3915                             if (Person::players[i]->isCrouch()) {
3916                                 Person::players[i]->animTarget = sneakanim;
3917                                 if (Person::players[i]->wasCrouch())
3918                                     Person::players[i]->target = 0;
3919                                 Person::players[i]->frameTarget = 0;
3920                             }
3921                             if (Person::players[i]->animTarget == hanganim /*&&(!Person::players[i]->forwardstogglekeydown||Person::players[i]->aitype!=playercontrolled)*/) {
3922                                 Person::players[i]->setTargetAnimation(climbanim);
3923                                 Person::players[i]->frameTarget = 1;
3924                                 Person::players[i]->jumpclimb = 1;
3925                             }
3926                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
3927                                 Person::players[i]->velocity += absflatfacing * 5 * multiplier;
3928                             }
3929                             Person::players[i]->forwardstogglekeydown = 1;
3930                             movekey = 1;
3931                         }
3932                         if (Person::players[i]->rightkeydown) {
3933                             if (Person::players[i]->isIdle() ||
3934                                 (Person::players[i]->isStop() &&
3935                                  Person::players[i]->targetyaw == Person::players[i]->yaw) ||
3936                                 (Person::players[i]->isLanding() &&
3937                                  Person::players[i]->frameTarget > 0 &&
3938                                  !Person::players[i]->jumpkeydown) ||
3939                                 (Person::players[i]->isLandhard() &&
3940                                  Person::players[i]->frameTarget > 0 &&
3941                                  !Person::players[i]->jumpkeydown &&
3942                                  Person::players[i]->crouchkeydown)) {
3943                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
3944                             }
3945                             if (Person::players[i]->isCrouch()) {
3946                                 Person::players[i]->animTarget = sneakanim;
3947                                 if (Person::players[i]->wasCrouch())
3948                                     Person::players[i]->target = 0;
3949                                 Person::players[i]->frameTarget = 0;
3950                             }
3951                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
3952                                 Person::players[i]->velocity += DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
3953                             }
3954                             Person::players[i]->targetyaw -= 90;
3955                             if (Person::players[i]->forwardkeydown)
3956                                 Person::players[i]->targetyaw += 45;
3957                             if (Person::players[i]->backkeydown)
3958                                 Person::players[i]->targetyaw -= 45;
3959                             movekey = 1;
3960                         }
3961                         if (Person::players[i]->leftkeydown) {
3962                             if (Person::players[i]->isIdle() ||
3963                                 (Person::players[i]->isStop() &&
3964                                  Person::players[i]->targetyaw == Person::players[i]->yaw) ||
3965                                 (Person::players[i]->isLanding() &&
3966                                  Person::players[i]->frameTarget > 0 &&
3967                                  !Person::players[i]->jumpkeydown) ||
3968                                 (Person::players[i]->isLandhard() &&
3969                                  Person::players[i]->frameTarget > 0 &&
3970                                  !Person::players[i]->jumpkeydown &&
3971                                  Person::players[i]->crouchkeydown)) {
3972                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
3973                             }
3974                             if (Person::players[i]->isCrouch()) {
3975                                 Person::players[i]->animTarget = sneakanim;
3976                                 if (Person::players[i]->wasCrouch())
3977                                     Person::players[i]->target = 0;
3978                                 Person::players[i]->frameTarget = 0;
3979                             }
3980                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
3981                                 Person::players[i]->velocity -= DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
3982                             }
3983                             Person::players[i]->targetyaw += 90;
3984                             if (Person::players[i]->forwardkeydown)
3985                                 Person::players[i]->targetyaw -= 45;
3986                             if (Person::players[i]->backkeydown)
3987                                 Person::players[i]->targetyaw += 45;
3988                             movekey = 1;
3989                         }
3990                         if (Person::players[i]->backkeydown) {
3991                             if (Person::players[i]->isIdle() ||
3992                                 (Person::players[i]->isStop() &&
3993                                  Person::players[i]->targetyaw == Person::players[i]->yaw) ||
3994                                 (Person::players[i]->isLanding() &&
3995                                  Person::players[i]->frameTarget > 0 &&
3996                                  !Person::players[i]->jumpkeydown) ||
3997                                 (Person::players[i]->isLandhard() &&
3998                                  Person::players[i]->frameTarget > 0 &&
3999                                  !Person::players[i]->jumpkeydown &&
4000                                  Person::players[i]->crouchkeydown)) {
4001                                 Person::players[i]->setTargetAnimation(Person::players[i]->getRun());
4002                             }
4003                             if (Person::players[i]->isCrouch()) {
4004                                 Person::players[i]->animTarget = sneakanim;
4005                                 if (Person::players[i]->wasCrouch())
4006                                     Person::players[i]->target = 0;
4007                                 Person::players[i]->frameTarget = 0;
4008                             }
4009                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
4010                                 Person::players[i]->velocity -= absflatfacing * 5 * multiplier;
4011                             }
4012                             if (Person::players[i]->animTarget == hanganim) {
4013                                 Person::players[i]->animCurrent = jumpdownanim;
4014                                 Person::players[i]->animTarget = jumpdownanim;
4015                                 Person::players[i]->target = 0;
4016                                 Person::players[i]->frameCurrent = 0;
4017                                 Person::players[i]->frameTarget = 1;
4018                                 Person::players[i]->velocity = 0;
4019                                 Person::players[i]->velocity.y += gravity;
4020                                 Person::players[i]->coords.y -= 1.4;
4021                                 Person::players[i]->grabdelay = 1;
4022                             }
4023                             if (!Person::players[i]->leftkeydown && !Person::players[i]->rightkeydown)
4024                                 Person::players[i]->targetyaw += 180;
4025                             movekey = 1;
4026                         }
4027                         if ((Person::players[i]->jumpkeydown && !Person::players[i]->jumpclimb) || Person::players[i]->jumpstart) {
4028                             if ((((Person::players[i]->isLanding() && Person::players[i]->frameTarget >= 3) ||
4029                                   Person::players[i]->isRun() ||
4030                                   Person::players[i]->animTarget == walkanim ||
4031                                   Person::players[i]->isCrouch() ||
4032                                   Person::players[i]->animTarget == sneakanim) &&
4033                                  Person::players[i]->jumppower > 1) &&
4034                                 ((Person::players[i]->animTarget != rabbitrunninganim &&
4035                                   Person::players[i]->animTarget != wolfrunninganim) ||
4036                                  i != 0)) {
4037                                 Person::players[i]->jumpstart = 0;
4038                                 Person::players[i]->setTargetAnimation(jumpupanim);
4039                                 Person::players[i]->yaw = Person::players[i]->targetyaw;
4040                                 Person::players[i]->transspeed = 20;
4041                                 Person::players[i]->FootLand(leftfoot, 1);
4042                                 Person::players[i]->FootLand(rightfoot, 1);
4043
4044                                 facing = 0;
4045                                 facing.z = -1;
4046                                 flatfacing = DoRotation(facing, 0, Person::players[i]->targetyaw + 180, 0);
4047
4048                                 if (movekey)
4049                                     Person::players[i]->velocity = flatfacing * Person::players[i]->speed * 45 * Person::players[i]->scale;
4050                                 if (!movekey)
4051                                     Person::players[i]->velocity = 0;
4052
4053                                 //Dodge sweep?
4054                                 target = -2;
4055                                 if (Person::players.size() > 1)
4056                                     for (unsigned j = 0; j < Person::players.size(); j++) {
4057                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim) {
4058                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
4059                                                 (Person::players[j]->victim == Person::players[i]) &&
4060                                                 (Person::players[j]->animTarget == sweepanim)) {
4061                                                 if (target >= 0)
4062                                                     target = -1;
4063                                                 else
4064                                                     target = j;
4065                                             }
4066                                         }
4067                                     }
4068                                 if (target >= 0)
4069                                     Person::players[i]->velocity.y = 1;
4070                                 else if (Person::players[i]->crouchkeydown || Person::players[i]->aitype != playercontrolled) {
4071                                     Person::players[i]->velocity.y = 7;
4072                                     Person::players[i]->crouchtogglekeydown = 1;
4073                                 } else
4074                                     Person::players[i]->velocity.y = 5;
4075
4076                                 if (mousejump && i == 0 && devtools) {
4077                                     if (!Person::players[i]->isLanding())
4078                                         Person::players[i]->tempdeltav = deltav;
4079                                     if (Person::players[i]->tempdeltav < 0)
4080                                         Person::players[i]->velocity.y -= (float)(Person::players[i]->tempdeltav) / multiplier / 1000;
4081                                 }
4082
4083                                 Person::players[i]->coords.y += .2;
4084                                 Person::players[i]->jumppower -= 1;
4085
4086                                 if (!i)
4087                                     emit_sound_at(whooshsound, Person::players[i]->coords, 128.);
4088
4089                                 emit_sound_at(jumpsound, Person::players[i]->coords, 128.);
4090                             }
4091                             if ((Person::players[i]->isIdle()) && Person::players[i]->jumppower > 1) {
4092                                 Person::players[i]->setTargetAnimation(Person::players[i]->getLanding());
4093                                 Person::players[i]->frameTarget = 2;
4094                                 Person::players[i]->landhard = 0;
4095                                 Person::players[i]->jumpstart = 1;
4096                                 Person::players[i]->tempdeltav = deltav;
4097                             }
4098                             if (Person::players[i]->animTarget == jumpupanim &&
4099                                 (((!floatjump &&
4100                                    !editorenabled) ||
4101                                   !devtools) ||
4102                                  Person::players[i]->aitype != playercontrolled)) {
4103                                 if (Person::players[i]->jumppower > multiplier * 6) {
4104                                     Person::players[i]->velocity.y += multiplier * 6;
4105                                     Person::players[i]->jumppower -= multiplier * 6;
4106                                 }
4107                                 if (Person::players[i]->jumppower <= multiplier * 6) {
4108                                     Person::players[i]->velocity.y += Person::players[i]->jumppower;
4109                                     Person::players[i]->jumppower = 0;
4110                                 }
4111                             }
4112                             if (((floatjump || editorenabled) && devtools) && i == 0)
4113                                 Person::players[i]->velocity.y += multiplier * 30;
4114                         }
4115
4116                         if (!movekey) {
4117                             if (Person::players[i]->isRun() || Person::players[i]->animTarget == walkanim) {
4118                                 Person::players[i]->setTargetAnimation(Person::players[i]->getStop());
4119                             }
4120                             if (Person::players[i]->animTarget == sneakanim) {
4121                                 Person::players[i]->animTarget = Person::players[i]->getCrouch();
4122                                 if (Person::players[i]->animCurrent == sneakanim) {
4123                                     Person::players[i]->target = 0;
4124                                 }
4125                                 Person::players[i]->frameTarget = 0;
4126                             }
4127                         }
4128                         if (Person::players[i]->animTarget == walkanim &&
4129                             (Person::players[i]->aitype == attacktypecutoff ||
4130                              Person::players[i]->aitype == searchtype ||
4131                              (Person::players[i]->aitype == passivetype &&
4132                               Person::players[i]->numwaypoints <= 1)))
4133                             Person::players[i]->setTargetAnimation(Person::players[i]->getStop());
4134                         if (Person::players[i]->isRun() && (Person::players[i]->aitype == passivetype))
4135                             Person::players[i]->setTargetAnimation(Person::players[i]->getStop());
4136                     }
4137                 }
4138                 if (Person::players[i]->animTarget == rollanim)
4139                     Person::players[i]->targetyaw = oldtargetyaw;
4140             }
4141
4142             //Rotation
4143             for (unsigned k = 0; k < Person::players.size(); k++) {
4144                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 180) {
4145                     if (Person::players[k]->yaw > Person::players[k]->targetyaw)
4146                         Person::players[k]->yaw -= 360;
4147                     else
4148                         Person::players[k]->yaw += 360;
4149                 }
4150
4151                 //stop to turn in right direction
4152                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 90 && (Person::players[k]->isRun() || Person::players[k]->animTarget == walkanim))
4153                     Person::players[k]->setTargetAnimation(Person::players[k]->getStop());
4154
4155                 if (Person::players[k]->animTarget == backhandspringanim || Person::players[k]->animTarget == dodgebackanim)
4156                     Person::players[k]->targettilt = 0;
4157
4158                 if (Person::players[k]->animTarget != jumpupanim &&
4159                     Person::players[k]->animTarget != backhandspringanim &&
4160                     Person::players[k]->animTarget != jumpdownanim &&
4161                     !Person::players[k]->isFlip()) {
4162                     Person::players[k]->targettilt = 0;
4163                     if (Person::players[k]->jumppower < 0 && !Person::players[k]->jumpkeydown)
4164                         Person::players[k]->jumppower = 0;
4165                     Person::players[k]->jumppower += multiplier * 7;
4166                     if (Person::players[k]->isCrouch())
4167                         Person::players[k]->jumppower += multiplier * 7;
4168                     if (Person::players[k]->jumppower > 5)
4169                         Person::players[k]->jumppower = 5;
4170                 }
4171
4172                 if (Person::players[k]->isRun())
4173                     Person::players[k]->targettilt = (Person::players[k]->yaw - Person::players[k]->targetyaw) / 4;
4174
4175                 Person::players[k]->tilt = stepTowardf(Person::players[k]->tilt, Person::players[k]->targettilt, multiplier * 150);
4176                 Person::players[k]->grabdelay -= multiplier;
4177             }
4178
4179             //do animations
4180             for (unsigned k = 0; k < Person::players.size(); k++) {
4181                 Person::players[k]->DoAnimations();
4182                 Person::players[k]->whichpatchx = Person::players[k]->coords.x / (terrain.size / subdivision * terrain.scale);
4183                 Person::players[k]->whichpatchz = Person::players[k]->coords.z / (terrain.size / subdivision * terrain.scale);
4184             }
4185
4186             //do stuff
4187             Object::DoStuff();
4188
4189             for (int j = numenvsounds - 1; j >= 0; j--) {
4190                 envsoundlife[j] -= multiplier;
4191                 if (envsoundlife[j] < 0) {
4192                     numenvsounds--;
4193                     envsoundlife[j] = envsoundlife[numenvsounds];
4194                     envsound[j] = envsound[numenvsounds];
4195                 }
4196             }
4197             OPENAL_SetFrequency(OPENAL_ALL, slomo);
4198
4199             if (Tutorial::active) {
4200                 Tutorial::DoStuff(multiplier);
4201             }
4202
4203             //3d sound
4204             static float gLoc[3];
4205             gLoc[0] = viewer.x;
4206             gLoc[1] = viewer.y;
4207             gLoc[2] = viewer.z;
4208             static float vel[3];
4209             vel[0] = (viewer.x - oldviewer.x) / multiplier;
4210             vel[1] = (viewer.y - oldviewer.y) / multiplier;
4211             vel[2] = (viewer.z - oldviewer.z) / multiplier;
4212
4213             //Set orientation with forward and up vectors
4214             static XYZ upvector;
4215             upvector = 0;
4216             upvector.z = -1;
4217
4218             upvector = DoRotation(upvector, -pitch + 90, 0, 0);
4219             upvector = DoRotation(upvector, 0, 0 - yaw, 0);
4220
4221             facing = 0;
4222             facing.z = -1;
4223
4224             facing = DoRotation(facing, -pitch, 0, 0);
4225             facing = DoRotation(facing, 0, 0 - yaw, 0);
4226
4227             static float ori[6];
4228             ori[0] = -facing.x;
4229             ori[1] = facing.y;
4230             ori[2] = -facing.z;
4231             ori[3] = -upvector.x;
4232             ori[4] = upvector.y;
4233             ori[5] = -upvector.z;
4234
4235             OPENAL_3D_Listener_SetAttributes(&gLoc[0], &vel[0], ori[0], ori[1], ori[2], ori[3], ori[4], ori[5]);
4236             OPENAL_Update();
4237
4238             oldviewer = viewer;
4239         }
4240     }
4241
4242     if (Input::isKeyPressed(SDL_SCANCODE_F1))
4243         Screenshot();
4244 }
4245
4246 void Game::TickOnce()
4247 {
4248     if (mainmenu) {
4249         yaw += multiplier * 5;
4250     } else if (Dialog::directing || !Dialog::inDialog()) {
4251         yaw += deltah * .7;
4252         if (invertmouse) {
4253             pitch -= deltav * .7;
4254         } else {
4255             pitch += deltav * .7;
4256         }
4257         if (pitch > 90)
4258             pitch = 90;
4259         if (pitch < -70)
4260             pitch = -70;
4261     }
4262 }
4263
4264 void Game::TickOnceAfter()
4265 {
4266     static XYZ colviewer;
4267     static XYZ coltarget;
4268     static XYZ target;
4269     static XYZ col;
4270     static XYZ facing;
4271     static float changedelay;
4272     static bool alldead;
4273     static float unseendelay;
4274     static float cameraspeed;
4275
4276     if (!mainmenu) {
4277         static int oldmusictype = musictype;
4278
4279         if (environment == snowyenvironment)
4280             leveltheme = stream_snowtheme;
4281         if (environment == grassyenvironment)
4282             leveltheme = stream_grasstheme;
4283         if (environment == desertenvironment)
4284             leveltheme = stream_deserttheme;
4285
4286         realthreat = 0;
4287
4288         musictype = leveltheme;
4289         for (unsigned i = 0; i < Person::players.size(); i++) {
4290             if ((Person::players[i]->aitype == attacktypecutoff ||
4291                  Person::players[i]->aitype == getweapontype ||
4292                  Person::players[i]->aitype == gethelptype ||
4293                  Person::players[i]->aitype == searchtype) &&
4294                 !Person::players[i]->dead &&
4295                 (Person::players[i]->animTarget != sneakattackedanim &&
4296                  Person::players[i]->animTarget != knifesneakattackedanim &&
4297                  Person::players[i]->animTarget != swordsneakattackedanim)) {
4298                 musictype = stream_fighttheme;
4299                 realthreat = 1;
4300             }
4301         }
4302         if (Person::players[0]->dead)
4303             musictype = stream_menutheme;
4304
4305         if (musictype == stream_fighttheme)
4306             unseendelay = 1;
4307
4308         if (oldmusictype == stream_fighttheme && musictype != stream_fighttheme) {
4309             unseendelay -= multiplier;
4310             if (unseendelay > 0)
4311                 musictype = stream_fighttheme;
4312         }
4313
4314         if (loading == 2) {
4315             musictype = stream_menutheme;
4316             musicvolume[2] = 512;
4317             musicvolume[0] = 0;
4318             musicvolume[1] = 0;
4319             musicvolume[3] = 0;
4320         }
4321
4322         if (musictoggle)
4323             if (musictype != oldmusictype && musictype == stream_fighttheme)
4324                 emit_sound_np(alarmsound);
4325         musicselected = musictype;
4326
4327         if (musicselected == leveltheme)
4328             musicvolume[0] += multiplier * 450;
4329         else
4330             musicvolume[0] -= multiplier * 450;
4331         if (musicselected == stream_fighttheme)
4332             musicvolume[1] += multiplier * 450;
4333         else
4334             musicvolume[1] -= multiplier * 450;
4335         if (musicselected == stream_menutheme)
4336             musicvolume[2] += multiplier * 450;
4337         else
4338             musicvolume[2] -= multiplier * 450;
4339
4340         for (int i = 0; i < 3; i++) {
4341             if (musicvolume[i] < 0)
4342                 musicvolume[i] = 0;
4343             if (musicvolume[i] > 512)
4344                 musicvolume[i] = 512;
4345         }
4346
4347         if (musicvolume[2] > 128 && !loading && !mainmenu)
4348             musicvolume[2] = 128;
4349
4350         if (musictoggle) {
4351             if (musicvolume[0] > 0 && oldmusicvolume[0] <= 0)
4352                 emit_stream_np(leveltheme, musicvolume[0]);
4353             if (musicvolume[1] > 0 && oldmusicvolume[1] <= 0)
4354                 emit_stream_np(stream_fighttheme, musicvolume[1]);
4355             if (musicvolume[2] > 0 && oldmusicvolume[2] <= 0)
4356                 emit_stream_np(stream_menutheme, musicvolume[2]);
4357             if (musicvolume[0] <= 0 && oldmusicvolume[0] > 0)
4358                 pause_sound(leveltheme);
4359             if (musicvolume[1] <= 0 && oldmusicvolume[1] > 0)
4360                 pause_sound(stream_fighttheme);
4361             if (musicvolume[2] <= 0 && oldmusicvolume[2] > 0)
4362                 pause_sound(stream_menutheme);
4363
4364             if (musicvolume[0] != oldmusicvolume[0])
4365                 OPENAL_SetVolume(channels[leveltheme], musicvolume[0]);
4366             if (musicvolume[1] != oldmusicvolume[1])
4367                 OPENAL_SetVolume(channels[stream_fighttheme], musicvolume[1]);
4368             if (musicvolume[2] != oldmusicvolume[2])
4369                 OPENAL_SetVolume(channels[stream_menutheme], musicvolume[2]);
4370
4371             for (int i = 0; i < 3; i++)
4372                 oldmusicvolume[i] = musicvolume[i];
4373         } else {
4374             pause_sound(leveltheme);
4375             pause_sound(stream_fighttheme);
4376             pause_sound(stream_menutheme);
4377
4378             for (int i = 0; i < 4; i++) {
4379                 oldmusicvolume[i] = 0;
4380                 musicvolume[i] = 0;
4381             }
4382         }
4383
4384         Hotspot::killhotspot = 2;
4385         for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
4386             if (Hotspot::hotspots[i].type > 10 && Hotspot::hotspots[i].type < 20) {
4387                 if (Person::players[Hotspot::hotspots[i].type - 10]->dead == 0)
4388                     Hotspot::killhotspot = 0;
4389                 else if (Hotspot::killhotspot == 2)
4390                     Hotspot::killhotspot = 1;
4391             }
4392         }
4393         if (Hotspot::killhotspot == 2)
4394             Hotspot::killhotspot = 0;
4395
4396         winhotspot = false;
4397         for (unsigned i = 0; i < Hotspot::hotspots.size(); i++) {
4398             if (Hotspot::hotspots[i].type == -1) {
4399                 if (distsq(&Person::players[0]->coords, &Hotspot::hotspots[i].position) < Hotspot::hotspots[i].size) {
4400                     winhotspot = true;
4401                 }
4402             }
4403         }
4404
4405         int numalarmed = 0;
4406         for (unsigned i = 1; i < Person::players.size(); i++) {
4407             if (!Person::players[i]->dead && Person::players[i]->aitype == attacktypecutoff && Person::players[i]->surprised <= 0) {
4408                 numalarmed++;
4409             }
4410         }
4411         if (numalarmed > maxalarmed) {
4412             maxalarmed = numalarmed;
4413         }
4414
4415         if (changedelay <= 0 && !loading && !editorenabled && gameon && !Tutorial::active && changedelay != -999 && !won) {
4416             if (Person::players[0]->dead) {
4417                 changedelay = 1;
4418                 targetlevel = whichlevel;
4419             }
4420             alldead = true;
4421             for (unsigned i = 1; i < Person::players.size(); i++) {
4422                 if (!Person::players[i]->dead && Person::players[i]->howactive < typedead1) {
4423                     alldead = false;
4424                     break;
4425                 }
4426             }
4427
4428             if (alldead && !Person::players[0]->dead && maptype == mapkilleveryone) {
4429                 changedelay = 1;
4430                 targetlevel = whichlevel + 1;
4431                 if (targetlevel > numchallengelevels - 1)
4432                     targetlevel = 0;
4433             }
4434             if (winhotspot || windialogue) {
4435                 changedelay = 0.1;
4436                 targetlevel = whichlevel + 1;
4437                 if (targetlevel > numchallengelevels - 1)
4438                     targetlevel = 0;
4439             }
4440
4441             if (Hotspot::killhotspot) {
4442                 changedelay = 1;
4443                 targetlevel = whichlevel + 1;
4444                 if (targetlevel > numchallengelevels - 1)
4445                     targetlevel = 0;
4446             }
4447
4448             if (changedelay > 0 && !Person::players[0]->dead && !won) {
4449                 //high scores, awards, win
4450                 if (campaign) {
4451                     Account::active().winCampaignLevel(whichchoice, bonustotal, leveltime);
4452                     scoreadded = 1;
4453                 } else {
4454                     wonleveltime = leveltime;
4455                     Account::active().winLevel(whichlevel, bonustotal - startbonustotal, leveltime);
4456                 }
4457                 won = 1;
4458                 Account::saveFile(Folders::getUserSavePath());
4459             }
4460         }
4461
4462         if (!winfreeze) {
4463
4464             if (leveltime < 1) {
4465                 loading = 0;
4466                 changedelay = .1;
4467                 alldead = false;
4468                 winhotspot = false;
4469                 Hotspot::killhotspot = 0;
4470             }
4471
4472             if (!editorenabled && gameon && !mainmenu) {
4473                 if (changedelay != -999)
4474                     changedelay -= multiplier / 7;
4475                 if (Person::players[0]->dead)
4476                     targetlevel = whichlevel;
4477                 if (loading == 2 && !campaign) {
4478                     flash();
4479
4480                     fireSound(firestartsound);
4481
4482                     if (!Person::players[0]->dead && targetlevel != whichlevel)
4483                         startbonustotal = bonustotal;
4484
4485                     LoadLevel(targetlevel);
4486                     fireSound();
4487
4488                     loading = 3;
4489                 }
4490                 if (loading == 2 && targetlevel == whichlevel) {
4491                     flash();
4492                     loadtime = 0;
4493
4494                     fireSound(firestartsound);
4495
4496                     LoadLevel(campaignlevels[Account::active().getCampaignChoicesMade()].mapname.c_str());
4497
4498                     fireSound();
4499
4500                     loading = 3;
4501                 }
4502                 if (changedelay <= -999 &&
4503                     whichlevel != -2 &&
4504                     !loading &&
4505                     (Person::players[0]->dead ||
4506                      (alldead && maptype == mapkilleveryone) ||
4507                      (winhotspot) ||
4508                      (Hotspot::killhotspot)))
4509                     loading = 1;
4510                 if ((Person::players[0]->dead ||
4511                      (alldead && maptype == mapkilleveryone) ||
4512                      (winhotspot) ||
4513                      (windialogue) ||
4514                      (Hotspot::killhotspot)) &&
4515                     changedelay <= 0) {
4516                     if (whichlevel != -2 && !loading && !Person::players[0]->dead) {
4517                         winfreeze = true;
4518                         changedelay = -999;
4519                     }
4520                     if (Person::players[0]->dead)
4521                         loading = 1;
4522                 }
4523             }
4524
4525             if (campaign) {
4526                 // campaignchoosenext determines what to do when the level is complete:
4527                 // 0 = load next level
4528                 // 1 = go back to level select screen
4529                 // 2 = stealthload next level
4530                 if (mainmenu == 0 && winfreeze && (campaignlevels[actuallevel].choosenext) == 1) {
4531                     if (campaignlevels[actuallevel].nextlevel.empty())
4532                         endgame = 1;
4533                 } else if (mainmenu == 0 && winfreeze) {
4534                     stealthloading = (campaignlevels[actuallevel].choosenext == 2);
4535
4536                     if (!stealthloading) {
4537                         fireSound(firestartsound);
4538
4539                         flash();
4540                     }
4541
4542                     startbonustotal = 0;
4543
4544                     LoadCampaign();
4545
4546                     loading = 2;
4547                     loadtime = 0;
4548                     targetlevel = 7;
4549                     if (!firstLoadDone) {
4550                         LoadStuff();
4551                     }
4552                     whichchoice = 0;
4553                     actuallevel = campaignlevels[actuallevel].nextlevel.front();
4554                     visibleloading = true;
4555                     stillloading = 1;
4556                     LoadLevel(campaignlevels[actuallevel].mapname.c_str());
4557                     campaign = 1;
4558                     mainmenu = 0;
4559                     gameon = 1;
4560                     pause_sound(stream_menutheme);
4561
4562                     stealthloading = 0;
4563                 }
4564             }
4565
4566             if (loading == 3)
4567                 loading = 0;
4568         }
4569
4570         oldmusictype = musictype;
4571     }
4572
4573     facing = 0;
4574     facing.z = -1;
4575
4576     facing = DoRotation(facing, -pitch, 0, 0);
4577     facing = DoRotation(facing, 0, 0 - yaw, 0);
4578     viewerfacing = facing;
4579
4580     if (!cameramode) {
4581         if ((Animation::animations[Person::players[0]->animTarget].attack != 3 && Animation::animations[Person::players[0]->animCurrent].attack != 3) || Person::players[0]->skeleton.free)
4582             target = Person::players[0]->coords + Person::players[0]->currentoffset * (1 - Person::players[0]->target) * Person::players[0]->scale + Person::players[0]->targetoffset * Person::players[0]->target * Person::players[0]->scale - Person::players[0]->facing * .05;
4583         else
4584             target = Person::players[0]->oldcoords + Person::players[0]->currentoffset * (1 - Person::players[0]->target) * Person::players[0]->scale + Person::players[0]->targetoffset * Person::players[0]->target * Person::players[0]->scale - Person::players[0]->facing * .05;
4585         target.y += .1;
4586         if (Person::players[0]->skeleton.free) {
4587             for (unsigned i = 0; i < Person::players[0]->skeleton.joints.size(); i++) {
4588                 if (Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y > target.y)
4589                     target.y = Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y;
4590             }
4591             target.y += .1;
4592         }
4593         if (Person::players[0]->skeleton.free != 2) {
4594             cameraspeed = 20;
4595             if (findLengthfast(&Person::players[0]->velocity) > 400) {
4596                 cameraspeed = 20 + (findLength(&Person::players[0]->velocity) - 20) * .96;
4597             }
4598             if (Person::players[0]->skeleton.free == 0 && Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim)
4599                 target.y += 1.4;
4600             coltarget = target - cameraloc;
4601             if (findLengthfast(&coltarget) < multiplier * multiplier * 400)
4602                 cameraloc = target;
4603             else {
4604                 Normalise(&coltarget);
4605                 if (Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim && Person::players[0]->animCurrent != climbanim && Person::players[0]->currentoffset.x == 0)
4606                     cameraloc = cameraloc + coltarget * multiplier * cameraspeed;
4607                 else
4608                     cameraloc = cameraloc + coltarget * multiplier * 8;
4609             }
4610             if (editorenabled)
4611                 cameraloc = target;
4612             cameradist += multiplier * 5;
4613             if (cameradist > 2.3)
4614                 cameradist = 2.3;
4615             viewer = cameraloc - facing * cameradist;
4616             colviewer = viewer;
4617             coltarget = cameraloc;
4618             Object::SphereCheckPossible(&colviewer, findDistance(&colviewer, &coltarget));
4619             for (unsigned int j = 0; j < terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz].size(); j++) {
4620                 unsigned int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
4621                 colviewer = viewer;
4622                 coltarget = cameraloc;
4623                 if (Object::objects[i]->model.LineCheckPossible(&colviewer, &coltarget, &col, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1) {
4624                     viewer = col;
4625                 }
4626             }
4627             for (unsigned int j = 0; j < terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz].size(); j++) {
4628                 unsigned int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
4629                 colviewer = viewer;
4630                 if (Object::objects[i]->model.SphereCheck(&colviewer, .15, &col, &Object::objects[i]->position, &Object::objects[i]->yaw) != -1) {
4631                     viewer = colviewer;
4632                 }
4633             }
4634             cameradist = findDistance(&viewer, &target);
4635             viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .6);
4636             if (cameraloc.y < terrain.getHeight(cameraloc.x, cameraloc.z)) {
4637                 cameraloc.y = terrain.getHeight(cameraloc.x, cameraloc.z);
4638             }
4639         }
4640         if (camerashake > .8)
4641             camerashake = .8;
4642         woozy += multiplier;
4643         if (Person::players[0]->dead)
4644             camerashake = 0;
4645         if (Person::players[0]->dead)
4646             woozy = 0;
4647         camerashake -= multiplier * 2;
4648         blackout -= multiplier * 2;
4649         if (camerashake < 0)
4650             camerashake = 0;
4651         if (blackout < 0)
4652             blackout = 0;
4653         if (camerashake) {
4654             viewer.x += (float)(Random() % 100) * .0005 * camerashake;
4655             viewer.y += (float)(Random() % 100) * .0005 * camerashake;
4656             viewer.z += (float)(Random() % 100) * .0005 * camerashake;
4657         }
4658     }
4659 }