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