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