Source/GameTick.cpp

   1 /*
   2 Copyright (C) 2003, 2010 - Wolfire Games
   3
   4 This file is part of Lugaru.
   5
   6 Lugaru is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 Lugaru is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 // Enable full math definitions
  21 #define _USE_MATH_DEFINES
  22
  23 #if PLATFORM_UNIX
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27 #else
  28 #include <direct.h>
  29 #endif
  30
  31
  32 #include <limits>
  33 #include <ctime>
  34 #include <cmath>
  35 #include <dirent.h>
  36 #include "Game.h"
  37 #include "openal_wrapper.h"
  38 #include "Settings.h"
  39 #include "Input.h"
  40 #include "Animation.h"
  41 #include "Awards.h"
  42 #include "Menu.h"
  43
  44 #include <algorithm>
  45 #include <set>
  46
  47 using namespace std;
  48 using namespace Game;
  49
  50 // Added more evilness needed for MSVC
  51 #ifdef _MSC_VER
  52 #define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
  53 #define snprintf(buf, size, format, ...) _sprintf_p(buf, size, format)
  54 #endif
  55
  56
  57 extern float multiplier;
  58 extern XYZ viewer;
  59 extern int environment;
  60 extern Terrain terrain;
  61 extern float screenwidth, screenheight;
  62 extern float gravity;
  63 extern int detail;
  64 extern float texdetail;
  65 extern Objects objects;
  66 extern int slomo;
  67 extern float slomodelay;
  68 extern bool floatjump;
  69 extern float volume;
  70 extern Light light;
  71 extern float camerashake;
  72 extern float woozy;
  73 extern float blackout;
  74 extern bool cellophane;
  75 extern bool musictoggle;
  76 extern int difficulty;
  77 extern int bloodtoggle;
  78 extern bool invertmouse;
  79 extern float windvar;
  80 extern float precipdelay;
  81 extern XYZ viewerfacing;
  82 extern bool ambientsound;
  83 extern bool mousejump;
  84 extern float viewdistance;
  85 extern bool freeze;
  86 extern bool keyboardfrozen;
  87 extern bool loadingstuff;
  88 extern XYZ windvector;
  89 extern bool debugmode;
  90 static int leveltheme;
  91 extern int mainmenu;
  92 extern int oldmainmenu;
  93 extern bool visibleloading;
  94 extern XYZ envsound[30];
  95 extern float envsoundvol[30];
  96 extern int numenvsounds;
  97 extern float envsoundlife[30];
  98 extern float usermousesensitivity;
  99 extern bool ismotionblur;
 100 extern bool showdamagebar; // (des)activate the damage bar
 101 extern bool decals;
 102 extern float tintr, tintg, tintb;
 103 extern bool skyboxtexture;
 104 extern float skyboxr;
 105 extern float skyboxg;
 106 extern float skyboxb;
 107 extern float skyboxlightr;
 108 extern float skyboxlightg;
 109 extern float skyboxlightb;
 110 extern float fadestart;
 111 extern float slomospeed;
 112 extern float slomofreq;
 113 extern int tutoriallevel;
 114 extern float smoketex;
 115 extern float tutorialstagetime;
 116 extern int tutorialstage;
 117 extern float tutorialmaxtime;
 118 extern float tutorialsuccess;
 119 extern bool againbonus;
 120 extern bool reversaltrain;
 121 extern bool canattack;
 122 extern bool cananger;
 123 extern float damagedealt;
 124 extern int maptype;
 125 extern int editoractive;
 126 extern int editorpathtype;
 127 extern TGAImageRec texture;
 128
 129 extern float hostiletime;
 130
 131 extern bool gamestarted;
 132
 133 extern int numhotspots;
 134 extern int killhotspot;
 135 extern XYZ hotspot[40];
 136 extern int hotspottype[40];
 137 extern float hotspotsize[40];
 138 extern char hotspottext[40][256];
 139 extern int currenthotspot;
 140
 141 extern int hostile;
 142
 143 extern bool stillloading;
 144 extern bool winfreeze;
 145
 146 extern bool campaign;
 147
 148
 149 extern void toggleFullscreen();
 150
 151
 152 void Loadlevel(int which);
 153 void Loadlevel(const char *name);
 154
 155
 156 class CampaignLevel
 157 {
 158 private:
 159     int width;
 160     struct Position {
 161         int x, y;
 162     };
 163 public:
 164     std::string mapname;
 165     std::string description;
 166     int choosenext;
 167     /*
 168     0 = Immediately load next level at the end of this one.
 169     1 = Go back to the world map.
 170     2 = Don't bring up the Fiery loading screen. Maybe other things, I've not investigated.
 171     */
 172     //int numnext; // 0 on final level. As David said: he meant to add story branching, but he eventually hadn't.
 173     std::vector<int> nextlevel;
 174     Position location;
 175     CampaignLevel() : width(10) {
 176         choosenext = 1;
 177         location.x = 0;
 178         location.y = 0;
 179     }
 180     int getStartX() {
 181         return 30 + 120 + location.x * 400 / 512;
 182     }
 183     int getStartY() {
 184         return 30 + 30 + (512 - location.y) * 400 / 512;
 185     }
 186     int getEndX() {
 187         return getStartX() + width;
 188     }
 189     int getEndY() {
 190         return getStartY() + width;
 191     }
 192     XYZ getCenter() {
 193         XYZ center;
 194         center.x = getStartX() + width / 2;
 195         center.y = getStartY() + width / 2;
 196         return center;
 197     }
 198     int getWidth() {
 199         return width;
 200     }
 201     istream& operator<< (istream& is) {
 202         is.ignore(256, ':');
 203         is.ignore(256, ':');
 204         is.ignore(256, ' ');
 205         is >> mapname;
 206         is.ignore(256, ':');
 207         is >> description;
 208         for (size_t pos = description.find('_'); pos != string::npos; pos = description.find('_', pos)) {
 209             description.replace(pos, 1, 1, ' ');
 210         }
 211         is.ignore(256, ':');
 212         is >> choosenext;
 213         is.ignore(256, ':');
 214         int numnext, next;
 215         is >> numnext;
 216         for (int j = 0; j < numnext; j++) {
 217             is.ignore(256, ':');
 218             is >> next;
 219             nextlevel.push_back(next - 1);
 220         }
 221         is.ignore(256, ':');
 222         is >> location.x;
 223         is.ignore(256, ':');
 224         is >> location.y;
 225         return is;
 226     }
 227     friend istream& operator>> (istream& is, CampaignLevel& cl) {
 228         return cl << is;
 229     }
 230 };
 231
 232 int indemo = 0;
 233 bool won = false;
 234 int entername = 0;
 235 vector<CampaignLevel> campaignlevels;
 236 int whichchoice = 0;
 237 int actuallevel = 0;
 238 bool winhotspot = false;
 239 bool windialogue = false;
 240 bool realthreat = 0;
 241 XYZ cameraloc;
 242 float cameradist = 0;
 243 bool oldattackkey = 0;
 244 int whichlevel = 0;
 245 float musicvolume[4] = {};
 246 float oldmusicvolume[4] = {};
 247 int musicselected = 0;
 248
 249
 250
 251 static const char *rabbitskin[] = {
 252     ":Data:Textures:Fur3.jpg",
 253     ":Data:Textures:Fur.jpg",
 254     ":Data:Textures:Fur2.jpg",
 255     ":Data:Textures:Lynx.jpg",
 256     ":Data:Textures:Otter.jpg",
 257     ":Data:Textures:Opal.jpg",
 258     ":Data:Textures:Sable.jpg",
 259     ":Data:Textures:Chocolate.jpg",
 260     ":Data:Textures:BW2.jpg",
 261     ":Data:Textures:WB2.jpg"
 262 };
 263
 264 static const char *wolfskin[] = {
 265     ":Data:Textures:Wolf.jpg",
 266     ":Data:Textures:Darkwolf.jpg",
 267     ":Data:Textures:Snowwolf.jpg"
 268 };
 269
 270 #define STATIC_ASSERT(x) extern int s_a_dummy[2 * (!!(x)) - 1];
 271 STATIC_ASSERT (rabbittype == 0 && wolftype == 1)
 272
 273 static const char **creatureskin[] = {rabbitskin, wolfskin};
 274
 275 /* Return true if PFX is a prefix of STR (case-insensitive).  */
 276 static bool stripfx(const char *str, const char *pfx)
 277 {
 278     return !strncasecmp(str, pfx, strlen(pfx));
 279 }
 280
 281 static const char *cmd_names[] = {
 282 #define DECLARE_COMMAND(cmd) #cmd,
 283 #include "ConsoleCmds.h"
 284 #undef  DECLARE_COMMAND
 285 };
 286
 287 typedef void (*console_handler)(const char *args);
 288
 289 #define DECLARE_COMMAND(cmd) static void ch_##cmd(const char *args);
 290 #include "ConsoleCmds.h"
 291 #undef  DECLARE_COMMAND
 292
 293 static console_handler cmd_handlers[] = {
 294 #define DECLARE_COMMAND(cmd) ch_##cmd,
 295 #include "ConsoleCmds.h"
 296 #undef  DECLARE_COMMAND
 297 };
 298
 299
 300
 301 // utility functions
 302
 303 // TODO: this is slightly incorrect
 304 inline float roughDirection(XYZ vec)
 305 {
 306     Normalise(&vec);
 307     float angle = -asin(-vec.x) * 180 / M_PI;
 308     if (vec.z < 0)
 309         angle = 180 - angle;
 310     return angle;
 311 }
 312 inline float roughDirectionTo(XYZ start, XYZ end)
 313 {
 314     return roughDirection(end - start);
 315 }
 316 inline float pitchOf(XYZ vec)
 317 {
 318     Normalise(&vec);
 319     return -asin(vec.y) * 180 / M_PI;
 320 }
 321 inline float pitchTo(XYZ start, XYZ end)
 322 {
 323     return pitchOf(end - start);
 324 }
 325 inline float sq(float n)
 326 {
 327     return n * n;
 328 }
 329 inline float stepTowardf(float from, float to, float by)
 330 {
 331     if (fabs(from - to) < by)
 332         return to;
 333     else if (from > to)
 334         return from - by;
 335     else
 336         return from + by;
 337 }
 338
 339 void playdialogueboxsound()
 340 {
 341     XYZ temppos;
 342     temppos = Person::players[participantfocus[whichdialogue][indialogue]]->coords;
 343     temppos = temppos - viewer;
 344     Normalise(&temppos);
 345     temppos += viewer;
 346
 347     int sound = -1;
 348     switch (dialogueboxsound[whichdialogue][indialogue]) {
 349     case -6:
 350         sound = alarmsound;
 351         break;
 352     case -4:
 353         sound = consolefailsound;
 354         break;
 355     case -3:
 356         sound = consolesuccesssound;
 357         break;
 358     case -2:
 359         sound = firestartsound;
 360         break;
 361     case -1:
 362         sound = fireendsound;
 363         break;
 364     case 1:
 365         sound = rabbitchitter;
 366         break;
 367     case 2:
 368         sound = rabbitchitter2;
 369         break;
 370     case 3:
 371         sound = rabbitpainsound;
 372         break;
 373     case 4:
 374         sound = rabbitpain1sound;
 375         break;
 376     case 5:
 377         sound = rabbitattacksound;
 378         break;
 379     case 6:
 380         sound = rabbitattack2sound;
 381         break;
 382     case 7:
 383         sound = rabbitattack3sound;
 384         break;
 385     case 8:
 386         sound = rabbitattack4sound;
 387         break;
 388     case 9:
 389         sound = growlsound;
 390         break;
 391     case 10:
 392         sound = growl2sound;
 393         break;
 394     case 11:
 395         sound = snarlsound;
 396         break;
 397     case 12:
 398         sound = snarl2sound;
 399         break;
 400     case 13:
 401         sound = barksound;
 402         break;
 403     case 14:
 404         sound = bark2sound;
 405         break;
 406     case 15:
 407         sound = bark3sound;
 408         break;
 409     case 16:
 410         sound = barkgrowlsound;
 411         break;
 412     default:
 413         break;
 414     }
 415     if (sound != -1)
 416         emit_sound_at(sound, temppos);
 417 }
 418
 419 // ================================================================
 420
 421 bool AddClothes(const char *fileName, GLubyte *array)
 422 {
 423     LOGFUNC;
 424     //Load Image
 425     unsigned char fileNamep[256];
 426     CopyCStringToPascal(fileName, fileNamep);
 427     bool opened;
 428     opened = upload_image( fileNamep , 1);
 429
 430     float alphanum;
 431     //Is it valid?
 432     if (opened) {
 433         if (tintr > 1) tintr = 1;
 434         if (tintg > 1) tintg = 1;
 435         if (tintb > 1) tintb = 1;
 436
 437         if (tintr < 0) tintr = 0;
 438         if (tintg < 0) tintg = 0;
 439         if (tintb < 0) tintb = 0;
 440
 441         int bytesPerPixel = texture.bpp / 8;
 442
 443         int tempnum = 0;
 444         alphanum = 255;
 445         for (int i = 0; i < (int)(texture.sizeY * texture.sizeX * bytesPerPixel); i++) {
 446             if (bytesPerPixel == 3)
 447                 alphanum = 255;
 448             else if ((i + 1) % 4 == 0)
 449                 alphanum = texture.data[i];
 450             //alphanum/=2;
 451             if ((i + 1) % 4 || bytesPerPixel == 3) {
 452                 if ((i % 4) == 0)
 453                     texture.data[i] *= tintr;
 454                 if ((i % 4) == 1)
 455                     texture.data[i] *= tintg;
 456                 if ((i % 4) == 2)
 457                     texture.data[i] *= tintb;
 458                 array[tempnum] = (float)array[tempnum] * (1 - alphanum / 255) + (float)texture.data[i] * (alphanum / 255);
 459                 tempnum++;
 460             }
 461         }
 462     } else
 463         return 0;
 464     return 1;
 465 }
 466
 467
 468
 469 static void ch_quit(const char *args)
 470 {
 471     tryquit = 1;
 472 }
 473
 474 static void ch_map(const char *args)
 475 {
 476     Loadlevel(args);
 477     whichlevel = -2;
 478     campaign = 0;
 479 }
 480
 481 static void ch_save(const char *args)
 482 {
 483     char buf[64];
 484     snprintf(buf, 63, ":Data:Maps:%s", args);
 485
 486     int mapvers = 12;
 487
 488     FILE *tfile;
 489     tfile = fopen( ConvertFileName(buf), "wb" );
 490     fpackf(tfile, "Bi", mapvers);
 491     fpackf(tfile, "Bi", maptype);
 492     fpackf(tfile, "Bi", hostile);
 493     fpackf(tfile, "Bf Bf", viewdistance, fadestart);
 494     fpackf(tfile, "Bb Bf Bf Bf", skyboxtexture, skyboxr, skyboxg, skyboxb);
 495     fpackf(tfile, "Bf Bf Bf", skyboxlightr, skyboxlightg, skyboxlightb);
 496     fpackf(tfile, "Bf Bf Bf Bf Bf Bi", Person::players[0]->coords.x, Person::players[0]->coords.y, Person::players[0]->coords.z,
 497            Person::players[0]->yaw, Person::players[0]->targetyaw, Person::players[0]->num_weapons);
 498     if (Person::players[0]->num_weapons > 0 && Person::players[0]->num_weapons < 5)
 499         for (int j = 0; j < Person::players[0]->num_weapons; j++)
 500             fpackf(tfile, "Bi", weapons[Person::players[0]->weaponids[j]].getType());
 501
 502     fpackf(tfile, "Bf Bf Bf", Person::players[0]->armorhead, Person::players[0]->armorhigh, Person::players[0]->armorlow);
 503     fpackf(tfile, "Bf Bf Bf", Person::players[0]->protectionhead, Person::players[0]->protectionhigh, Person::players[0]->protectionlow);
 504     fpackf(tfile, "Bf Bf Bf", Person::players[0]->metalhead, Person::players[0]->metalhigh, Person::players[0]->metallow);
 505     fpackf(tfile, "Bf Bf", Person::players[0]->power, Person::players[0]->speedmult);
 506
 507     fpackf(tfile, "Bi", Person::players[0]->numclothes);
 508
 509     fpackf(tfile, "Bi Bi", Person::players[0]->whichskin, Person::players[0]->creature);
 510
 511     fpackf(tfile, "Bi", numdialogues);
 512
 513     for (int k = 0; k < numdialogues; k++) {
 514         fpackf(tfile, "Bi", numdialogueboxes[k]);
 515         fpackf(tfile, "Bi", dialoguetype[k]);
 516         for (int l = 0; l < 10; l++) {
 517             fpackf(tfile, "Bf Bf Bf", participantlocation[k][l].x, participantlocation[k][l].y, participantlocation[k][l].z);
 518             fpackf(tfile, "Bf", participantyaw[k][l]);
 519         }
 520         for (int l = 0; l < numdialogueboxes[k]; l++) {
 521             fpackf(tfile, "Bi", dialogueboxlocation[k][l]);
 522             fpackf(tfile, "Bf", dialogueboxcolor[k][l][0]);
 523             fpackf(tfile, "Bf", dialogueboxcolor[k][l][1]);
 524             fpackf(tfile, "Bf", dialogueboxcolor[k][l][2]);
 525             fpackf(tfile, "Bi", dialogueboxsound[k][l]);
 526
 527             int templength = strlen(dialoguetext[k][l]);
 528             fpackf(tfile, "Bi", (templength));
 529             for (int m = 0; m < templength; m++) {
 530                 fpackf(tfile, "Bb", dialoguetext[k][l][m]);
 531                 if (dialoguetext[k][l][m] == '\0')
 532                     break;
 533             }
 534
 535             templength = strlen(dialoguename[k][l]);
 536             fpackf(tfile, "Bi", templength);
 537             for (int m = 0; m < templength; m++) {
 538                 fpackf(tfile, "Bb", dialoguename[k][l][m]);
 539                 if (dialoguename[k][l][m] == '\0')
 540                     break;
 541             }
 542
 543             fpackf(tfile, "Bf Bf Bf", dialoguecamera[k][l].x, dialoguecamera[k][l].y, dialoguecamera[k][l].z);
 544             fpackf(tfile, "Bi", participantfocus[k][l]);
 545             fpackf(tfile, "Bi", participantaction[k][l]);
 546
 547             for (int m = 0; m < 10; m++)
 548                 fpackf(tfile, "Bf Bf Bf", participantfacing[k][l][m].x, participantfacing[k][l][m].y, participantfacing[k][l][m].z);
 549
 550             fpackf(tfile, "Bf Bf", dialoguecamerayaw[k][l], dialoguecamerapitch[k][l]);
 551         }
 552     }
 553
 554     for (int k = 0; k < Person::players[0]->numclothes; k++) {
 555         int templength = strlen(Person::players[0]->clothes[k]);
 556         fpackf(tfile, "Bi", templength);
 557         for (int l = 0; l < templength; l++)
 558             fpackf(tfile, "Bb", Person::players[0]->clothes[k][l]);
 559         fpackf(tfile, "Bf Bf Bf", Person::players[0]->clothestintr[k], Person::players[0]->clothestintg[k], Person::players[0]->clothestintb[k]);
 560     }
 561
 562     fpackf(tfile, "Bi", environment);
 563
 564     fpackf(tfile, "Bi", objects.numobjects);
 565
 566     for (int k = 0; k < objects.numobjects; k++)
 567         fpackf(tfile, "Bi Bf Bf Bf Bf Bf Bf", objects.type[k], objects.yaw[k], objects.pitch[k],
 568                objects.position[k].x, objects.position[k].y, objects.position[k].z, objects.scale[k]);
 569
 570     fpackf(tfile, "Bi", numhotspots);
 571     for (int i = 0; i < numhotspots; i++) {
 572         fpackf(tfile, "Bi Bf Bf Bf Bf", hotspottype[i], hotspotsize[i], hotspot[i].x, hotspot[i].y, hotspot[i].z);
 573         int templength = strlen(hotspottext[i]);
 574         fpackf(tfile, "Bi", templength);
 575         for (int l = 0; l < templength; l++)
 576             fpackf(tfile, "Bb", hotspottext[i][l]);
 577     }
 578
 579     fpackf(tfile, "Bi", Person::players.size());
 580     if (Person::players.size() > maxplayers) {
 581         cout << "Warning: this level contains more players than allowed" << endl;
 582     }
 583     for (unsigned j = 1; j < Person::players.size(); j++) {
 584         fpackf(tfile, "Bi Bi Bf Bf Bf Bi Bi Bf Bb Bf", Person::players[j]->whichskin, Person::players[j]->creature,
 585                Person::players[j]->coords.x, Person::players[j]->coords.y, Person::players[j]->coords.z,
 586                Person::players[j]->num_weapons, Person::players[j]->howactive, Person::players[j]->scale, Person::players[j]->immobile, Person::players[j]->yaw);
 587         if (Person::players[j]->num_weapons < 5)
 588             for (int k = 0; k < Person::players[j]->num_weapons; k++)
 589                 fpackf(tfile, "Bi", weapons[Person::players[j]->weaponids[k]].getType());
 590         if (Person::players[j]->numwaypoints < 30) {
 591             fpackf(tfile, "Bi", Person::players[j]->numwaypoints);
 592             for (int k = 0; k < Person::players[j]->numwaypoints; k++) {
 593                 fpackf(tfile, "Bf", Person::players[j]->waypoints[k].x);
 594                 fpackf(tfile, "Bf", Person::players[j]->waypoints[k].y);
 595                 fpackf(tfile, "Bf", Person::players[j]->waypoints[k].z);
 596                 fpackf(tfile, "Bi", Person::players[j]->waypointtype[k]);
 597             }
 598             fpackf(tfile, "Bi", Person::players[j]->waypoint);
 599         } else {
 600             Person::players[j]->numwaypoints = 0;
 601             Person::players[j]->waypoint = 0;
 602             fpackf(tfile, "Bi Bi Bi", Person::players[j]->numwaypoints, Person::players[j]->waypoint, Person::players[j]->waypoint);
 603         }
 604
 605         fpackf(tfile, "Bf Bf Bf", Person::players[j]->armorhead, Person::players[j]->armorhigh, Person::players[j]->armorlow);
 606         fpackf(tfile, "Bf Bf Bf", Person::players[j]->protectionhead, Person::players[j]->protectionhigh, Person::players[j]->protectionlow);
 607         fpackf(tfile, "Bf Bf Bf", Person::players[j]->metalhead, Person::players[j]->metalhigh, Person::players[j]->metallow);
 608         fpackf(tfile, "Bf Bf", Person::players[j]->power, Person::players[j]->speedmult);
 609
 610         float headprop, bodyprop, armprop, legprop;
 611         if (Person::players[j]->creature == wolftype) {
 612             headprop = Person::players[j]->proportionhead.x / 1.1;
 613             bodyprop = Person::players[j]->proportionbody.x / 1.1;
 614             armprop = Person::players[j]->proportionarms.x / 1.1;
 615             legprop = Person::players[j]->proportionlegs.x / 1.1;
 616         } else if (Person::players[j]->creature == rabbittype) {
 617             headprop = Person::players[j]->proportionhead.x / 1.2;
 618             bodyprop = Person::players[j]->proportionbody.x / 1.05;
 619             armprop = Person::players[j]->proportionarms.x / 1.00;
 620             legprop = Person::players[j]->proportionlegs.x / 1.1;
 621         }
 622
 623         fpackf(tfile, "Bf Bf Bf Bf", headprop, bodyprop, armprop, legprop);
 624
 625         fpackf(tfile, "Bi", Person::players[j]->numclothes);
 626         if (Person::players[j]->numclothes)
 627             for (int k = 0; k < Person::players[j]->numclothes; k++) {
 628                 int templength;
 629                 templength = strlen(Person::players[j]->clothes[k]);
 630                 fpackf(tfile, "Bi", templength);
 631                 for (int l = 0; l < templength; l++)
 632                     fpackf(tfile, "Bb", Person::players[j]->clothes[k][l]);
 633                 fpackf(tfile, "Bf Bf Bf", Person::players[j]->clothestintr[k], Person::players[j]->clothestintg[k], Person::players[j]->clothestintb[k]);
 634             }
 635     }
 636
 637     fpackf(tfile, "Bi", numpathpoints);
 638     for (int j = 0; j < numpathpoints; j++) {
 639         fpackf(tfile, "Bf Bf Bf Bi", pathpoint[j].x, pathpoint[j].y, pathpoint[j].z, numpathpointconnect[j]);
 640         for (int k = 0; k < numpathpointconnect[j]; k++)
 641             fpackf(tfile, "Bi", pathpointconnect[j][k]);
 642     }
 643
 644     fpackf(tfile, "Bf Bf Bf Bf", mapcenter.x, mapcenter.y, mapcenter.z, mapradius);
 645
 646     fclose(tfile);
 647 }
 648
 649 static void ch_cellar(const char *args)
 650 {
 651     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:Furdarko.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 652 }
 653
 654 static void ch_tint(const char *args)
 655 {
 656     sscanf(args, "%f%f%f", &tintr, &tintg, &tintb);
 657 }
 658
 659 static void ch_tintr(const char *args)
 660 {
 661     tintr = atof(args);
 662 }
 663
 664 static void ch_tintg(const char *args)
 665 {
 666     tintg = atof(args);
 667 }
 668
 669 static void ch_tintb(const char *args)
 670 {
 671     tintb = atof(args);
 672 }
 673
 674 static void ch_speed(const char *args)
 675 {
 676     Person::players[0]->speedmult = atof(args);
 677 }
 678
 679 static void ch_strength(const char *args)
 680 {
 681     Person::players[0]->power = atof(args);
 682 }
 683
 684 static void ch_power(const char *args)
 685 {
 686     Person::players[0]->power = atof(args);
 687 }
 688
 689 static void ch_size(const char *args)
 690 {
 691     Person::players[0]->scale = atof(args) * .2;
 692 }
 693
 694 static int findClosestPlayer()
 695 {
 696     int closest = -1;
 697     float closestdist = std::numeric_limits<float>::max();
 698
 699     for (unsigned i = 1; i < Person::players.size(); i++) {
 700         float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
 701         if (distance < closestdist) {
 702             closestdist = distance;
 703             closest = i;
 704         }
 705     }
 706     return closest;
 707 }
 708
 709 static int findClosestObject()
 710 {
 711     int closest = -1;
 712     float closestdist = std::numeric_limits<float>::max();
 713
 714     for (int i = 0; i < objects.numobjects; i++) {
 715         float distance = distsq(&objects.position[i], &Person::players[0]->coords);
 716         if (distance < closestdist) {
 717             closestdist = distance;
 718             closest = i;
 719         }
 720     }
 721     return closest;
 722 }
 723
 724 static void ch_sizenear(const char *args)
 725 {
 726     int closest = findClosestPlayer();
 727     if (closest >= 0)
 728         Person::players[closest]->scale = atof(args) * .2;
 729 }
 730
 731 static void set_proportion(int pnum, const char *args)
 732 {
 733     float headprop, bodyprop, armprop, legprop;
 734
 735     sscanf(args, "%f%f%f%f", &headprop, &bodyprop, &armprop, &legprop);
 736
 737     if (Person::players[pnum]->creature == wolftype) {
 738         Person::players[pnum]->proportionhead = 1.1 * headprop;
 739         Person::players[pnum]->proportionbody = 1.1 * bodyprop;
 740         Person::players[pnum]->proportionarms = 1.1 * armprop;
 741         Person::players[pnum]->proportionlegs = 1.1 * legprop;
 742     } else if (Person::players[pnum]->creature == rabbittype) {
 743         Person::players[pnum]->proportionhead = 1.2 * headprop;
 744         Person::players[pnum]->proportionbody = 1.05 * bodyprop;
 745         Person::players[pnum]->proportionarms = 1.00 * armprop;
 746         Person::players[pnum]->proportionlegs = 1.1 * legprop;
 747         Person::players[pnum]->proportionlegs.y = 1.05 * legprop;
 748     }
 749 }
 750
 751 static void ch_proportion(const char *args)
 752 {
 753     set_proportion(0, args);
 754 }
 755
 756 static void ch_proportionnear(const char *args)
 757 {
 758     int closest = findClosestPlayer();
 759     if (closest >= 0)
 760         set_proportion(closest, args);
 761 }
 762
 763 static void set_protection(int pnum, const char *args)
 764 {
 765     float head, high, low;
 766     sscanf(args, "%f%f%f", &head, &high, &low);
 767
 768     Person::players[pnum]->protectionhead = head;
 769     Person::players[pnum]->protectionhigh = high;
 770     Person::players[pnum]->protectionlow  = low;
 771 }
 772
 773 static void ch_protection(const char *args)
 774 {
 775     set_protection(0, args);
 776 }
 777
 778 static void ch_protectionnear(const char *args)
 779 {
 780     int closest = findClosestPlayer();
 781     if (closest >= 0)
 782         set_protection(closest, args);
 783 }
 784
 785 static void set_armor(int pnum, const char *args)
 786 {
 787     float head, high, low;
 788     sscanf(args, "%f%f%f", &head, &high, &low);
 789
 790     Person::players[pnum]->armorhead = head;
 791     Person::players[pnum]->armorhigh = high;
 792     Person::players[pnum]->armorlow  = low;
 793 }
 794
 795 static void ch_armor(const char *args)
 796 {
 797     set_armor(0, args);
 798 }
 799
 800 static void ch_armornear(const char *args)
 801 {
 802     int closest = findClosestPlayer();
 803     if (closest >= 0)
 804         set_armor(closest, args);
 805 }
 806
 807 static void ch_protectionreset(const char *args)
 808 {
 809     set_protection(0, "1 1 1");
 810     set_armor(0, "1 1 1");
 811 }
 812
 813 static void set_metal(int pnum, const char *args)
 814 {
 815     float head, high, low;
 816     sscanf(args, "%f%f%f", &head, &high, &low);
 817
 818     Person::players[pnum]->metalhead = head;
 819     Person::players[pnum]->metalhigh = high;
 820     Person::players[pnum]->metallow  = low;
 821 }
 822
 823 static void ch_metal(const char *args)
 824 {
 825     set_metal(0, args);
 826 }
 827
 828 static void set_noclothes(int pnum, const char *args)
 829 {
 830     Person::players[pnum]->numclothes = 0;
 831     Person::players[pnum]->skeleton.drawmodel.textureptr.load(
 832         creatureskin[Person::players[pnum]->creature][Person::players[pnum]->whichskin], 1,
 833         &Person::players[pnum]->skeleton.skinText[0], &Person::players[pnum]->skeleton.skinsize);
 834 }
 835
 836 static void ch_noclothes(const char *args)
 837 {
 838     set_noclothes(0, args);
 839 }
 840
 841 static void ch_noclothesnear(const char *args)
 842 {
 843     int closest = findClosestPlayer();
 844     if (closest >= 0)
 845         set_noclothes(closest, args);
 846 }
 847
 848
 849 static void set_clothes(int pnum, const char *args)
 850 {
 851     char buf[64];
 852     snprintf(buf, 63, ":Data:Textures:%s.png", args);
 853
 854     if (!AddClothes(buf, &Person::players[pnum]->skeleton.skinText[pnum]))
 855         return;
 856
 857     Person::players[pnum]->DoMipmaps();
 858     strcpy(Person::players[pnum]->clothes[Person::players[pnum]->numclothes], buf);
 859     Person::players[pnum]->clothestintr[Person::players[pnum]->numclothes] = tintr;
 860     Person::players[pnum]->clothestintg[Person::players[pnum]->numclothes] = tintg;
 861     Person::players[pnum]->clothestintb[Person::players[pnum]->numclothes] = tintb;
 862     Person::players[pnum]->numclothes++;
 863 }
 864
 865 static void ch_clothes(const char *args)
 866 {
 867     set_clothes(0, args);
 868 }
 869
 870 static void ch_clothesnear(const char *args)
 871 {
 872     int closest = findClosestPlayer();
 873     if (closest >= 0)
 874         set_clothes(closest, args);
 875 }
 876
 877 static void ch_belt(const char *args)
 878 {
 879     Person::players[0]->skeleton.clothes = !Person::players[0]->skeleton.clothes;
 880 }
 881
 882
 883 static void ch_cellophane(const char *args)
 884 {
 885     cellophane = !cellophane;
 886     float mul = (cellophane ? 0 : 1);
 887
 888     for (auto player : Person::players) {
 889         player->proportionhead.z = player->proportionhead.x * mul;
 890         player->proportionbody.z = player->proportionbody.x * mul;
 891         player->proportionarms.z = player->proportionarms.x * mul;
 892         player->proportionlegs.z = player->proportionlegs.x * mul;
 893     }
 894 }
 895
 896 static void ch_funnybunny(const char *args)
 897 {
 898     Person::players[0]->skeleton.id = 0;
 899     Person::players[0]->skeleton.Load(":Data:Skeleton:Basic Figure", ":Data:Skeleton:Basic Figurelow",
 900                             ":Data:Skeleton:Rabbitbelt", ":Data:Models:Body.solid",
 901                             ":Data:Models:Body2.solid", ":Data:Models:Body3.solid",
 902                             ":Data:Models:Body4.solid", ":Data:Models:Body5.solid",
 903                             ":Data:Models:Body6.solid", ":Data:Models:Body7.solid",
 904                             ":Data:Models:Bodylow.solid", ":Data:Models:Belt.solid", 1);
 905     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:fur3.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 906     Person::players[0]->creature = rabbittype;
 907     Person::players[0]->scale = .2;
 908     Person::players[0]->headless = 0;
 909     Person::players[0]->damagetolerance = 200;
 910     set_proportion(0, "1 1 1 1");
 911 }
 912
 913 static void ch_wolfie(const char *args)
 914 {
 915     Person::players[0]->skeleton.id = 0;
 916     Person::players[0]->skeleton.Load(":Data:Skeleton:Basic Figure Wolf", ":Data:Skeleton:Basic Figure Wolf Low",
 917                             ":Data:Skeleton:Rabbitbelt", ":Data:Models:Wolf.solid",
 918                             ":Data:Models:Wolf2.solid", ":Data:Models:Wolf3.solid",
 919                             ":Data:Models:Wolf4.solid", ":Data:Models:Wolf5.solid",
 920                             ":Data:Models:Wolf6.solid", ":Data:Models:Wolf7.solid",
 921                             ":Data:Models:Wolflow.solid", ":Data:Models:Belt.solid", 0);
 922     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:Wolf.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 923     Person::players[0]->creature = wolftype;
 924     Person::players[0]->damagetolerance = 300;
 925     set_proportion(0, "1 1 1 1");
 926 }
 927
 928 static void ch_wolfieisgod(const char *args)
 929 {
 930     ch_wolfie(args);
 931 }
 932
 933 static void ch_wolf(const char *args)
 934 {
 935     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:Wolf.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 936 }
 937
 938 static void ch_snowwolf(const char *args)
 939 {
 940     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:SnowWolf.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 941 }
 942
 943 static void ch_darkwolf(const char *args)
 944 {
 945     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:DarkWolf.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 946 }
 947
 948 static void ch_lizardwolf(const char *args)
 949 {
 950     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:Lizardwolf.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 951 }
 952
 953 static void ch_white(const char *args)
 954 {
 955     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:fur.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 956 }
 957
 958 static void ch_brown(const char *args)
 959 {
 960     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:fur3.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 961 }
 962
 963 static void ch_black(const char *args)
 964 {
 965     Person::players[0]->skeleton.drawmodel.textureptr.load(":Data:Textures:fur2.jpg", 1, &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
 966 }
 967
 968 static void ch_sizemin(const char *args)
 969 {
 970     for (unsigned i = 1; i < Person::players.size(); i++)
 971         if (Person::players[i]->scale < 0.8 * 0.2)
 972             Person::players[i]->scale = 0.8 * 0.2;
 973 }
 974
 975 static void ch_tutorial(const char *args)
 976 {
 977     tutoriallevel = atoi(args);
 978 }
 979
 980 static void ch_hostile(const char *args)
 981 {
 982     hostile = atoi(args);
 983 }
 984
 985 static void ch_indemo(const char *args)
 986 {
 987     indemo = 1;
 988     hotspot[numhotspots] = Person::players[0]->coords;
 989     hotspotsize[numhotspots] = 0;
 990     hotspottype[numhotspots] = -111;
 991     strcpy(hotspottext[numhotspots], "mapname");
 992     numhotspots++;
 993 }
 994
 995 static void ch_notindemo(const char *args)
 996 {
 997     indemo = 0;
 998     numhotspots--;
 999 }
1000
1001 static void ch_type(const char *args)
1002 {
1003     int n = sizeof(editortypenames) / sizeof(editortypenames[0]);
1004     for (int i = 0; i < n; i++)
1005         if (stripfx(args, editortypenames[i])) {
1006             editoractive = i;
1007             break;
1008         }
1009 }
1010
1011 static void ch_path(const char *args)
1012 {
1013     int n = sizeof(pathtypenames) / sizeof(pathtypenames[0]);
1014     for (int i = 0; i < n; i++)
1015         if (stripfx(args, pathtypenames[i])) {
1016             editorpathtype = i;
1017             break;
1018         }
1019 }
1020
1021 static void ch_hs(const char *args)
1022 {
1023     hotspot[numhotspots] = Person::players[0]->coords;
1024
1025     float size;
1026     int type, shift;
1027     sscanf(args, "%f%d %n", &size, &type, &shift);
1028
1029     hotspotsize[numhotspots] = size;
1030     hotspottype[numhotspots] = type;
1031
1032     strcpy(hotspottext[numhotspots], args + shift);
1033     strcat(hotspottext[numhotspots], "\n");
1034
1035     numhotspots++;
1036 }
1037
1038 static void ch_dialogue(const char *args)
1039 {
1040     int dlg;
1041     char buf1[32], buf2[64];
1042
1043     sscanf(args, "%d %31s", &dlg, buf1);
1044     snprintf(buf2, 63, ":Data:Dialogues:%s.txt", buf1);
1045
1046     dialoguetype[numdialogues] = dlg;
1047
1048     memset(dialoguetext[numdialogues], 0, sizeof(dialoguetext[numdialogues]));
1049     memset(dialoguename[numdialogues], 0, sizeof(dialoguename[numdialogues]));
1050
1051     ifstream ipstream(ConvertFileName(buf2));
1052     ipstream.ignore(256, ':');
1053     ipstream >> numdialogueboxes[numdialogues];
1054     for (int i = 0; i < numdialogueboxes[numdialogues]; i++) {
1055         ipstream.ignore(256, ':');
1056         ipstream.ignore(256, ':');
1057         ipstream.ignore(256, ' ');
1058         ipstream >> dialogueboxlocation[numdialogues][i];
1059         ipstream.ignore(256, ':');
1060         ipstream >> dialogueboxcolor[numdialogues][i][0];
1061         ipstream >> dialogueboxcolor[numdialogues][i][1];
1062         ipstream >> dialogueboxcolor[numdialogues][i][2];
1063         ipstream.ignore(256, ':');
1064         ipstream.getline(dialoguename[numdialogues][i], 64);
1065         ipstream.ignore(256, ':');
1066         ipstream.ignore(256, ' ');
1067         ipstream.getline(dialoguetext[numdialogues][i], 128);
1068         for (int j = 0; j < 128; j++) {
1069             if (dialoguetext[numdialogues][i][j] == '\\')
1070                 dialoguetext[numdialogues][i][j] = '\n';
1071         }
1072         ipstream.ignore(256, ':');
1073         ipstream >> dialogueboxsound[numdialogues][i];
1074     }
1075
1076     for (int i = 0; i < numdialogueboxes[numdialogues]; i++) {
1077         for (unsigned j = 0; j < Person::players.size(); j++) {
1078             participantfacing[numdialogues][i][j] = Person::players[j]->facing;
1079         }
1080     }
1081     ipstream.close();
1082
1083     directing = 1;
1084     indialogue = 0;
1085     whichdialogue = numdialogues;
1086
1087     numdialogues++;
1088 }
1089
1090 static void ch_fixdialogue(const char *args)
1091 {
1092     char buf1[32], buf2[64];
1093     int whichdi;
1094
1095     sscanf(args, "%d %31s", &whichdi, buf1);
1096     snprintf(buf2, 63, ":Data:Dialogues:%s.txt", buf1);
1097
1098     memset(dialoguetext[whichdi], 0, sizeof(dialoguetext[whichdi]));
1099     memset(dialoguename[whichdi], 0, sizeof(dialoguename[whichdi]));
1100
1101     ifstream ipstream(ConvertFileName(buf2));
1102     ipstream.ignore(256, ':');
1103     ipstream >> numdialogueboxes[whichdi];
1104     for (int i = 0; i < numdialogueboxes[whichdi]; i++) {
1105         ipstream.ignore(256, ':');
1106         ipstream.ignore(256, ':');
1107         ipstream.ignore(256, ' ');
1108         ipstream >> dialogueboxlocation[whichdi][i];
1109         ipstream.ignore(256, ':');
1110         ipstream >> dialogueboxcolor[whichdi][i][0];
1111         ipstream >> dialogueboxcolor[whichdi][i][1];
1112         ipstream >> dialogueboxcolor[whichdi][i][2];
1113         ipstream.ignore(256, ':');
1114         ipstream.getline(dialoguename[whichdi][i], 64);
1115         ipstream.ignore(256, ':');
1116         ipstream.ignore(256, ' ');
1117         ipstream.getline(dialoguetext[whichdi][i], 128);
1118         for (int j = 0; j < 128; j++) {
1119             if (dialoguetext[whichdi][i][j] == '\\')
1120                 dialoguetext[whichdi][i][j] = '\n';
1121         }
1122         ipstream.ignore(256, ':');
1123         ipstream >> dialogueboxsound[whichdi][i];
1124     }
1125
1126     ipstream.close();
1127 }
1128
1129 static void ch_fixtype(const char *args)
1130 {
1131     int dlg;
1132     sscanf(args, "%d", &dlg);
1133     dialoguetype[0] = dlg;
1134 }
1135
1136 static void ch_fixrotation(const char *args)
1137 {
1138     participantyaw[whichdialogue][participantfocus[whichdialogue][indialogue]] = Person::players[participantfocus[whichdialogue][indialogue]]->yaw;
1139 }
1140
1141 static void ch_ddialogue(const char *args)
1142 {
1143     if (numdialogues)
1144         numdialogues--;
1145 }
1146
1147 static void ch_dhs(const char *args)
1148 {
1149     if (numhotspots)
1150         numhotspots--;
1151 }
1152
1153 static void ch_immobile(const char *args)
1154 {
1155     Person::players[0]->immobile = 1;
1156 }
1157
1158 static void ch_allimmobile(const char *args)
1159 {
1160     for (unsigned i = 1; i < Person::players.size(); i++)
1161         Person::players[i]->immobile = 1;
1162 }
1163
1164 static void ch_mobile(const char *args)
1165 {
1166     Person::players[0]->immobile = 0;
1167 }
1168
1169 static void ch_default(const char *args)
1170 {
1171     Person::players[0]->armorhead = 1;
1172     Person::players[0]->armorhigh = 1;
1173     Person::players[0]->armorlow = 1;
1174     Person::players[0]->protectionhead = 1;
1175     Person::players[0]->protectionhigh = 1;
1176     Person::players[0]->protectionlow = 1;
1177     Person::players[0]->metalhead = 1;
1178     Person::players[0]->metalhigh = 1;
1179     Person::players[0]->metallow = 1;
1180     Person::players[0]->power = 1;
1181     Person::players[0]->speedmult = 1;
1182     Person::players[0]->scale = 1;
1183
1184     if (Person::players[0]->creature == wolftype) {
1185         Person::players[0]->proportionhead = 1.1;
1186         Person::players[0]->proportionbody = 1.1;
1187         Person::players[0]->proportionarms = 1.1;
1188         Person::players[0]->proportionlegs = 1.1;
1189     } else if (Person::players[0]->creature == rabbittype) {
1190         Person::players[0]->proportionhead = 1.2;
1191         Person::players[0]->proportionbody = 1.05;
1192         Person::players[0]->proportionarms = 1.00;
1193         Person::players[0]->proportionlegs = 1.1;
1194         Person::players[0]->proportionlegs.y = 1.05;
1195     }
1196
1197     Person::players[0]->numclothes = 0;
1198     Person::players[0]->skeleton.drawmodel.textureptr.load(
1199         creatureskin[Person::players[0]->creature][Person::players[0]->whichskin], 1,
1200         &Person::players[0]->skeleton.skinText[0], &Person::players[0]->skeleton.skinsize);
1201
1202     editoractive = typeactive;
1203     Person::players[0]->immobile = 0;
1204 }
1205
1206 static void ch_play(const char *args)
1207 {
1208     int dlg;
1209     sscanf(args, "%d", &dlg);
1210     whichdialogue = dlg;
1211
1212     if (whichdialogue >= numdialogues)
1213         return;
1214
1215     for (int i = 0; i < numdialogueboxes[whichdialogue]; i++) {
1216         Person::players[participantfocus[whichdialogue][i]]->coords = participantlocation[whichdialogue][participantfocus[whichdialogue][i]];
1217         Person::players[participantfocus[whichdialogue][i]]->yaw = participantyaw[whichdialogue][participantfocus[whichdialogue][i]];
1218         Person::players[participantfocus[whichdialogue][i]]->targetyaw = participantyaw[whichdialogue][participantfocus[whichdialogue][i]];
1219         Person::players[participantfocus[whichdialogue][i]]->velocity = 0;
1220         Person::players[participantfocus[whichdialogue][i]]->animTarget = Person::players[participantfocus[whichdialogue][i]]->getIdle();
1221         Person::players[participantfocus[whichdialogue][i]]->frameTarget = 0;
1222     }
1223
1224     directing = 0;
1225     indialogue = 0;
1226
1227     playdialogueboxsound();
1228 }
1229
1230 static void ch_mapkilleveryone(const char *args)
1231 {
1232     maptype = mapkilleveryone;
1233 }
1234
1235 static void ch_mapkillmost(const char *args)
1236 {
1237     maptype = mapkillmost;
1238 }
1239
1240 static void ch_mapkillsomeone(const char *args)
1241 {
1242     maptype = mapkillsomeone;
1243 }
1244
1245 static void ch_mapgosomewhere(const char *args)
1246 {
1247     maptype = mapgosomewhere;
1248 }
1249
1250 static void ch_viewdistance(const char *args)
1251 {
1252     viewdistance = atof(args) * 100;
1253 }
1254
1255 static void ch_fadestart(const char *args)
1256 {
1257     fadestart = atof(args);
1258 }
1259
1260 static void ch_slomo(const char *args)
1261 {
1262     slomospeed = atof(args);
1263     slomo = !slomo;
1264     slomodelay = 1000;
1265 }
1266
1267 static void ch_slofreq(const char *args)
1268 {
1269     slomofreq = atof(args);
1270 }
1271
1272 static void ch_skytint(const char *args)
1273 {
1274     sscanf(args, "%f%f%f", &skyboxr, &skyboxg, &skyboxb);
1275
1276     skyboxlightr = skyboxr;
1277     skyboxlightg = skyboxg;
1278     skyboxlightb = skyboxb;
1279
1280     SetUpLighting();
1281
1282     terrain.DoShadows();
1283     objects.DoShadows();
1284 }
1285
1286 static void ch_skylight(const char *args)
1287 {
1288     sscanf(args, "%f%f%f", &skyboxlightr, &skyboxlightg, &skyboxlightb);
1289
1290     SetUpLighting();
1291
1292     terrain.DoShadows();
1293     objects.DoShadows();
1294 }
1295
1296 static void ch_skybox(const char *args)
1297 {
1298     skyboxtexture = !skyboxtexture;
1299
1300     SetUpLighting();
1301
1302     terrain.DoShadows();
1303     objects.DoShadows();
1304 }
1305
1306 static void cmd_dispatch(const string cmd)
1307 {
1308     int i, n_cmds = sizeof(cmd_names) / sizeof(cmd_names[0]);
1309
1310     for (i = 0; i < n_cmds; i++)
1311         if (cmd.substr(0, cmd.find(' ')) == string(cmd_names[i])) {
1312             cout << "|" << cmd.substr(cmd.find(' ') + 1) << "|" << endl;
1313             cmd_handlers[i](cmd.substr(cmd.find(' ') + 1).c_str());
1314             break;
1315         }
1316     emit_sound_np(i < n_cmds ? consolesuccesssound : consolefailsound);
1317 }
1318
1319 /********************> Tick() <*****/
1320 extern bool save_image(const char * fname);
1321 void Screenshot (void)
1322 {
1323     char filename[1024];
1324     time_t t = time(NULL);
1325     struct tm *tme = localtime(&t);
1326     sprintf(filename, "Screenshots/Screenshot-%04d%02d%02d-%02d%02d%02d.png",
1327             tme->tm_year + 1900, tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);
1328
1329 #if defined(_WIN32)
1330     mkdir("Screenshots");
1331 #endif
1332
1333     save_image(filename);
1334 }
1335
1336 void Game::SetUpLighting()
1337 {
1338     if (environment == snowyenvironment)
1339         light.setColors(.65, .65, .7, .4, .4, .44);
1340     if (environment == desertenvironment)
1341         light.setColors(.95, .95, .95, .4, .35, .3);
1342     if (environment == grassyenvironment)
1343         light.setColors(.95, .95, 1, .4, .4, .44);
1344     if (!skyboxtexture)
1345         light.setColors(1, 1, 1, .4, .4, .4);
1346     float average;
1347     average = (skyboxlightr + skyboxlightg + skyboxlightb) / 3;
1348     light.color[0] *= (skyboxlightr + average) / 2;
1349     light.color[1] *= (skyboxlightg + average) / 2;
1350     light.color[2] *= (skyboxlightb + average) / 2;
1351     light.ambient[0] *= (skyboxlightr + average) / 2;
1352     light.ambient[1] *= (skyboxlightg + average) / 2;
1353     light.ambient[2] *= (skyboxlightb + average) / 2;
1354 }
1355
1356 int findPathDist(int start, int end)
1357 {
1358     int smallestcount, count, connected;
1359     int last, last2, last3, last4;
1360     int closest;
1361
1362     smallestcount = 1000;
1363     for (int i = 0; i < 50; i++) {
1364         count = 0;
1365         last = start;
1366         last2 = -1;
1367         last3 = -1;
1368         last4 = -1;
1369         while (last != end && count < 30) {
1370             closest = -1;
1371             for (int j = 0; j < numpathpoints; j++) {
1372                 if (j != last && j != last2 && j != last3 && j != last4) {
1373                     connected = 0;
1374                     if (numpathpointconnect[j])
1375                         for (int k = 0; k < numpathpointconnect[j]; k++) {
1376                             if (pathpointconnect[j][k] == last)connected = 1;
1377                         }
1378                     if (!connected)
1379                         if (numpathpointconnect[last])
1380                             for (int k = 0; k < numpathpointconnect[last]; k++) {
1381                                 if (pathpointconnect[last][k] == j)connected = 1;
1382                             }
1383                     if (connected)
1384                         if (closest == -1 || Random() % 2 == 0) {
1385                             closest = j;
1386                         }
1387                 }
1388             }
1389             last4 = last3;
1390             last3 = last2;
1391             last2 = last;
1392             last = closest;
1393             count++;
1394         }
1395         if (count < smallestcount)
1396             smallestcount = count;
1397     }
1398     return smallestcount;
1399 }
1400
1401 int Game::checkcollide(XYZ startpoint, XYZ endpoint)
1402 {
1403     static XYZ colpoint, colviewer, coltarget;
1404     static float minx, minz, maxx, maxz, miny, maxy;
1405
1406     minx = min(startpoint.x, endpoint.x) - 1;
1407     miny = min(startpoint.y, endpoint.y) - 1;
1408     minz = min(startpoint.z, endpoint.z) - 1;
1409     maxx = max(startpoint.x, endpoint.x) + 1;
1410     maxy = max(startpoint.y, endpoint.y) + 1;
1411     maxz = max(startpoint.z, endpoint.z) + 1;
1412
1413     for (int i = 0; i < objects.numobjects; i++) {
1414         if (     objects.position[i].x > minx - objects.model[i].boundingsphereradius &&
1415                  objects.position[i].x < maxx + objects.model[i].boundingsphereradius &&
1416                  objects.position[i].y > miny - objects.model[i].boundingsphereradius &&
1417                  objects.position[i].y < maxy + objects.model[i].boundingsphereradius &&
1418                  objects.position[i].z > minz - objects.model[i].boundingsphereradius &&
1419                  objects.position[i].z < maxz + objects.model[i].boundingsphereradius) {
1420             if (     objects.type[i] != treeleavestype &&
1421                      objects.type[i] != bushtype &&
1422                      objects.type[i] != firetype) {
1423                 colviewer = startpoint;
1424                 coltarget = endpoint;
1425                 if (objects.model[i].LineCheck(&colviewer, &coltarget, &colpoint, &objects.position[i], &objects.yaw[i]) != -1)
1426                     return i;
1427             }
1428         }
1429     }
1430
1431     //if(terrain.lineTerrain(startpoint,endpoint,&colpoint)!=-1)return 1000;
1432
1433     return -1;
1434 }
1435
1436 int Game::checkcollide(XYZ startpoint, XYZ endpoint, int what)
1437 {
1438     static XYZ colpoint, colviewer, coltarget;
1439     static float minx, minz, maxx, maxz, miny, maxy;
1440     static int i; //FIXME: see below
1441
1442     minx = min(startpoint.x, endpoint.x) - 1;
1443     miny = min(startpoint.y, endpoint.y) - 1;
1444     minz = min(startpoint.z, endpoint.z) - 1;
1445     maxx = max(startpoint.x, endpoint.x) + 1;
1446     maxy = max(startpoint.y, endpoint.y) + 1;
1447     maxz = max(startpoint.z, endpoint.z) + 1;
1448
1449     if (what != 1000) {
1450         if (     objects.position[what].x > minx - objects.model[what].boundingsphereradius &&
1451                  objects.position[what].x < maxx + objects.model[what].boundingsphereradius &&
1452                  objects.position[what].y > miny - objects.model[what].boundingsphereradius &&
1453                  objects.position[what].y < maxy + objects.model[what].boundingsphereradius &&
1454                  objects.position[what].z > minz - objects.model[what].boundingsphereradius &&
1455                  objects.position[what].z < maxz + objects.model[what].boundingsphereradius) {
1456             if (     objects.type[what] != treeleavestype &&
1457                      objects.type[what] != bushtype &&
1458                      objects.type[what] != firetype) {
1459                 colviewer = startpoint;
1460                 coltarget = endpoint;
1461                 //FIXME: i/what
1462                 if (objects.model[what].LineCheck(&colviewer, &coltarget, &colpoint, &objects.position[what], &objects.yaw[what]) != -1)
1463                     return i;
1464             }
1465         }
1466     }
1467
1468     if (what == 1000)
1469         if (terrain.lineTerrain(startpoint, endpoint, &colpoint) != -1)
1470             return 1000;
1471
1472     return -1;
1473 }
1474
1475 void Setenvironment(int which)
1476 {
1477     LOGFUNC;
1478
1479     LOG(" Setting environment...");
1480
1481     float temptexdetail;
1482     environment = which;
1483
1484     pause_sound(stream_snowtheme);
1485     pause_sound(stream_grasstheme);
1486     pause_sound(stream_deserttheme);
1487     pause_sound(stream_wind);
1488     pause_sound(stream_desertambient);
1489
1490
1491     if (environment == snowyenvironment) {
1492         windvector = 0;
1493         windvector.z = 3;
1494         if (ambientsound)
1495             emit_stream_np(stream_wind);
1496
1497         objects.treetextureptr.load(":Data:Textures:snowtree.png", 0, 1);
1498         objects.bushtextureptr.load(":Data:Textures:bushsnow.png", 0, 1);
1499         objects.rocktextureptr.load(":Data:Textures:bouldersnow.jpg", 1, 0);
1500         objects.boxtextureptr.load(":Data:Textures:snowbox.jpg", 1, 0);
1501
1502         footstepsound = footstepsn1;
1503         footstepsound2 = footstepsn2;
1504         footstepsound3 = footstepst1;
1505         footstepsound4 = footstepst2;
1506
1507         terraintexture.load(":Data:Textures:snow.jpg", 1, 0);
1508         terraintexture2.load(":Data:Textures:rock.jpg", 1, 0);
1509
1510         //LoadTexture(":Data:Textures:detailgrain.png",&terraintexture3,1);
1511
1512
1513
1514
1515         temptexdetail = texdetail;
1516         if (texdetail > 1)
1517             texdetail = 4;
1518         skybox->load(   ":Data:Textures:Skybox(snow):Front.jpg",
1519                         ":Data:Textures:Skybox(snow):Left.jpg",
1520                         ":Data:Textures:Skybox(snow):Back.jpg",
1521                         ":Data:Textures:Skybox(snow):Right.jpg",
1522                         ":Data:Textures:Skybox(snow):Up.jpg",
1523                         ":Data:Textures:Skybox(snow):Down.jpg");
1524
1525
1526
1527
1528         texdetail = temptexdetail;
1529     } else if (environment == desertenvironment) {
1530         windvector = 0;
1531         windvector.z = 2;
1532         objects.treetextureptr.load(":Data:Textures:deserttree.png", 0, 1);
1533         objects.bushtextureptr.load(":Data:Textures:bushdesert.png", 0, 1);
1534         objects.rocktextureptr.load(":Data:Textures:boulderdesert.jpg", 1, 0);
1535         objects.boxtextureptr.load(":Data:Textures:desertbox.jpg", 1, 0);
1536
1537
1538         if (ambientsound)
1539             emit_stream_np(stream_desertambient);
1540
1541         footstepsound = footstepsn1;
1542         footstepsound2 = footstepsn2;
1543         footstepsound3 = footstepsn1;
1544         footstepsound4 = footstepsn2;
1545
1546         terraintexture.load(":Data:Textures:sand.jpg", 1, 0);
1547         terraintexture2.load(":Data:Textures:sandslope.jpg", 1, 0);
1548
1549         //LoadTexture(":Data:Textures:detailgrain.png",&terraintexture3,1);
1550
1551
1552
1553         temptexdetail = texdetail;
1554         if (texdetail > 1)
1555             texdetail = 4;
1556         skybox->load(   ":Data:Textures:Skybox(sand):Front.jpg",
1557                         ":Data:Textures:Skybox(sand):Left.jpg",
1558                         ":Data:Textures:Skybox(sand):Back.jpg",
1559                         ":Data:Textures:Skybox(sand):Right.jpg",
1560                         ":Data:Textures:Skybox(sand):Up.jpg",
1561                         ":Data:Textures:Skybox(sand):Down.jpg");
1562
1563
1564
1565
1566         texdetail = temptexdetail;
1567     } else if (environment == grassyenvironment) {
1568         windvector = 0;
1569         windvector.z = 2;
1570         objects.treetextureptr.load(":Data:Textures:tree.png", 0, 1);
1571         objects.bushtextureptr.load(":Data:Textures:bush.png", 0, 1);
1572         objects.rocktextureptr.load(":Data:Textures:boulder.jpg", 1, 0);
1573         objects.boxtextureptr.load(":Data:Textures:grassbox.jpg", 1, 0);
1574
1575         if (ambientsound)
1576             emit_stream_np(stream_wind, 100.);
1577
1578         footstepsound = footstepgr1;
1579         footstepsound2 = footstepgr2;
1580         footstepsound3 = footstepst1;
1581         footstepsound4 = footstepst2;
1582
1583         terraintexture.load(":Data:Textures:grassdirt.jpg", 1, 0);
1584         terraintexture2.load(":Data:Textures:mossrock.jpg", 1, 0);
1585
1586         //LoadTexture(":Data:Textures:detail.png",&terraintexture3,1);
1587
1588
1589
1590         temptexdetail = texdetail;
1591         if (texdetail > 1)
1592             texdetail = 4;
1593         skybox->load(   ":Data:Textures:Skybox(grass):Front.jpg",
1594                         ":Data:Textures:Skybox(grass):Left.jpg",
1595                         ":Data:Textures:Skybox(grass):Back.jpg",
1596                         ":Data:Textures:Skybox(grass):Right.jpg",
1597                         ":Data:Textures:Skybox(grass):Up.jpg",
1598                         ":Data:Textures:Skybox(grass):Down.jpg");
1599
1600
1601
1602         texdetail = temptexdetail;
1603     }
1604     temptexdetail = texdetail;
1605     texdetail = 1;
1606     terrain.load(":Data:Textures:heightmap.png");
1607
1608     texdetail = temptexdetail;
1609 }
1610
1611 void LoadCampaign()
1612 {
1613     if (!accountactive)
1614         return;
1615     ifstream ipstream(ConvertFileName((":Data:Campaigns:" + accountactive->getCurrentCampaign() + ".txt").c_str()));
1616     if (!ipstream.good()) {
1617         if (accountactive->getCurrentCampaign() == "main") {
1618             cerr << "Could not found main campaign!" << endl;
1619             return;
1620         }
1621         cerr << "Could not found campaign \"" << accountactive->getCurrentCampaign() << "\", falling back to main." << endl;
1622         accountactive->setCurrentCampaign("main");
1623         return LoadCampaign();
1624     }
1625     ipstream.ignore(256, ':');
1626     int numlevels;
1627     ipstream >> numlevels;
1628     campaignlevels.clear();
1629     for (int i = 0; i < numlevels; i++) {
1630         CampaignLevel cl;
1631         ipstream >> cl;
1632         campaignlevels.push_back(cl);
1633     }
1634     ipstream.close();
1635
1636     ifstream test(ConvertFileName((":Data:Textures:" + accountactive->getCurrentCampaign() + ":World.png").c_str()));
1637     if (test.good()) {
1638         Mainmenuitems[7].load((":Data:Textures:" + accountactive->getCurrentCampaign() + ":World.png").c_str(), 0, 0);
1639     } else {
1640         Mainmenuitems[7].load(":Data:Textures:World.png", 0, 0);
1641     }
1642
1643     if (accountactive->getCampaignChoicesMade() == 0) {
1644         accountactive->setCampaignScore(0);
1645         accountactive->resetFasttime();
1646     }
1647 }
1648
1649 vector<string> ListCampaigns()
1650 {
1651     DIR *campaigns = opendir(ConvertFileName(":Data:Campaigns"));
1652     struct dirent *campaign = NULL;
1653     if (!campaigns) {
1654         perror("Problem while loading campaigns");
1655         cerr << "campaign folder was : " << ConvertFileName(":Data:Campaigns") << endl;
1656         exit(EXIT_FAILURE);
1657     }
1658     vector<string> campaignNames;
1659     while ((campaign = readdir(campaigns)) != NULL) {
1660         string name(campaign->d_name);
1661         if (name.length() < 5)
1662             continue;
1663         if (!name.compare(name.length() - 4, 4, ".txt")) {
1664             campaignNames.push_back(name.substr(0, name.length() - 4));
1665         }
1666     }
1667     closedir(campaigns);
1668     return campaignNames;
1669 }
1670
1671 void Loadlevel(int which)
1672 {
1673     stealthloading = 0;
1674     whichlevel = which;
1675
1676     if (which == -1) {
1677         tutoriallevel = -1;
1678         Loadlevel("tutorial");
1679     } else if (which >= 0 && which <= 15) {
1680         char buf[32];
1681         snprintf(buf, 32, "map%d", which + 1); // challenges
1682         Loadlevel(buf);
1683     } else
1684         Loadlevel("mapsave");
1685 }
1686
1687 void Loadlevel(const char *name)
1688 {
1689     int templength;
1690     float lamefloat;
1691     static const char *pfx = ":Data:Maps:";
1692     char *buf;
1693
1694     float headprop, legprop, armprop, bodyprop;
1695
1696     LOGFUNC;
1697
1698     LOG(std::string("Loading level...") + name);
1699
1700     if (!gameon)
1701         visibleloading = 1;
1702     if (stealthloading)
1703         visibleloading = 0;
1704     if (!stillloading)
1705         loadtime = 0;
1706     gamestarted = 1;
1707
1708     numenvsounds = 0;
1709
1710     if (tutoriallevel != -1)
1711         tutoriallevel = 0;
1712     else
1713         tutoriallevel = 1;
1714
1715     if (tutoriallevel == 1)
1716         tutorialstage = 0;
1717     if (tutorialstage == 0) {
1718         tutorialstagetime = 0;
1719         tutorialmaxtime = 1;
1720     }
1721     loadingstuff = 1;
1722     pause_sound(whooshsound);
1723     pause_sound(stream_firesound);
1724
1725     // Change the map filename into something that is os specific
1726     buf = (char*) alloca(strlen(pfx) + strlen(name) + 1);
1727     sprintf(buf, "%s%s", pfx, name);
1728     const char *FixedFN = ConvertFileName(buf);
1729
1730     int mapvers;
1731     FILE *tfile;
1732     //~ char* buff=getcwd(NULL,0);
1733     //~ cout << buff << " " << FixedFN << endl;
1734     //~ free(buff);
1735     tfile = fopen( FixedFN, "rb" );
1736     if (tfile) {
1737         pause_sound(stream_firesound);
1738         scoreadded = 0;
1739         windialogue = false;
1740         hostiletime = 0;
1741         won = 0;
1742
1743         animation[bounceidleanim].Load((char *)"Idle", middleheight, neutral);
1744
1745         numdialogues = 0;
1746
1747         for (int i = 0; i < 20; i++)
1748             dialoguegonethrough[i] = 0;
1749
1750         indialogue = -1;
1751         cameramode = 0;
1752
1753         damagedealt = 0;
1754         damagetaken = 0;
1755
1756         if (accountactive)
1757             difficulty = accountactive->getDifficulty();
1758
1759         numhotspots = 0;
1760         currenthotspot = -1;
1761         bonustime = 1;
1762
1763         skyboxtexture = 1;
1764         skyboxr = 1;
1765         skyboxg = 1;
1766         skyboxb = 1;
1767
1768         freeze = 0;
1769         winfreeze = 0;
1770
1771         for (int i = 0; i < 100; i++)
1772             bonusnum[i] = 0;
1773
1774         numfalls = 0;
1775         numflipfail = 0;
1776         numseen = 0;
1777         numstaffattack = 0;
1778         numswordattack = 0;
1779         numknifeattack = 0;
1780         numunarmedattack = 0;
1781         numescaped = 0;
1782         numflipped = 0;
1783         numwallflipped = 0;
1784         numthrowkill = 0;
1785         numafterkill = 0;
1786         numreversals = 0;
1787         numattacks = 0;
1788         maxalarmed = 0;
1789         numresponded = 0;
1790
1791         bonustotal = startbonustotal;
1792         bonus = 0;
1793         gameon = 1;
1794         changedelay = 0;
1795         if (console) {
1796             emit_sound_np(consolesuccesssound);
1797             freeze = 0;
1798             console = false;
1799         }
1800
1801         if (!stealthloading) {
1802             terrain.numdecals = 0;
1803             Sprite::deleteSprites();
1804             for (int i = 0; i < objects.numobjects; i++)
1805                 objects.model[i].numdecals = 0;
1806
1807             int j = objects.numobjects;
1808             for (int i = 0; i < j; i++) {
1809                 objects.DeleteObject(0);
1810                 if (visibleloading)
1811                     LoadingScreen();
1812             }
1813
1814             for (int i = 0; i < subdivision; i++)
1815                 for (int j = 0; j < subdivision; j++)
1816                     terrain.patchobjectnum[i][j] = 0;
1817             if (visibleloading)
1818                 LoadingScreen();
1819         }
1820
1821         weapons.clear();
1822
1823         funpackf(tfile, "Bi", &mapvers);
1824         if (mapvers >= 15)
1825             funpackf(tfile, "Bi", &indemo);
1826         else
1827             indemo = 0;
1828         if (mapvers >= 5)
1829             funpackf(tfile, "Bi", &maptype);
1830         else
1831             maptype = mapkilleveryone;
1832         if (mapvers >= 6)
1833             funpackf(tfile, "Bi", &hostile);
1834         else
1835             hostile = 1;
1836         if (mapvers >= 4)
1837             funpackf(tfile, "Bf Bf", &viewdistance, &fadestart);
1838         else {
1839             viewdistance = 100;
1840             fadestart = .6;
1841         }
1842         if (mapvers >= 2)
1843             funpackf(tfile, "Bb Bf Bf Bf", &skyboxtexture, &skyboxr, &skyboxg, &skyboxb);
1844         else {
1845             skyboxtexture = 1;
1846             skyboxr = 1;
1847             skyboxg = 1;
1848             skyboxb = 1;
1849         }
1850         if (mapvers >= 10)
1851             funpackf(tfile, "Bf Bf Bf", &skyboxlightr, &skyboxlightg, &skyboxlightb);
1852         else {
1853             skyboxlightr = skyboxr;
1854             skyboxlightg = skyboxg;
1855             skyboxlightb = skyboxb;
1856         }
1857         if (!stealthloading)
1858             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);
1859         if (stealthloading)
1860             funpackf(tfile, "Bf Bf Bf Bf Bf Bi", &lamefloat, &lamefloat, &lamefloat, &lamefloat, &lamefloat, &Person::players[0]->num_weapons);
1861         Person::players[0]->originalcoords = Person::players[0]->coords;
1862         if (Person::players[0]->num_weapons > 0 && Person::players[0]->num_weapons < 5)
1863             for (int j = 0; j < Person::players[0]->num_weapons; j++) {
1864                 Person::players[0]->weaponids[j] = weapons.size();
1865                 int type;
1866                 funpackf(tfile, "Bi", &type);
1867                 weapons.push_back(Weapon(type, 0));
1868             }
1869
1870         if (visibleloading)
1871             LoadingScreen();
1872
1873         funpackf(tfile, "Bf Bf Bf", &Person::players[0]->armorhead, &Person::players[0]->armorhigh, &Person::players[0]->armorlow);
1874         funpackf(tfile, "Bf Bf Bf", &Person::players[0]->protectionhead, &Person::players[0]->protectionhigh, &Person::players[0]->protectionlow);
1875         funpackf(tfile, "Bf Bf Bf", &Person::players[0]->metalhead, &Person::players[0]->metalhigh, &Person::players[0]->metallow);
1876         funpackf(tfile, "Bf Bf", &Person::players[0]->power, &Person::players[0]->speedmult);
1877
1878         funpackf(tfile, "Bi", &Person::players[0]->numclothes);
1879
1880         if (mapvers >= 9)
1881             funpackf(tfile, "Bi Bi", &Person::players[0]->whichskin, &Person::players[0]->creature);
1882         else {
1883             Person::players[0]->whichskin = 0;
1884             Person::players[0]->creature = rabbittype;
1885         }
1886
1887         Person::players[0]->lastattack = -1;
1888         Person::players[0]->lastattack2 = -1;
1889         Person::players[0]->lastattack3 = -1;
1890
1891         //dialogues
1892         if (mapvers >= 8) {
1893             funpackf(tfile, "Bi", &numdialogues);
1894             for (int k = 0; k < numdialogues; k++) {
1895                 funpackf(tfile, "Bi", &numdialogueboxes[k]);
1896                 funpackf(tfile, "Bi", &dialoguetype[k]);
1897                 for (int l = 0; l < 10; l++) {
1898                     funpackf(tfile, "Bf Bf Bf", &participantlocation[k][l].x, &participantlocation[k][l].y, &participantlocation[k][l].z);
1899                     funpackf(tfile, "Bf", &participantyaw[k][l]);
1900                 }
1901                 for (int l = 0; l < numdialogueboxes[k]; l++) {
1902                     funpackf(tfile, "Bi", &dialogueboxlocation[k][l]);
1903                     funpackf(tfile, "Bf", &dialogueboxcolor[k][l][0]);
1904                     funpackf(tfile, "Bf", &dialogueboxcolor[k][l][1]);
1905                     funpackf(tfile, "Bf", &dialogueboxcolor[k][l][2]);
1906                     funpackf(tfile, "Bi", &dialogueboxsound[k][l]);
1907
1908                     funpackf(tfile, "Bi", &templength);
1909                     if (templength > 128 || templength <= 0)
1910                         templength = 128;
1911                     int m;
1912                     for (m = 0; m < templength; m++) {
1913                         funpackf(tfile, "Bb", &dialoguetext[k][l][m]);
1914                         if (dialoguetext[k][l][m] == '\0')
1915                             break;
1916                     }
1917                     dialoguetext[k][l][m] = 0;
1918
1919                     funpackf(tfile, "Bi", &templength);
1920                     if (templength > 64 || templength <= 0)
1921                         templength = 64;
1922                     for (m = 0; m < templength; m++) {
1923                         funpackf(tfile, "Bb", &dialoguename[k][l][m]);
1924                         if (dialoguename[k][l][m] == '\0')
1925                             break;
1926                     }
1927                     dialoguename[k][l][m] = 0;
1928                     funpackf(tfile, "Bf Bf Bf", &dialoguecamera[k][l].x, &dialoguecamera[k][l].y, &dialoguecamera[k][l].z);
1929                     funpackf(tfile, "Bi", &participantfocus[k][l]);
1930                     funpackf(tfile, "Bi", &participantaction[k][l]);
1931
1932                     for (m = 0; m < 10; m++)
1933                         funpackf(tfile, "Bf Bf Bf", &participantfacing[k][l][m].x, &participantfacing[k][l][m].y, &participantfacing[k][l][m].z);
1934
1935                     funpackf(tfile, "Bf Bf", &dialoguecamerayaw[k][l], &dialoguecamerapitch[k][l]);
1936                 }
1937             }
1938         } else
1939             numdialogues = 0;
1940
1941         for (int k = 0; k < Person::players[0]->numclothes; k++) {
1942             funpackf(tfile, "Bi", &templength);
1943             for (int l = 0; l < templength; l++)
1944                 funpackf(tfile, "Bb", &Person::players[0]->clothes[k][l]);
1945             Person::players[0]->clothes[k][templength] = '\0';
1946             funpackf(tfile, "Bf Bf Bf", &Person::players[0]->clothestintr[k], &Person::players[0]->clothestintg[k], &Person::players[0]->clothestintb[k]);
1947         }
1948
1949         funpackf(tfile, "Bi", &environment);
1950
1951         funpackf(tfile, "Bi", &objects.numobjects);
1952         for (int i = 0; i < objects.numobjects; i++) {
1953             funpackf(tfile, "Bi Bf Bf Bf Bf Bf Bf", &objects.type[i], &objects.yaw[i], &objects.pitch[i], &objects.position[i].x, &objects.position[i].y, &objects.position[i].z, &objects.scale[i]);
1954             if (objects.type[i] == treeleavestype)
1955                 objects.scale[i] = objects.scale[i - 1];
1956         }
1957
1958         if (mapvers >= 7) {
1959             funpackf(tfile, "Bi", &numhotspots);
1960             for (int i = 0; i < numhotspots; i++) {
1961                 funpackf(tfile, "Bi Bf Bf Bf Bf", &hotspottype[i], &hotspotsize[i], &hotspot[i].x, &hotspot[i].y, &hotspot[i].z);
1962                 funpackf(tfile, "Bi", &templength);
1963                 if (templength)
1964                     for (int l = 0; l < templength; l++)
1965                         funpackf(tfile, "Bb", &hotspottext[i][l]);
1966                 hotspottext[i][templength] = '\0';
1967                 if (hotspottype[i] == -111)
1968                     indemo = 1;
1969             }
1970         } else
1971             numhotspots = 0;
1972
1973         if (visibleloading)
1974             LoadingScreen();
1975
1976         if (!stealthloading) {
1977             objects.center = 0;
1978             for (int i = 0; i < objects.numobjects; i++)
1979                 objects.center += objects.position[i];
1980             objects.center /= objects.numobjects;
1981
1982
1983             if (visibleloading)
1984                 LoadingScreen();
1985
1986             float maxdistance = 0;
1987             float tempdist;
1988             //~ int whichclosest;
1989             for (int i = 0; i < objects.numobjects; i++) {
1990                 tempdist = distsq(&objects.center, &objects.position[i]);
1991                 if (tempdist > maxdistance) {
1992                     //~ whichclosest=i;
1993                     maxdistance = tempdist;
1994                 }
1995             }
1996             objects.radius = fast_sqrt(maxdistance);
1997         }
1998
1999         if (visibleloading)
2000             LoadingScreen();
2001
2002         int numplayers;
2003         funpackf(tfile, "Bi", &numplayers);
2004         int howmanyremoved = 0;
2005         bool removeanother = 0;
2006         if (numplayers > maxplayers) {
2007             cout << "Warning: this level contains more players than allowed" << endl;
2008         }
2009         if (numplayers > 1) {
2010             for (int i = 1; i < numplayers; i++) {
2011                 Person::players.push_back(shared_ptr<Person>(new Person()));
2012                 if (visibleloading)
2013                     LoadingScreen();
2014                 removeanother = 0;
2015
2016                 funpackf(tfile, "Bi Bi Bf Bf Bf Bi", &Person::players[i - howmanyremoved]->whichskin, &Person::players[i - howmanyremoved]->creature, &Person::players[i - howmanyremoved]->coords.x, &Person::players[i - howmanyremoved]->coords.y, &Person::players[i - howmanyremoved]->coords.z, &Person::players[i - howmanyremoved]->num_weapons);
2017                 if (mapvers >= 5)
2018                     funpackf(tfile, "Bi", &Person::players[i - howmanyremoved]->howactive);
2019                 else
2020                     Person::players[i - howmanyremoved]->howactive = typeactive;
2021                 if (mapvers >= 3)
2022                     funpackf(tfile, "Bf", &Person::players[i - howmanyremoved]->scale);
2023                 else
2024                     Person::players[i - howmanyremoved]->scale = -1;
2025                 if (mapvers >= 11)
2026                     funpackf(tfile, "Bb", &Person::players[i - howmanyremoved]->immobile);
2027                 else
2028                     Person::players[i - howmanyremoved]->immobile = 0;
2029                 if (mapvers >= 12)
2030                     funpackf(tfile, "Bf", &Person::players[i - howmanyremoved]->yaw);
2031                 else
2032                     Person::players[i - howmanyremoved]->yaw = 0;
2033                 Person::players[i - howmanyremoved]->targetyaw = Person::players[i - howmanyremoved]->yaw;
2034                 if (Person::players[i - howmanyremoved]->num_weapons < 0 || Person::players[i - howmanyremoved]->num_weapons > 5) {
2035                     removeanother = 1;
2036                     howmanyremoved++;
2037                 }
2038                 if (!removeanother) {
2039                     if (Person::players[i - howmanyremoved]->num_weapons > 0 && Person::players[i - howmanyremoved]->num_weapons < 5) {
2040                         for (int j = 0; j < Person::players[i - howmanyremoved]->num_weapons; j++) {
2041                             Person::players[i - howmanyremoved]->weaponids[j] = weapons.size();
2042                             int type;
2043                             funpackf(tfile, "Bi", &type);
2044                             weapons.push_back(Weapon(type, i));
2045                         }
2046                     }
2047                     funpackf(tfile, "Bi", &Person::players[i - howmanyremoved]->numwaypoints);
2048                     //Person::players[i-howmanyremoved]->numwaypoints=10;
2049                     for (int j = 0; j < Person::players[i - howmanyremoved]->numwaypoints; j++) {
2050                         funpackf(tfile, "Bf", &Person::players[i - howmanyremoved]->waypoints[j].x);
2051                         funpackf(tfile, "Bf", &Person::players[i - howmanyremoved]->waypoints[j].y);
2052                         funpackf(tfile, "Bf", &Person::players[i - howmanyremoved]->waypoints[j].z);
2053                         if (mapvers >= 5)
2054                             funpackf(tfile, "Bi", &Person::players[i - howmanyremoved]->waypointtype[j]);
2055                         else
2056                             Person::players[i - howmanyremoved]->waypointtype[j] = wpkeepwalking;
2057                     }
2058
2059                     funpackf(tfile, "Bi", &Person::players[i - howmanyremoved]->waypoint);
2060                     if (Person::players[i - howmanyremoved]->waypoint > Person::players[i - howmanyremoved]->numwaypoints - 1)
2061                         Person::players[i - howmanyremoved]->waypoint = 0;
2062
2063                     funpackf(tfile, "Bf Bf Bf", &Person::players[i - howmanyremoved]->armorhead, &Person::players[i - howmanyremoved]->armorhigh, &Person::players[i - howmanyremoved]->armorlow);
2064                     funpackf(tfile, "Bf Bf Bf", &Person::players[i - howmanyremoved]->protectionhead, &Person::players[i - howmanyremoved]->protectionhigh, &Person::players[i - howmanyremoved]->protectionlow);
2065                     funpackf(tfile, "Bf Bf Bf", &Person::players[i - howmanyremoved]->metalhead, &Person::players[i - howmanyremoved]->metalhigh, &Person::players[i - howmanyremoved]->metallow);
2066                     funpackf(tfile, "Bf Bf", &Person::players[i - howmanyremoved]->power, &Person::players[i - howmanyremoved]->speedmult);
2067
2068                     if (mapvers >= 4)
2069                         funpackf(tfile, "Bf Bf Bf Bf", &headprop, &bodyprop, &armprop, &legprop);
2070                     else {
2071                         headprop = 1;
2072                         bodyprop = 1;
2073                         armprop = 1;
2074                         legprop = 1;
2075                     }
2076                     if (Person::players[i - howmanyremoved]->creature == wolftype) {
2077                         Person::players[i - howmanyremoved]->proportionhead = 1.1 * headprop;
2078                         Person::players[i - howmanyremoved]->proportionbody = 1.1 * bodyprop;
2079                         Person::players[i - howmanyremoved]->proportionarms = 1.1 * armprop;
2080                         Person::players[i - howmanyremoved]->proportionlegs = 1.1 * legprop;
2081                     }
2082
2083                     if (Person::players[i - howmanyremoved]->creature == rabbittype) {
2084                         Person::players[i - howmanyremoved]->proportionhead = 1.2 * headprop;
2085                         Person::players[i - howmanyremoved]->proportionbody = 1.05 * bodyprop;
2086                         Person::players[i - howmanyremoved]->proportionarms = 1.00 * armprop;
2087                         Person::players[i - howmanyremoved]->proportionlegs = 1.1 * legprop;
2088                         Person::players[i - howmanyremoved]->proportionlegs.y = 1.05 * legprop;
2089                     }
2090
2091                     funpackf(tfile, "Bi", &Person::players[i - howmanyremoved]->numclothes);
2092                     if (Person::players[i - howmanyremoved]->numclothes) {
2093                         for (int k = 0; k < Person::players[i - howmanyremoved]->numclothes; k++) {
2094                             int templength;
2095                             funpackf(tfile, "Bi", &templength);
2096                             for (int l = 0; l < templength; l++)
2097                                 funpackf(tfile, "Bb", &Person::players[i - howmanyremoved]->clothes[k][l]);
2098                             Person::players[i - howmanyremoved]->clothes[k][templength] = '\0';
2099                             funpackf(tfile, "Bf Bf Bf", &Person::players[i - howmanyremoved]->clothestintr[k], &Person::players[i - howmanyremoved]->clothestintg[k], &Person::players[i - howmanyremoved]->clothestintb[k]);
2100                         }
2101                     }
2102                 }
2103             }
2104         }
2105         if (visibleloading)
2106             LoadingScreen();
2107
2108         numplayers -= howmanyremoved;
2109         Person::players.resize(numplayers);
2110
2111         funpackf(tfile, "Bi", &numpathpoints);
2112         if (numpathpoints > 30 || numpathpoints < 0)
2113             numpathpoints = 0;
2114         for (int j = 0; j < numpathpoints; j++) {
2115             funpackf(tfile, "Bf Bf Bf Bi", &pathpoint[j].x, &pathpoint[j].y, &pathpoint[j].z, &numpathpointconnect[j]);
2116             for (int k = 0; k < numpathpointconnect[j]; k++) {
2117                 funpackf(tfile, "Bi", &pathpointconnect[j][k]);
2118             }
2119         }
2120         if (visibleloading)
2121             LoadingScreen();
2122
2123         funpackf(tfile, "Bf Bf Bf Bf", &mapcenter.x, &mapcenter.y, &mapcenter.z, &mapradius);
2124
2125         SetUpLighting();
2126         if (environment != oldenvironment)
2127             Setenvironment(environment);
2128         oldenvironment = environment;
2129
2130         if (!stealthloading) {
2131             int j = objects.numobjects;
2132             objects.numobjects = 0;
2133             for (int i = 0; i < j; i++) {
2134                 objects.MakeObject(objects.type[i], objects.position[i], objects.yaw[i], objects.pitch[i], objects.scale[i]);
2135                 if (visibleloading)
2136                     LoadingScreen();
2137             }
2138
2139             terrain.DoShadows();
2140             if (visibleloading)
2141                 LoadingScreen();
2142             objects.DoShadows();
2143             if (visibleloading)
2144                 LoadingScreen();
2145         }
2146
2147         fclose(tfile);
2148
2149         for (unsigned i = 0; i < Person::players.size(); i++) {
2150             if (visibleloading)
2151                 LoadingScreen();
2152             Person::players[i]->burnt = 0;
2153             Person::players[i]->bled = 0;
2154             Person::players[i]->onfire = 0;
2155             if (i == 0 || Person::players[i]->scale < 0)
2156                 Person::players[i]->scale = .2;
2157             Person::players[i]->skeleton.free = 0;
2158             Person::players[i]->skeleton.id = i;
2159             if (i == 0 && mapvers < 9)
2160                 Person::players[i]->creature = rabbittype;
2161             if (Person::players[i]->creature != wolftype) {
2162                 Person::players[i]->skeleton.Load(
2163                     (char *)":Data:Skeleton:Basic Figure",
2164                     (char *)":Data:Skeleton:Basic Figurelow",
2165                     (char *)":Data:Skeleton:Rabbitbelt",
2166                     (char *)":Data:Models:Body.solid",
2167                     (char *)":Data:Models:Body2.solid",
2168                     (char *)":Data:Models:Body3.solid",
2169                     (char *)":Data:Models:Body4.solid",
2170                     (char *)":Data:Models:Body5.solid",
2171                     (char *)":Data:Models:Body6.solid",
2172                     (char *)":Data:Models:Body7.solid",
2173                     (char *)":Data:Models:Bodylow.solid",
2174                     (char *)":Data:Models:Belt.solid", 0);
2175             } else {
2176                 if (Person::players[i]->creature != wolftype) {
2177                     Person::players[i]->skeleton.Load(
2178                         (char *)":Data:Skeleton:Basic Figure",
2179                         (char *)":Data:Skeleton:Basic Figurelow",
2180                         (char *)":Data:Skeleton:Rabbitbelt",
2181                         (char *)":Data:Models:Body.solid",
2182                         (char *)":Data:Models:Body2.solid",
2183                         (char *)":Data:Models:Body3.solid",
2184                         (char *)":Data:Models:Body4.solid",
2185                         (char *)":Data:Models:Body5.solid",
2186                         (char *)":Data:Models:Body6.solid",
2187                         (char *)":Data:Models:Body7.solid",
2188                         (char *)":Data:Models:Bodylow.solid",
2189                         (char *)":Data:Models:Belt.solid", 1);
2190                     Person::players[i]->skeleton.drawmodelclothes.textureptr.load(":Data:Textures:Belt.png", 1, 1);
2191                 }
2192                 if (Person::players[i]->creature == wolftype) {
2193                     Person::players[i]->skeleton.Load(
2194                         (char *)":Data:Skeleton:Basic Figure Wolf",
2195                         (char *)":Data:Skeleton:Basic Figure Wolf Low",
2196                         (char *)":Data:Skeleton:Rabbitbelt",
2197                         (char *)":Data:Models:Wolf.solid",
2198                         (char *)":Data:Models:Wolf2.solid",
2199                         (char *)":Data:Models:Wolf3.solid",
2200                         (char *)":Data:Models:Wolf4.solid",
2201                         (char *)":Data:Models:Wolf5.solid",
2202                         (char *)":Data:Models:Wolf6.solid",
2203                         (char *)":Data:Models:Wolf7.solid",
2204                         (char *)":Data:Models:Wolflow.solid",
2205                         (char *)":Data:Models:Belt.solid", 0);
2206                 }
2207             }
2208
2209             Person::players[i]->skeleton.drawmodel.textureptr.load(creatureskin[Person::players[i]->creature][Person::players[i]->whichskin], 1, &Person::players[i]->skeleton.skinText[0], &Person::players[i]->skeleton.skinsize);
2210
2211             if (Person::players[i]->numclothes) {
2212                 for (int j = 0; j < Person::players[i]->numclothes; j++) {
2213                     tintr = Person::players[i]->clothestintr[j];
2214                     tintg = Person::players[i]->clothestintg[j];
2215                     tintb = Person::players[i]->clothestintb[j];
2216                     AddClothes((char *)Person::players[i]->clothes[j], &Person::players[i]->skeleton.skinText[0]);
2217                 }
2218                 Person::players[i]->DoMipmaps();
2219             }
2220
2221             Person::players[i]->animCurrent = bounceidleanim;
2222             Person::players[i]->animTarget = bounceidleanim;
2223             Person::players[i]->frameCurrent = 0;
2224             Person::players[i]->frameTarget = 1;
2225             Person::players[i]->target = 0;
2226             Person::players[i]->speed = 1 + (float)(Random() % 100) / 1000;
2227             if (difficulty == 0)
2228                 Person::players[i]->speed -= .2;
2229             if (difficulty == 1)
2230                 Person::players[i]->speed -= .1;
2231
2232             Person::players[i]->velocity = 0;
2233             Person::players[i]->oldcoords = Person::players[i]->coords;
2234             Person::players[i]->realoldcoords = Person::players[i]->coords;
2235
2236             Person::players[i]->id = i;
2237             Person::players[i]->skeleton.id = i;
2238             Person::players[i]->updatedelay = 0;
2239             Person::players[i]->normalsupdatedelay = 0;
2240
2241             Person::players[i]->aitype = passivetype;
2242             Person::players[i]->madskills = 0;
2243
2244             if (i == 0) {
2245                 Person::players[i]->proportionhead = 1.2;
2246                 Person::players[i]->proportionbody = 1.05;
2247                 Person::players[i]->proportionarms = 1.00;
2248                 Person::players[i]->proportionlegs = 1.1;
2249                 Person::players[i]->proportionlegs.y = 1.05;
2250             }
2251             Person::players[i]->headless = 0;
2252             Person::players[i]->currentoffset = 0;
2253             Person::players[i]->targetoffset = 0;
2254
2255             Person::players[i]->damagetolerance = 200;
2256
2257             if (Person::players[i]->creature == wolftype) {
2258                 if (i == 0 || Person::players[i]->scale < 0)
2259                     Person::players[i]->scale = .23;
2260                 Person::players[i]->damagetolerance = 300;
2261             }
2262
2263             if (visibleloading)
2264                 LoadingScreen();
2265             if (cellophane) {
2266                 Person::players[i]->proportionhead.z = 0;
2267                 Person::players[i]->proportionbody.z = 0;
2268                 Person::players[i]->proportionarms.z = 0;
2269                 Person::players[i]->proportionlegs.z = 0;
2270             }
2271
2272             Person::players[i]->tempanimation.Load((char *)"Tempanim", 0, 0);
2273
2274             Person::players[i]->headmorphness = 0;
2275             Person::players[i]->targetheadmorphness = 1;
2276             Person::players[i]->headmorphstart = 0;
2277             Person::players[i]->headmorphend = 0;
2278
2279             Person::players[i]->pausetime = 0;
2280
2281             Person::players[i]->dead = 0;
2282             Person::players[i]->jumppower = 5;
2283             Person::players[i]->damage = 0;
2284             Person::players[i]->permanentdamage = 0;
2285             Person::players[i]->superpermanentdamage = 0;
2286
2287             Person::players[i]->forwardkeydown = 0;
2288             Person::players[i]->leftkeydown = 0;
2289             Person::players[i]->backkeydown = 0;
2290             Person::players[i]->rightkeydown = 0;
2291             Person::players[i]->jumpkeydown = 0;
2292             Person::players[i]->crouchkeydown = 0;
2293             Person::players[i]->throwkeydown = 0;
2294
2295             Person::players[i]->collided = -10;
2296             Person::players[i]->loaded = 1;
2297             Person::players[i]->bloodloss = 0;
2298             Person::players[i]->weaponactive = -1;
2299             Person::players[i]->weaponstuck = -1;
2300             Person::players[i]->bleeding = 0;
2301             Person::players[i]->deathbleeding = 0;
2302             Person::players[i]->stunned = 0;
2303             Person::players[i]->hasvictim = 0;
2304             Person::players[i]->wentforweapon = 0;
2305         }
2306
2307         Person::players[0]->aitype = playercontrolled;
2308         Person::players[0]->weaponactive = -1;
2309
2310         if (difficulty == 1) {
2311             Person::players[0]->power = 1 / .9;
2312             Person::players[0]->damagetolerance = 250;
2313         } else if (difficulty == 0) {
2314             Person::players[0]->power = 1 / .8;
2315             Person::players[0]->damagetolerance = 300;
2316             Person::players[0]->armorhead *= 1.5;
2317             Person::players[0]->armorhigh *= 1.5;
2318             Person::players[0]->armorlow *= 1.5;
2319         }
2320
2321         cameraloc = Person::players[0]->coords;
2322         cameraloc.y += 5;
2323         yaw = Person::players[0]->yaw;
2324
2325         hawkcoords = Person::players[0]->coords;
2326         hawkcoords.y += 30;
2327
2328         if (visibleloading)
2329             LoadingScreen();
2330
2331         LOG("Starting background music...");
2332
2333         OPENAL_StopSound(OPENAL_ALL);
2334         if (ambientsound) {
2335             if (environment == snowyenvironment) {
2336                 emit_stream_np(stream_wind);
2337             } else if (environment == desertenvironment) {
2338                 emit_stream_np(stream_desertambient);
2339             } else if (environment == grassyenvironment) {
2340                 emit_stream_np(stream_wind, 100.);
2341             }
2342         }
2343         oldmusicvolume[0] = 0;
2344         oldmusicvolume[1] = 0;
2345         oldmusicvolume[2] = 0;
2346         oldmusicvolume[3] = 0;
2347
2348         if (!firstload)
2349             firstload = 1;
2350     } else {
2351         perror("Problem");
2352     }
2353     leveltime = 0;
2354     loadingstuff = 0;
2355     visibleloading = 0;
2356 }
2357
2358 void doTutorial()
2359 {
2360     if (tutorialstagetime > tutorialmaxtime) {
2361         tutorialstage++;
2362         tutorialsuccess = 0;
2363         if (tutorialstage <= 1) {
2364             canattack = 0;
2365             cananger = 0;
2366             reversaltrain = 0;
2367         }
2368         switch (tutorialstage) {
2369         case 1:
2370             tutorialmaxtime = 5;
2371             break;
2372         case 2:
2373             tutorialmaxtime = 2;
2374             break;
2375         case 3:
2376             tutorialmaxtime = 600;
2377             break;
2378         case 4:
2379             tutorialmaxtime = 1000;
2380             break;
2381         case 5:
2382             tutorialmaxtime = 600;
2383             break;
2384         case 6:
2385             tutorialmaxtime = 600;
2386             break;
2387         case 7:
2388             tutorialmaxtime = 600;
2389             break;
2390         case 8:
2391             tutorialmaxtime = 600;
2392             break;
2393         case 9:
2394             tutorialmaxtime = 600;
2395             break;
2396         case 10:
2397             tutorialmaxtime = 2;
2398             break;
2399         case 11:
2400             tutorialmaxtime = 1000;
2401             break;
2402         case 12:
2403             tutorialmaxtime = 1000;
2404             break;
2405         case 13:
2406             tutorialmaxtime = 2;
2407             break;
2408         case 14: {
2409             tutorialmaxtime = 3;
2410
2411             XYZ temp, temp2;
2412
2413             temp.x = 1011;
2414             temp.y = 84;
2415             temp.z = 491;
2416             temp2.x = 1025;
2417             temp2.y = 75;
2418             temp2.z = 447;
2419
2420             Person::players[1]->coords = (temp + temp2) / 2;
2421
2422             emit_sound_at(fireendsound, Person::players[1]->coords);
2423
2424             for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
2425                 if (Random() % 2 == 0) {
2426                     if (!Person::players[1]->skeleton.free)
2427                         temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
2428                     if (Person::players[1]->skeleton.free)
2429                         temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
2430                     if (!Person::players[1]->skeleton.free)
2431                         temp = DoRotation(DoRotation(DoRotation(Person::players[1]->skeleton.joints[i].position, 0, 0, Person::players[1]->tilt), Person::players[1]->tilt2, 0, 0), 0, Person::players[1]->yaw, 0) * Person::players[1]->scale + Person::players[1]->coords;
2432                     if (Person::players[1]->skeleton.free)
2433                         temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
2434                     Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
2435                 }
2436             }
2437         }
2438         break;
2439         case 15:
2440             tutorialmaxtime = 500;
2441             break;
2442         case 16:
2443             tutorialmaxtime = 500;
2444             break;
2445         case 17:
2446             tutorialmaxtime = 500;
2447             break;
2448         case 18:
2449             tutorialmaxtime = 500;
2450             break;
2451         case 19:
2452             tutorialstage = 20;
2453             //tutorialmaxtime=500;
2454             break;
2455         case 20:
2456             tutorialmaxtime = 500;
2457             break;
2458         case 21:
2459             tutorialmaxtime = 500;
2460             if (bonus == cannon) {
2461                 bonus = Slicebonus;
2462                 againbonus = 1;
2463             } else
2464                 againbonus = 0;
2465             break;
2466         case 22:
2467             tutorialmaxtime = 500;
2468             break;
2469         case 23:
2470             tutorialmaxtime = 500;
2471             break;
2472         case 24:
2473             tutorialmaxtime = 500;
2474             break;
2475         case 25:
2476             tutorialmaxtime = 500;
2477             break;
2478         case 26:
2479             tutorialmaxtime = 2;
2480             break;
2481         case 27:
2482             tutorialmaxtime = 4;
2483             reversaltrain = 1;
2484             cananger = 1;
2485             Person::players[1]->aitype = attacktypecutoff;
2486             break;
2487         case 28:
2488             tutorialmaxtime = 400;
2489             break;
2490         case 29:
2491             tutorialmaxtime = 400;
2492             Person::players[0]->escapednum = 0;
2493             break;
2494         case 30:
2495             tutorialmaxtime = 4;
2496             reversaltrain = 0;
2497             cananger = 0;
2498             Person::players[1]->aitype = passivetype;
2499             break;
2500         case 31:
2501             tutorialmaxtime = 13;
2502             break;
2503         case 32:
2504             tutorialmaxtime = 8;
2505             break;
2506         case 33:
2507             tutorialmaxtime = 400;
2508             cananger = 1;
2509             canattack = 1;
2510             Person::players[1]->aitype = attacktypecutoff;
2511             break;
2512         case 34:
2513             tutorialmaxtime = 400;
2514             break;
2515         case 35:
2516             tutorialmaxtime = 400;
2517             break;
2518         case 36:
2519             tutorialmaxtime = 2;
2520             reversaltrain = 0;
2521             cananger = 0;
2522             Person::players[1]->aitype = passivetype;
2523             break;
2524         case 37:
2525             damagedealt = 0;
2526             damagetaken = 0;
2527             tutorialmaxtime = 50;
2528             cananger = 1;
2529             canattack = 1;
2530             Person::players[1]->aitype = attacktypecutoff;
2531             break;
2532         case 38:
2533             tutorialmaxtime = 4;
2534             canattack = 0;
2535             cananger = 0;
2536             Person::players[1]->aitype = passivetype;
2537             break;
2538         case 39: {
2539             XYZ temp, temp2;
2540
2541             temp.x = 1011;
2542             temp.y = 84;
2543             temp.z = 491;
2544             temp2.x = 1025;
2545             temp2.y = 75;
2546             temp2.z = 447;
2547
2548             Weapon w(knife, -1);
2549             w.position = (temp + temp2) / 2;
2550             w.tippoint = (temp + temp2) / 2;
2551
2552             w.velocity = 0.1;
2553             w.tipvelocity = 0.1;
2554             w.missed = 1;
2555             w.hitsomething = 0;
2556             w.freetime = 0;
2557             w.firstfree = 1;
2558             w.physics = 1;
2559
2560             weapons.push_back(w);
2561         }
2562         break;
2563         case 40:
2564             tutorialmaxtime = 300;
2565             break;
2566         case 41:
2567             tutorialmaxtime = 300;
2568             break;
2569         case 42:
2570             tutorialmaxtime = 8;
2571             break;
2572         case 43:
2573             tutorialmaxtime = 300;
2574             break;
2575         case 44:
2576             weapons[0].owner = 1;
2577             Person::players[0]->weaponactive = -1;
2578             Person::players[0]->num_weapons = 0;
2579             Person::players[1]->weaponactive = 0;
2580             Person::players[1]->num_weapons = 1;
2581             Person::players[1]->weaponids[0] = 0;
2582
2583             cananger = 1;
2584             canattack = 1;
2585             Person::players[1]->aitype = attacktypecutoff;
2586
2587             tutorialmaxtime = 300;
2588             break;
2589         case 45:
2590             weapons[0].owner = 1;
2591             Person::players[0]->weaponactive = -1;
2592             Person::players[0]->num_weapons = 0;
2593             Person::players[1]->weaponactive = 0;
2594             Person::players[1]->num_weapons = 1;
2595             Person::players[1]->weaponids[0] = 0;
2596
2597             tutorialmaxtime = 300;
2598             break;
2599         case 46:
2600             weapons[0].owner = 1;
2601             Person::players[0]->weaponactive = -1;
2602             Person::players[0]->num_weapons = 0;
2603             Person::players[1]->weaponactive = 0;
2604             Person::players[1]->num_weapons = 1;
2605             Person::players[1]->weaponids[0] = 0;
2606
2607             weapons[0].setType(sword);
2608
2609             tutorialmaxtime = 300;
2610             break;
2611         case 47: {
2612             tutorialmaxtime = 10;
2613
2614             XYZ temp, temp2;
2615
2616             temp.x = 1011;
2617             temp.y = 84;
2618             temp.z = 491;
2619             temp2.x = 1025;
2620             temp2.y = 75;
2621             temp2.z = 447;
2622
2623             Weapon w(sword, -1);
2624             w.position = (temp + temp2) / 2;
2625             w.tippoint = (temp + temp2) / 2;
2626
2627             w.velocity = 0.1;
2628             w.tipvelocity = 0.1;
2629             w.missed = 1;
2630             w.hitsomething = 0;
2631             w.freetime = 0;
2632             w.firstfree = 1;
2633             w.physics = 1;
2634
2635             weapons.push_back(w);
2636
2637             weapons[0].owner = 1;
2638             weapons[1].owner = 0;
2639             Person::players[0]->weaponactive = 0;
2640             Person::players[0]->num_weapons = 1;
2641             Person::players[0]->weaponids[0] = 1;
2642             Person::players[1]->weaponactive = 0;
2643             Person::players[1]->num_weapons = 1;
2644             Person::players[1]->weaponids[0] = 0;
2645
2646         }
2647         break;
2648         case 48:
2649             canattack = 0;
2650             cananger = 0;
2651             Person::players[1]->aitype = passivetype;
2652
2653             tutorialmaxtime = 15;
2654
2655             weapons[0].owner = 1;
2656             weapons[1].owner = 0;
2657             Person::players[0]->weaponactive = 0;
2658             Person::players[0]->num_weapons = 1;
2659             Person::players[0]->weaponids[0] = 1;
2660             Person::players[1]->weaponactive = 0;
2661             Person::players[1]->num_weapons = 1;
2662             Person::players[1]->weaponids[0] = 0;
2663
2664             if (Person::players[0]->weaponactive != -1)
2665                 weapons[Person::players[0]->weaponids[Person::players[0]->weaponactive]].setType(staff);
2666             else
2667                 weapons[0].setType(staff);
2668             break;
2669         case 49:
2670             canattack = 0;
2671             cananger = 0;
2672             Person::players[1]->aitype = passivetype;
2673
2674             tutorialmaxtime = 200;
2675
2676             weapons[1].position = 1000;
2677             weapons[1].tippoint = 1000;
2678
2679             weapons[0].setType(knife);
2680
2681             weapons[0].owner = 0;
2682             Person::players[1]->weaponactive = -1;
2683             Person::players[1]->num_weapons = 0;
2684             Person::players[0]->weaponactive = 0;
2685             Person::players[0]->num_weapons = 1;
2686             Person::players[0]->weaponids[0] = 0;
2687
2688             break;
2689         case 50: {
2690             tutorialmaxtime = 8;
2691
2692             XYZ temp, temp2;
2693             emit_sound_at(fireendsound, Person::players[1]->coords);
2694
2695             for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
2696                 if (Random() % 2 == 0) {
2697                     if (!Person::players[1]->skeleton.free)
2698                         temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
2699                     if (Person::players[1]->skeleton.free)
2700                         temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
2701                     if (!Person::players[1]->skeleton.free)
2702                         temp = DoRotation(DoRotation(DoRotation(Person::players[1]->skeleton.joints[i].position, 0, 0, Person::players[1]->tilt), Person::players[1]->tilt2, 0, 0), 0, Person::players[1]->yaw, 0) * Person::players[1]->scale + Person::players[1]->coords;
2703                     if (Person::players[1]->skeleton.free)
2704                         temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
2705                     Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
2706                 }
2707             }
2708
2709             Person::players[1]->num_weapons = 0;
2710             Person::players[1]->weaponstuck = -1;
2711             Person::players[1]->weaponactive = -1;
2712
2713             weapons.clear();
2714         }
2715         break;
2716         case 51:
2717             tutorialmaxtime = 80000;
2718             break;
2719         default:
2720             break;
2721         }
2722         if (tutorialstage <= 51)
2723             tutorialstagetime = 0;
2724     }
2725
2726     //Tutorial success
2727     if (tutorialstagetime < tutorialmaxtime - 3) {
2728         switch (tutorialstage) {
2729         case 3:
2730             if (deltah || deltav)
2731                 tutorialsuccess += multiplier;
2732             break;
2733         case 4:
2734             if (Person::players[0]->forwardkeydown || Person::players[0]->backkeydown || Person::players[0]->leftkeydown || Person::players[0]->rightkeydown)
2735                 tutorialsuccess += multiplier;
2736             break;
2737         case 5:
2738             if (Person::players[0]->jumpkeydown)
2739                 tutorialsuccess = 1;
2740             break;
2741         case 6:
2742             if (Person::players[0]->isCrouch())
2743                 tutorialsuccess = 1;
2744             break;
2745         case 7:
2746             if (Person::players[0]->animTarget == rollanim)
2747                 tutorialsuccess = 1;
2748             break;
2749         case 8:
2750             if (Person::players[0]->animTarget == sneakanim)
2751                 tutorialsuccess += multiplier;
2752             break;
2753         case 9:
2754             if (Person::players[0]->animTarget == rabbitrunninganim || Person::players[0]->animTarget == wolfrunninganim)
2755                 tutorialsuccess += multiplier;
2756             break;
2757         case 11:
2758             if (Person::players[0]->isWallJump())
2759                 tutorialsuccess = 1;
2760             break;
2761         case 12:
2762             if (Person::players[0]->animTarget == flipanim)
2763                 tutorialsuccess = 1;
2764             break;
2765         case 15:
2766             if (Person::players[0]->animTarget == upunchanim || Person::players[0]->animTarget == winduppunchanim)
2767                 tutorialsuccess = 1;
2768             break;
2769         case 16:
2770             if (Person::players[0]->animTarget == winduppunchanim)
2771                 tutorialsuccess = 1;
2772             break;
2773         case 17:
2774             if (Person::players[0]->animTarget == spinkickanim)
2775                 tutorialsuccess = 1;
2776             break;
2777         case 18:
2778             if (Person::players[0]->animTarget == sweepanim)
2779                 tutorialsuccess = 1;
2780             break;
2781         case 19:
2782             if (Person::players[0]->animTarget == dropkickanim)
2783                 tutorialsuccess = 1;
2784             break;
2785         case 20:
2786             if (Person::players[0]->animTarget == rabbitkickanim)
2787                 tutorialsuccess = 1;
2788             break;
2789         case 21:
2790             if (bonus == cannon)
2791                 tutorialsuccess = 1;
2792             break;
2793         case 22:
2794             if (bonus == spinecrusher)
2795                 tutorialsuccess = 1;
2796             break;
2797         case 23:
2798             if (Person::players[0]->animTarget == walljumprightkickanim || Person::players[0]->animTarget == walljumpleftkickanim)
2799                 tutorialsuccess = 1;
2800             break;
2801         case 24:
2802             if (Person::players[0]->animTarget == rabbittacklinganim)
2803                 tutorialsuccess = 1;
2804             break;
2805         case 25:
2806             if (Person::players[0]->animTarget == backhandspringanim)
2807                 tutorialsuccess = 1;
2808             break;
2809         case 28:
2810             if (animation[Person::players[0]->animTarget].attack == reversed && Person::players[0]->feint)
2811                 tutorialsuccess = 1;
2812             break;
2813         case 29:
2814             if (Person::players[0]->escapednum == 2) {
2815                 tutorialsuccess = 1;
2816                 reversaltrain = 0;
2817                 cananger = 0;
2818                 Person::players[1]->aitype = passivetype;
2819             }
2820             break;
2821         case 33:
2822             if (animation[Person::players[0]->animTarget].attack == reversal)
2823                 tutorialsuccess = 1;
2824             break;
2825         case 34:
2826             if (animation[Person::players[0]->animTarget].attack == reversal)
2827                 tutorialsuccess = 1;
2828             break;
2829         case 35:
2830             if (animation[Person::players[0]->animTarget].attack == reversal) {
2831                 tutorialsuccess = 1;
2832                 reversaltrain = 0;
2833                 cananger = 0;
2834                 Person::players[1]->aitype = passivetype;
2835             }
2836             break;
2837         case 40:
2838             if (Person::players[0]->num_weapons > 0)
2839                 tutorialsuccess = 1;
2840             break;
2841         case 41:
2842             if (Person::players[0]->weaponactive == -1 && Person::players[0]->num_weapons > 0)
2843                 tutorialsuccess = 1;
2844             break;
2845         case 43:
2846             if (Person::players[0]->animTarget == knifeslashstartanim)
2847                 tutorialsuccess = 1;
2848             break;
2849         case 44:
2850             if (animation[Person::players[0]->animTarget].attack == reversal)
2851                 tutorialsuccess = 1;
2852             break;
2853         case 45:
2854             if (animation[Person::players[0]->animTarget].attack == reversal)
2855                 tutorialsuccess = 1;
2856             break;
2857         case 46:
2858             if (animation[Person::players[0]->animTarget].attack == reversal)
2859                 tutorialsuccess = 1;
2860             break;
2861         case 49:
2862             if (Person::players[1]->weaponstuck != -1)
2863                 tutorialsuccess = 1;
2864             break;
2865         default:
2866             break;
2867         }
2868         if (tutorialsuccess >= 1)
2869             tutorialstagetime = tutorialmaxtime - 3;
2870
2871
2872         if (tutorialstagetime == tutorialmaxtime - 3) {
2873             emit_sound_np(consolesuccesssound);
2874         }
2875
2876         if (tutorialsuccess >= 1) {
2877             if (tutorialstage == 34 || tutorialstage == 35)
2878                 tutorialstagetime = tutorialmaxtime - 1;
2879         }
2880     }
2881
2882     if (tutorialstage < 14 || tutorialstage >= 50) {
2883         Person::players[1]->coords.y = 300;
2884         Person::players[1]->velocity = 0;
2885     }
2886 }
2887
2888 void doDebugKeys()
2889 {
2890     float headprop, bodyprop, armprop, legprop;
2891     if (debugmode) {
2892         if (Input::isKeyPressed(SDL_SCANCODE_H)) {
2893             Person::players[0]->damagetolerance = 200000;
2894             Person::players[0]->damage = 0;
2895             Person::players[0]->burnt = 0;
2896             Person::players[0]->permanentdamage = 0;
2897             Person::players[0]->superpermanentdamage = 0;
2898         }
2899
2900         if (Input::isKeyPressed(SDL_SCANCODE_J)) {
2901             environment++;
2902             if (environment > 2)
2903                 environment = 0;
2904             Setenvironment(environment);
2905         }
2906
2907         if (Input::isKeyPressed(SDL_SCANCODE_C)) {
2908             cameramode = 1 - cameramode;
2909         }
2910
2911         if (Input::isKeyPressed(SDL_SCANCODE_X) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
2912             if (Person::players[0]->num_weapons > 0) {
2913                 if (weapons[Person::players[0]->weaponids[0]].getType() == sword)
2914                     weapons[Person::players[0]->weaponids[0]].setType(staff);
2915                 else if (weapons[Person::players[0]->weaponids[0]].getType() == staff)
2916                     weapons[Person::players[0]->weaponids[0]].setType(knife);
2917                 else
2918                     weapons[Person::players[0]->weaponids[0]].setType(sword);
2919             }
2920         }
2921
2922         if (Input::isKeyPressed(SDL_SCANCODE_X) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
2923             int closest = findClosestPlayer();
2924             if (closest >= 0) {
2925                 if (Person::players[closest]->num_weapons) {
2926                     if (weapons[Person::players[closest]->weaponids[0]].getType() == sword)
2927                         weapons[Person::players[closest]->weaponids[0]].setType(staff);
2928                     else if (weapons[Person::players[closest]->weaponids[0]].getType() == staff)
2929                         weapons[Person::players[closest]->weaponids[0]].setType(knife);
2930                     else
2931                         weapons[Person::players[closest]->weaponids[0]].setType(sword);
2932                 }
2933                 if (!Person::players[closest]->num_weapons) {
2934                     Person::players[closest]->weaponids[0] = weapons.size();
2935
2936                     weapons.push_back(Weapon(knife, closest));
2937
2938                     Person::players[closest]->num_weapons = 1;
2939                 }
2940             }
2941         }
2942
2943         if (Input::isKeyDown(SDL_SCANCODE_U)) {
2944             int closest = findClosestPlayer();
2945             if (closest >= 0) {
2946                 Person::players[closest]->yaw += multiplier * 50;
2947                 Person::players[closest]->targetyaw = Person::players[closest]->yaw;
2948             }
2949         }
2950
2951
2952         if (Input::isKeyPressed(SDL_SCANCODE_O) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
2953             int closest = findClosestPlayer();
2954             if (Input::isKeyDown(SDL_SCANCODE_LCTRL))
2955                 closest = 0;
2956
2957             if (closest >= 0) {
2958                 Person::players[closest]->whichskin++;
2959                 if (Person::players[closest]->whichskin > 9)
2960                     Person::players[closest]->whichskin = 0;
2961                 if (Person::players[closest]->whichskin > 2 && Person::players[closest]->creature == wolftype)
2962                     Person::players[closest]->whichskin = 0;
2963
2964                 Person::players[closest]->skeleton.drawmodel.textureptr.load(creatureskin[Person::players[closest]->creature][Person::players[closest]->whichskin], 1,
2965                         &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
2966             }
2967
2968             if (Person::players[closest]->numclothes) {
2969                 for (int i = 0; i < Person::players[closest]->numclothes; i++) {
2970                     tintr = Person::players[closest]->clothestintr[i];
2971                     tintg = Person::players[closest]->clothestintg[i];
2972                     tintb = Person::players[closest]->clothestintb[i];
2973                     AddClothes((char *)Person::players[closest]->clothes[i], &Person::players[closest]->skeleton.skinText[0]);
2974                 }
2975                 Person::players[closest]->DoMipmaps();
2976             }
2977         }
2978
2979         if (Input::isKeyPressed(SDL_SCANCODE_O) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
2980             int closest = findClosestPlayer();
2981             if (closest >= 0) {
2982                 if (Person::players[closest]->creature == wolftype) {
2983                     headprop = Person::players[closest]->proportionhead.x / 1.1;
2984                     bodyprop = Person::players[closest]->proportionbody.x / 1.1;
2985                     armprop = Person::players[closest]->proportionarms.x / 1.1;
2986                     legprop = Person::players[closest]->proportionlegs.x / 1.1;
2987                 }
2988
2989                 if (Person::players[closest]->creature == rabbittype) {
2990                     headprop = Person::players[closest]->proportionhead.x / 1.2;
2991                     bodyprop = Person::players[closest]->proportionbody.x / 1.05;
2992                     armprop = Person::players[closest]->proportionarms.x / 1.00;
2993                     legprop = Person::players[closest]->proportionlegs.x / 1.1;
2994                 }
2995
2996
2997                 if (Person::players[closest]->creature == rabbittype) {
2998                     Person::players[closest]->skeleton.id = closest;
2999                     Person::players[closest]->skeleton.Load((char *)":Data:Skeleton:Basic Figure Wolf", (char *)":Data:Skeleton:Basic Figure Wolf Low", (char *)":Data:Skeleton:Rabbitbelt", (char *)":Data:Models:Wolf.solid", (char *)":Data:Models:Wolf2.solid", (char *)":Data:Models:Wolf3.solid", (char *)":Data:Models:Wolf4.solid", (char *)":Data:Models:Wolf5.solid", (char *)":Data:Models:Wolf6.solid", (char *)":Data:Models:Wolf7.solid", (char *)":Data:Models:Wolflow.solid", (char *)":Data:Models:Belt.solid", 0);
3000                     Person::players[closest]->skeleton.drawmodel.textureptr.load(":Data:Textures:Wolf.jpg", 1, &Person::players[closest]->skeleton.skinText[closest], &Person::players[closest]->skeleton.skinsize);
3001                     Person::players[closest]->whichskin = 0;
3002                     Person::players[closest]->creature = wolftype;
3003
3004                     Person::players[closest]->proportionhead = 1.1;
3005                     Person::players[closest]->proportionbody = 1.1;
3006                     Person::players[closest]->proportionarms = 1.1;
3007                     Person::players[closest]->proportionlegs = 1.1;
3008                     Person::players[closest]->proportionlegs.y = 1.1;
3009                     Person::players[closest]->scale = .23 * 5 * Person::players[0]->scale;
3010
3011                     Person::players[closest]->damagetolerance = 300;
3012                 } else {
3013                     Person::players[closest]->skeleton.id = closest;
3014                     Person::players[closest]->skeleton.Load((char *)":Data:Skeleton:Basic Figure", (char *)":Data:Skeleton:Basic Figurelow", (char *)":Data:Skeleton:Rabbitbelt", (char *)":Data:Models:Body.solid", (char *)":Data:Models:Body2.solid", (char *)":Data:Models:Body3.solid", (char *)":Data:Models:Body4.solid", (char *)":Data:Models:Body5.solid", (char *)":Data:Models:Body6.solid", (char *)":Data:Models:Body7.solid", (char *)":Data:Models:Bodylow.solid", (char *)":Data:Models:Belt.solid", 1);
3015                     Person::players[closest]->skeleton.drawmodel.textureptr.load(":Data:Textures:Fur3.jpg", 1, &Person::players[closest]->skeleton.skinText[0], &Person::players[closest]->skeleton.skinsize);
3016                     Person::players[closest]->whichskin = 0;
3017                     Person::players[closest]->creature = rabbittype;
3018
3019                     Person::players[closest]->proportionhead = 1.2;
3020                     Person::players[closest]->proportionbody = 1.05;
3021                     Person::players[closest]->proportionarms = 1.00;
3022                     Person::players[closest]->proportionlegs = 1.1;
3023                     Person::players[closest]->proportionlegs.y = 1.05;
3024                     Person::players[closest]->scale = .2 * 5 * Person::players[0]->scale;
3025
3026                     Person::players[closest]->damagetolerance = 200;
3027                 }
3028
3029                 if (Person::players[closest]->creature == wolftype) {
3030                     Person::players[closest]->proportionhead = 1.1 * headprop;
3031                     Person::players[closest]->proportionbody = 1.1 * bodyprop;
3032                     Person::players[closest]->proportionarms = 1.1 * armprop;
3033                     Person::players[closest]->proportionlegs = 1.1 * legprop;
3034                 }
3035
3036                 if (Person::players[closest]->creature == rabbittype) {
3037                     Person::players[closest]->proportionhead = 1.2 * headprop;
3038                     Person::players[closest]->proportionbody = 1.05 * bodyprop;
3039                     Person::players[closest]->proportionarms = 1.00 * armprop;
3040                     Person::players[closest]->proportionlegs = 1.1 * legprop;
3041                     Person::players[closest]->proportionlegs.y = 1.05 * legprop;
3042                 }
3043
3044             }
3045         }
3046
3047         if (Input::isKeyPressed(SDL_SCANCODE_B) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3048             slomo = 1 - slomo;
3049             slomodelay = 1000;
3050         }
3051
3052
3053         if (((Input::isKeyPressed(SDL_SCANCODE_I) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
3054             int closest = -1;
3055             float closestdist = std::numeric_limits<float>::max();
3056
3057             for (unsigned i = 1; i < Person::players.size(); i++) {
3058                 float distance = distsq(&Person::players[i]->coords, &Person::players[0]->coords);
3059                 if (!Person::players[i]->headless)
3060                     if (distance < closestdist) {
3061                         closestdist = distance;
3062                         closest = i;
3063                     }
3064             }
3065
3066             XYZ flatfacing2, flatvelocity2;
3067             XYZ blah;
3068             if (closest != -1 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
3069                 blah = Person::players[closest]->coords;
3070                 XYZ headspurtdirection;
3071                 //int i = Person::players[closest]->skeleton.jointlabels[head];
3072                 Joint& headjoint = Person::players[closest]->joint(head);
3073                 for (int k = 0; k < Person::players[closest]->skeleton.num_joints; k++) {
3074                     if (!Person::players[closest]->skeleton.free)
3075                         flatvelocity2 = Person::players[closest]->velocity;
3076                     if (Person::players[closest]->skeleton.free)
3077                         flatvelocity2 = headjoint.velocity;
3078                     if (!Person::players[closest]->skeleton.free)
3079                         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;
3080                     if (Person::players[closest]->skeleton.free)
3081                         flatfacing2 = headjoint.position * Person::players[closest]->scale + Person::players[closest]->coords;
3082                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
3083                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
3084                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
3085                     headspurtdirection = headjoint.position - Person::players[closest]->jointPos(neck);
3086                     Normalise(&headspurtdirection);
3087                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, .6, 1);
3088                     flatvelocity2 += headspurtdirection * 8;
3089                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 / 2, 1, 1, 1, .16, 1);
3090                 }
3091                 Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
3092
3093                 emit_sound_at(splattersound, blah);
3094                 emit_sound_at(breaksound2, blah, 100.);
3095
3096                 if (Person::players[closest]->skeleton.free == 2)
3097                     Person::players[closest]->skeleton.free = 0;
3098                 Person::players[closest]->RagDoll(0);
3099                 Person::players[closest]->dead = 2;
3100                 Person::players[closest]->headless = 1;
3101                 Person::players[closest]->DoBloodBig(3, 165);
3102
3103                 camerashake += .3;
3104             }
3105         }
3106
3107         if (((Input::isKeyPressed(SDL_SCANCODE_I) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)))) {
3108             int closest = findClosestPlayer();
3109             XYZ flatfacing2, flatvelocity2;
3110             XYZ blah;
3111             if (closest >= 0 && distsq(&Person::players[closest]->coords, &Person::players[0]->coords) < 144) {
3112                 blah = Person::players[closest]->coords;
3113                 emit_sound_at(splattersound, blah);
3114                 emit_sound_at(breaksound2, blah);
3115
3116                 for (int i = 0; i < Person::players[closest]->skeleton.num_joints; i++) {
3117                     if (!Person::players[closest]->skeleton.free)
3118                         flatvelocity2 = Person::players[closest]->velocity;
3119                     if (Person::players[closest]->skeleton.free)
3120                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
3121                     if (!Person::players[closest]->skeleton.free)
3122                         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;
3123                     if (Person::players[closest]->skeleton.free)
3124                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
3125                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
3126                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
3127                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
3128                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
3129                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .3, 1);
3130                     Sprite::MakeSprite(cloudsprite, flatfacing2, flatvelocity2 * 0, .6, 0, 0, 1, .5);
3131                 }
3132
3133                 for (int i = 0; i < Person::players[closest]->skeleton.num_joints; i++) {
3134                     if (!Person::players[closest]->skeleton.free)
3135                         flatvelocity2 = Person::players[closest]->velocity;
3136                     if (Person::players[closest]->skeleton.free)
3137                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
3138                     if (!Person::players[closest]->skeleton.free)
3139                         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;
3140                     if (Person::players[closest]->skeleton.free)
3141                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
3142                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
3143                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
3144                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
3145                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2, 1, 1, 1, 3, 1);
3146                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2, 1, 1, 1, .4, 1);
3147                 }
3148
3149                 for (int i = 0; i < Person::players[closest]->skeleton.num_joints; i++) {
3150                     if (!Person::players[closest]->skeleton.free)
3151                         flatvelocity2 = Person::players[closest]->velocity;
3152                     if (Person::players[closest]->skeleton.free)
3153                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
3154                     if (!Person::players[closest]->skeleton.free)
3155                         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;
3156                     if (Person::players[closest]->skeleton.free)
3157                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
3158                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
3159                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
3160                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
3161                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, 3, 1);
3162                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, .4, 1);
3163                 }
3164
3165                 for (int i = 0; i < Person::players[closest]->skeleton.num_joints; i++) {
3166                     if (!Person::players[closest]->skeleton.free)
3167                         flatvelocity2 = Person::players[closest]->velocity;
3168                     if (Person::players[closest]->skeleton.free)
3169                         flatvelocity2 = Person::players[closest]->skeleton.joints[i].velocity;
3170                     if (!Person::players[closest]->skeleton.free)
3171                         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;
3172                     if (Person::players[closest]->skeleton.free)
3173                         flatfacing2 = Person::players[closest]->skeleton.joints[i].position * Person::players[closest]->scale + Person::players[closest]->coords;
3174                     flatvelocity2.x += (float)(abs(Random() % 100) - 50) / 10;
3175                     flatvelocity2.y += (float)(abs(Random() % 100) - 50) / 10;
3176                     flatvelocity2.z += (float)(abs(Random() % 100) - 50) / 10;
3177                     Sprite::MakeSprite(bloodflamesprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, 3, 1);
3178                     Sprite::MakeSprite(bloodsprite, flatfacing2, flatvelocity2 * 2, 1, 1, 1, .4, 1);
3179                 }
3180
3181                 XYZ temppos;
3182                 for (unsigned j = 0; j < Person::players.size(); j++) {
3183                     if (int(j) != closest) {
3184                         if (distsq(&Person::players[j]->coords, &Person::players[closest]->coords) < 25) {
3185                             Person::players[j]->DoDamage((25 - distsq(&Person::players[j]->coords, &Person::players[closest]->coords)) * 60);
3186                             if (Person::players[j]->skeleton.free == 2)
3187                                 Person::players[j]->skeleton.free = 1;
3188                             Person::players[j]->skeleton.longdead = 0;
3189                             Person::players[j]->RagDoll(0);
3190                             for (int i = 0; i < Person::players[j]->skeleton.num_joints; i++) {
3191                                 temppos = Person::players[j]->skeleton.joints[i].position + Person::players[j]->coords;
3192                                 if (distsq(&temppos, &Person::players[closest]->coords) < 25) {
3193                                     flatvelocity2 = temppos - Person::players[closest]->coords;
3194                                     Normalise(&flatvelocity2);
3195                                     Person::players[j]->skeleton.joints[i].velocity += flatvelocity2 * ((20 - distsq(&temppos, &Person::players[closest]->coords)) * 20);
3196                                 }
3197                             }
3198                         }
3199                     }
3200                 }
3201
3202                 Person::players[closest]->DoDamage(10000);
3203                 Person::players[closest]->RagDoll(0);
3204                 Person::players[closest]->dead = 2;
3205                 Person::players[closest]->coords = 20;
3206                 Person::players[closest]->skeleton.free = 2;
3207
3208                 camerashake += .6;
3209
3210             }
3211         }
3212
3213         if (Input::isKeyPressed(SDL_SCANCODE_F)) {
3214             Person::players[0]->onfire = 1 - Person::players[0]->onfire;
3215             if (Person::players[0]->onfire) {
3216                 Person::players[0]->CatchFire();
3217             }
3218             if (!Person::players[0]->onfire) {
3219                 emit_sound_at(fireendsound, Person::players[0]->coords);
3220                 pause_sound(stream_firesound);
3221             }
3222         }
3223
3224         if (Input::isKeyPressed(SDL_SCANCODE_N) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3225             //if(!Person::players[0]->skeleton.free)Person::players[0]->damage+=500;
3226             Person::players[0]->RagDoll(0);
3227             //Person::players[0]->spurt=1;
3228             //Person::players[0]->DoDamage(1000);
3229
3230             emit_sound_at(whooshsound, Person::players[0]->coords, 128.);
3231         }
3232
3233         if (Input::isKeyPressed(SDL_SCANCODE_N) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3234             for (int i = 0; i < objects.numobjects; i++) {
3235                 if (objects.type[i] == treeleavestype) {
3236                     objects.scale[i] *= .9;
3237                 }
3238             }
3239         }
3240
3241         if (Input::isKeyPressed(SDL_SCANCODE_M) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3242             editorenabled = 1 - editorenabled;
3243             if (editorenabled) {
3244                 Person::players[0]->damagetolerance = 100000;
3245             } else {
3246                 Person::players[0]->damagetolerance = 200;
3247             }
3248             Person::players[0]->damage = 0; // these lines were in both if and else, but I think they would better fit in the if
3249             Person::players[0]->permanentdamage = 0;
3250             Person::players[0]->superpermanentdamage = 0;
3251             Person::players[0]->bloodloss = 0;
3252             Person::players[0]->deathbleeding = 0;
3253         }
3254
3255         //skip level
3256         if (whichlevel != -2 && Input::isKeyPressed(SDL_SCANCODE_K) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !editorenabled) {
3257             targetlevel++;
3258             if (targetlevel > numchallengelevels - 1)
3259                 targetlevel = 0;
3260             loading = 1;
3261             leveltime = 5;
3262         }
3263
3264         if (editorenabled) {
3265             if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3266                 int closest = findClosestPlayer();
3267                 if (closest >= 0) {
3268                     Person::players.erase(Person::players.begin()+closest);
3269                 }
3270             }
3271
3272             if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3273                 int closest = findClosestObject();
3274                 if (closest >= 0)
3275                     objects.position[closest].y -= 500;
3276             }
3277
3278             if (Input::isKeyPressed(SDL_SCANCODE_M) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3279                 //drawmode++;
3280                 //if(drawmode>2)drawmode=0;
3281                 if (objects.numobjects < max_objects - 1) {
3282                     XYZ boxcoords;
3283                     boxcoords.x = Person::players[0]->coords.x;
3284                     boxcoords.z = Person::players[0]->coords.z;
3285                     boxcoords.y = Person::players[0]->coords.y - 3;
3286                     if (editortype == bushtype)
3287                         boxcoords.y = Person::players[0]->coords.y - .5;
3288                     if (editortype == firetype)
3289                         boxcoords.y = Person::players[0]->coords.y - .5;
3290                     //objects.MakeObject(abs(Random()%3),boxcoords,Random()%360);
3291                     float temprotat, temprotat2;
3292                     temprotat = editoryaw;
3293                     temprotat2 = editorpitch;
3294                     if (temprotat < 0 || editortype == bushtype)
3295                         temprotat = Random() % 360;
3296                     if (temprotat2 < 0)
3297                         temprotat2 = Random() % 360;
3298
3299                     objects.MakeObject(editortype, boxcoords, (int)temprotat - ((int)temprotat) % 30, (int)temprotat2, editorsize);
3300                     if (editortype == treetrunktype)
3301                         objects.MakeObject(treeleavestype, boxcoords, Random() % 360 * (temprotat2 < 2) + (int)editoryaw - ((int)editoryaw) % 30, editorpitch, editorsize);
3302                 }
3303             }
3304
3305             if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3306                 Person::players.push_back(shared_ptr<Person>(new Person()));
3307
3308                 Person::players.back()->scale = .2 * 5 * Person::players[0]->scale;
3309                 Person::players.back()->creature = rabbittype;
3310                 Person::players.back()->howactive = editoractive;
3311                 Person::players.back()->skeleton.id = Person::players.size()-1;
3312                 Person::players.back()->skeleton.Load((char *)":Data:Skeleton:Basic Figure", (char *)":Data:Skeleton:Basic Figurelow", (char *)":Data:Skeleton:Rabbitbelt", (char *)":Data:Models:Body.solid", (char *)":Data:Models:Body2.solid", (char *)":Data:Models:Body3.solid", (char *)":Data:Models:Body4.solid", (char *)":Data:Models:Body5.solid", (char *)":Data:Models:Body6.solid", (char *)":Data:Models:Body7.solid", (char *)":Data:Models:Bodylow.solid", (char *)":Data:Models:Belt.solid", 1);
3313
3314                 int k = abs(Random() % 2) + 1;
3315                 if (k == 0) {
3316                     Person::players.back()->skeleton.drawmodel.textureptr.load(":Data:Textures:Fur3.jpg", 1, &Person::players.back()->skeleton.skinText[0], &Person::players.back()->skeleton.skinsize);
3317                     Person::players.back()->whichskin = 0;
3318                 } else if (k == 1) {
3319                     Person::players.back()->skeleton.drawmodel.textureptr.load(":Data:Textures:Fur.jpg", 1, &Person::players.back()->skeleton.skinText[0], &Person::players.back()->skeleton.skinsize);
3320                     Person::players.back()->whichskin = 1;
3321                 } else {
3322                     Person::players.back()->skeleton.drawmodel.textureptr.load(":Data:Textures:Fur2.jpg", 1, &Person::players.back()->skeleton.skinText[0], &Person::players.back()->skeleton.skinsize);
3323                     Person::players.back()->whichskin = 2;
3324                 }
3325
3326                 Person::players.back()->skeleton.drawmodelclothes.textureptr.load(":Data:Textures:Belt.png", 1, 1);
3327                 Person::players.back()->power = 1;
3328                 Person::players.back()->speedmult = 1;
3329                 Person::players.back()->animCurrent = bounceidleanim;
3330                 Person::players.back()->animTarget = bounceidleanim;
3331                 Person::players.back()->frameCurrent = 0;
3332                 Person::players.back()->frameTarget = 1;
3333                 Person::players.back()->target = 0;
3334                 Person::players.back()->bled = 0;
3335                 Person::players.back()->speed = 1 + (float)(Random() % 100) / 1000;
3336
3337                 Person::players.back()->targetyaw = Person::players[0]->targetyaw;
3338                 Person::players.back()->yaw = Person::players[0]->yaw;
3339
3340                 Person::players.back()->velocity = 0;
3341                 Person::players.back()->coords = Person::players[0]->coords;
3342                 Person::players.back()->oldcoords = Person::players.back()->coords;
3343                 Person::players.back()->realoldcoords = Person::players.back()->coords;
3344
3345                 Person::players.back()->id = Person::players.size()-1;
3346                 Person::players.back()->updatedelay = 0;
3347                 Person::players.back()->normalsupdatedelay = 0;
3348
3349                 Person::players.back()->aitype = passivetype;
3350
3351                 if (Person::players[0]->creature == wolftype) {
3352                     headprop = Person::players[0]->proportionhead.x / 1.1;
3353                     bodyprop = Person::players[0]->proportionbody.x / 1.1;
3354                     armprop = Person::players[0]->proportionarms.x / 1.1;
3355                     legprop = Person::players[0]->proportionlegs.x / 1.1;
3356                 }
3357
3358                 if (Person::players[0]->creature == rabbittype) {
3359                     headprop = Person::players[0]->proportionhead.x / 1.2;
3360                     bodyprop = Person::players[0]->proportionbody.x / 1.05;
3361                     armprop = Person::players[0]->proportionarms.x / 1.00;
3362                     legprop = Person::players[0]->proportionlegs.x / 1.1;
3363                 }
3364
3365                 if (Person::players.back()->creature == wolftype) {
3366                     Person::players.back()->proportionhead = 1.1 * headprop;
3367                     Person::players.back()->proportionbody = 1.1 * bodyprop;
3368                     Person::players.back()->proportionarms = 1.1 * armprop;
3369                     Person::players.back()->proportionlegs = 1.1 * legprop;
3370                 }
3371
3372                 if (Person::players.back()->creature == rabbittype) {
3373                     Person::players.back()->proportionhead = 1.2 * headprop;
3374                     Person::players.back()->proportionbody = 1.05 * bodyprop;
3375                     Person::players.back()->proportionarms = 1.00 * armprop;
3376                     Person::players.back()->proportionlegs = 1.1 * legprop;
3377                     Person::players.back()->proportionlegs.y = 1.05 * legprop;
3378                 }
3379
3380                 Person::players.back()->headless = 0;
3381                 Person::players.back()->onfire = 0;
3382
3383                 if (cellophane) {
3384                     Person::players.back()->proportionhead.z = 0;
3385                     Person::players.back()->proportionbody.z = 0;
3386                     Person::players.back()->proportionarms.z = 0;
3387                     Person::players.back()->proportionlegs.z = 0;
3388                 }
3389
3390                 Person::players.back()->tempanimation.Load((char *)"Tempanim", 0, 0);
3391
3392                 Person::players.back()->damagetolerance = 200;
3393
3394                 Person::players.back()->protectionhead = Person::players[0]->protectionhead;
3395                 Person::players.back()->protectionhigh = Person::players[0]->protectionhigh;
3396                 Person::players.back()->protectionlow = Person::players[0]->protectionlow;
3397                 Person::players.back()->armorhead = Person::players[0]->armorhead;
3398                 Person::players.back()->armorhigh = Person::players[0]->armorhigh;
3399                 Person::players.back()->armorlow = Person::players[0]->armorlow;
3400                 Person::players.back()->metalhead = Person::players[0]->metalhead;
3401                 Person::players.back()->metalhigh = Person::players[0]->metalhigh;
3402                 Person::players.back()->metallow = Person::players[0]->metallow;
3403
3404                 Person::players.back()->immobile = Person::players[0]->immobile;
3405
3406                 Person::players.back()->numclothes = Person::players[0]->numclothes;
3407                 if (Person::players.back()->numclothes)
3408                     for (int i = 0; i < Person::players.back()->numclothes; i++) {
3409                         strcpy(Person::players.back()->clothes[i], Person::players[0]->clothes[i]);
3410                         Person::players.back()->clothestintr[i] = Person::players[0]->clothestintr[i];
3411                         Person::players.back()->clothestintg[i] = Person::players[0]->clothestintg[i];
3412                         Person::players.back()->clothestintb[i] = Person::players[0]->clothestintb[i];
3413                         tintr = Person::players.back()->clothestintr[i];
3414                         tintg = Person::players.back()->clothestintg[i];
3415                         tintb = Person::players.back()->clothestintb[i];
3416                         AddClothes((char *)Person::players.back()->clothes[i], &Person::players.back()->skeleton.skinText[0]);
3417                     }
3418                 if (Person::players.back()->numclothes) {
3419                     Person::players.back()->DoMipmaps();
3420                 }
3421
3422                 Person::players.back()->power = Person::players[0]->power;
3423                 Person::players.back()->speedmult = Person::players[0]->speedmult;
3424
3425                 Person::players.back()->damage = 0;
3426                 Person::players.back()->permanentdamage = 0;
3427                 Person::players.back()->superpermanentdamage = 0;
3428                 Person::players.back()->deathbleeding = 0;
3429                 Person::players.back()->bleeding = 0;
3430                 Person::players.back()->numwaypoints = 0;
3431                 Person::players.back()->waypoint = 0;
3432                 Person::players.back()->jumppath = 0;
3433                 Person::players.back()->weaponstuck = -1;
3434                 Person::players.back()->weaponactive = -1;
3435                 Person::players.back()->num_weapons = 0;
3436                 Person::players.back()->bloodloss = 0;
3437                 Person::players.back()->dead = 0;
3438
3439                 Person::players.back()->loaded = 1;
3440             }
3441
3442             if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3443                 if (Person::players.back()->numwaypoints < 90) {
3444                     Person::players.back()->waypoints[Person::players.back()->numwaypoints] = Person::players[0]->coords;
3445                     Person::players.back()->waypointtype[Person::players.back()->numwaypoints] = editorpathtype;
3446                     Person::players.back()->numwaypoints++;
3447                 }
3448             }
3449
3450             if (Input::isKeyPressed(SDL_SCANCODE_P) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3451                 if (numpathpoints < 30) {
3452                     bool connected, alreadyconnected;
3453                     connected = 0;
3454                     if (numpathpoints > 1)
3455                         for (int i = 0; i < numpathpoints; i++) {
3456                             if (distsq(&pathpoint[i], &Person::players[0]->coords) < .5 && i != pathpointselected && !connected) {
3457                                 alreadyconnected = 0;
3458                                 for (int j = 0; j < numpathpointconnect[pathpointselected]; j++) {
3459                                     if (pathpointconnect[pathpointselected][j] == i)
3460                                         alreadyconnected = 1;
3461                                 }
3462                                 if (!alreadyconnected) {
3463                                     numpathpointconnect[pathpointselected]++;
3464                                     connected = 1;
3465                                     pathpointconnect[pathpointselected][numpathpointconnect[pathpointselected] - 1] = i;
3466                                 }
3467                             }
3468                         }
3469                     if (!connected) {
3470                         numpathpoints++;
3471                         pathpoint[numpathpoints - 1] = Person::players[0]->coords;
3472                         numpathpointconnect[numpathpoints - 1] = 0;
3473                         if (numpathpoints > 1 && pathpointselected != -1) {
3474                             numpathpointconnect[pathpointselected]++;
3475                             pathpointconnect[pathpointselected][numpathpointconnect[pathpointselected] - 1] = numpathpoints - 1;
3476                         }
3477                         pathpointselected = numpathpoints - 1;
3478                     }
3479                 }
3480             }
3481
3482             if (Input::isKeyPressed(SDL_SCANCODE_PERIOD)) {
3483                 pathpointselected++;
3484                 if (pathpointselected >= numpathpoints)
3485                     pathpointselected = -1;
3486             }
3487             if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3488                 pathpointselected--;
3489                 if (pathpointselected <= -2)
3490                     pathpointselected = numpathpoints - 1;
3491             }
3492             if (Input::isKeyPressed(SDL_SCANCODE_COMMA) && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3493                 if (pathpointselected != -1) {
3494                     numpathpoints--;
3495                     pathpoint[pathpointselected] = pathpoint[numpathpoints];
3496                     numpathpointconnect[pathpointselected] = numpathpointconnect[numpathpoints];
3497                     for (int i = 0; i < numpathpointconnect[pathpointselected]; i++) {
3498                         pathpointconnect[pathpointselected][i] = pathpointconnect[numpathpoints][i];
3499                     }
3500                     for (int i = 0; i < numpathpoints; i++) {
3501                         for (int j = 0; j < numpathpointconnect[i]; j++) {
3502                             if (pathpointconnect[i][j] == pathpointselected) {
3503                                 pathpointconnect[i][j] = pathpointconnect[i][numpathpointconnect[i] - 1];
3504                                 numpathpointconnect[i]--;
3505                             }
3506                             if (pathpointconnect[i][j] == numpathpoints) {
3507                                 pathpointconnect[i][j] = pathpointselected;
3508                             }
3509                         }
3510                     }
3511                     pathpointselected = numpathpoints - 1;
3512                 }
3513             }
3514
3515             if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3516                 editortype--;
3517                 if (editortype == treeleavestype || editortype == 10)
3518                     editortype--;
3519                 if (editortype < 0)
3520                     editortype = firetype;
3521             }
3522
3523             if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3524                 editortype++;
3525                 if (editortype == treeleavestype || editortype == 10)
3526                     editortype++;
3527                 if (editortype > firetype)
3528                     editortype = 0;
3529             }
3530
3531             if (Input::isKeyDown(SDL_SCANCODE_LEFT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3532                 editoryaw -= multiplier * 100;
3533                 if (editoryaw < -.01)
3534                     editoryaw = -.01;
3535             }
3536
3537             if (Input::isKeyDown(SDL_SCANCODE_RIGHT) && !Input::isKeyDown(SDL_SCANCODE_LSHIFT) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3538                 editoryaw += multiplier * 100;
3539             }
3540
3541             if (Input::isKeyDown(SDL_SCANCODE_UP) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3542                 editorsize += multiplier;
3543             }
3544
3545             if (Input::isKeyDown(SDL_SCANCODE_DOWN) && !Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3546                 editorsize -= multiplier;
3547                 if (editorsize < .1)
3548                     editorsize = .1;
3549             }
3550
3551
3552             if (Input::isKeyPressed(SDL_SCANCODE_LEFT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3553                 mapradius -= multiplier * 10;
3554             }
3555
3556             if (Input::isKeyPressed(SDL_SCANCODE_RIGHT) && Input::isKeyDown(SDL_SCANCODE_LSHIFT) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3557                 mapradius += multiplier * 10;
3558             }
3559             if (Input::isKeyDown(SDL_SCANCODE_UP) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3560                 editorpitch += multiplier * 100;
3561             }
3562
3563             if (Input::isKeyDown(SDL_SCANCODE_DOWN) && Input::isKeyDown(SDL_SCANCODE_LCTRL)) {
3564                 editorpitch -= multiplier * 100;
3565                 if (editorpitch < -.01)
3566                     editorpitch = -.01;
3567             }
3568             if (Input::isKeyPressed(SDL_SCANCODE_DELETE) && objects.numobjects && Input::isKeyDown(SDL_SCANCODE_LSHIFT)) {
3569                 int closest = findClosestObject();
3570                 if (closest >= 0)
3571                     objects.DeleteObject(closest);
3572             }
3573         }
3574     }
3575 }
3576
3577 void doJumpReversals()
3578 {
3579     for (unsigned k = 0; k < Person::players.size(); k++)
3580         for (unsigned i = k; i < Person::players.size(); i++) {
3581             if (i == k)
3582                 continue;
3583             if (     Person::players[k]->skeleton.free == 0 &&
3584                      Person::players[i]->skeleton.oldfree == 0 &&
3585                      (Person::players[i]->animTarget == jumpupanim ||
3586                       Person::players[k]->animTarget == jumpupanim) &&
3587                      (Person::players[i]->aitype == playercontrolled ||
3588                       Person::players[k]->aitype == playercontrolled) &&
3589                      ((Person::players[i]->aitype == attacktypecutoff && Person::players[i]->stunned <= 0) ||
3590                       (Person::players[k]->aitype == attacktypecutoff && Person::players[k]->stunned <= 0))) {
3591                 if (     distsq(&Person::players[i]->coords, &Person::players[k]->coords) < 10 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5) &&
3592                          distsqflat(&Person::players[i]->coords, &Person::players[k]->coords) < 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
3593                     //TODO: refactor two huge similar ifs
3594                     if (Person::players[i]->animTarget == jumpupanim &&
3595                             Person::players[k]->animTarget != getupfrombackanim &&
3596                             Person::players[k]->animTarget != getupfromfrontanim &&
3597                             animation[Person::players[k]->animTarget].height == middleheight &&
3598                             normaldotproduct(Person::players[i]->velocity, Person::players[k]->coords - Person::players[i]->coords) < 0 &&
3599                             ((Person::players[k]->aitype == playercontrolled && Person::players[k]->attackkeydown) ||
3600                              Person::players[k]->aitype != playercontrolled)) {
3601                         Person::players[i]->victim = Person::players[k];
3602                         Person::players[i]->velocity = 0;
3603                         Person::players[i]->animCurrent = jumpreversedanim;
3604                         Person::players[i]->animTarget = jumpreversedanim;
3605                         Person::players[i]->frameCurrent = 0;
3606                         Person::players[i]->frameTarget = 1;
3607                         Person::players[i]->targettilt2 = 0;
3608                         Person::players[k]->victim = Person::players[i];
3609                         Person::players[k]->velocity = 0;
3610                         Person::players[k]->animCurrent = jumpreversalanim;
3611                         Person::players[k]->animTarget = jumpreversalanim;
3612                         Person::players[k]->frameCurrent = 0;
3613                         Person::players[k]->frameTarget = 1;
3614                         Person::players[k]->targettilt2 = 0;
3615                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 1) {
3616                             Person::players[i]->animCurrent = rabbitkickreversedanim;
3617                             Person::players[i]->animTarget = rabbitkickreversedanim;
3618                             Person::players[i]->frameCurrent = 1;
3619                             Person::players[i]->frameTarget = 2;
3620                             Person::players[k]->animCurrent = rabbitkickreversalanim;
3621                             Person::players[k]->animTarget = rabbitkickreversalanim;
3622                             Person::players[k]->frameCurrent = 1;
3623                             Person::players[k]->frameTarget = 2;
3624                         }
3625                         Person::players[i]->target = 0;
3626                         Person::players[k]->oldcoords = Person::players[k]->coords;
3627                         Person::players[i]->coords = Person::players[k]->coords;
3628                         Person::players[k]->targetyaw = Person::players[i]->targetyaw;
3629                         Person::players[k]->yaw = Person::players[i]->targetyaw;
3630                         if (Person::players[k]->aitype == attacktypecutoff)
3631                             Person::players[k]->stunned = .5;
3632                     }
3633                     if (Person::players[k]->animTarget == jumpupanim &&
3634                             Person::players[i]->animTarget != getupfrombackanim &&
3635                             Person::players[i]->animTarget != getupfromfrontanim &&
3636                             animation[Person::players[i]->animTarget].height == middleheight &&
3637                             normaldotproduct(Person::players[k]->velocity, Person::players[i]->coords - Person::players[k]->coords) < 0 &&
3638                             ((Person::players[i]->aitype == playercontrolled && Person::players[i]->attackkeydown) ||
3639                              Person::players[i]->aitype != playercontrolled)) {
3640                         Person::players[k]->victim = Person::players[i];
3641                         Person::players[k]->velocity = 0;
3642                         Person::players[k]->animCurrent = jumpreversedanim;
3643                         Person::players[k]->animTarget = jumpreversedanim;
3644                         Person::players[k]->frameCurrent = 0;
3645                         Person::players[k]->frameTarget = 1;
3646                         Person::players[k]->targettilt2 = 0;
3647                         Person::players[i]->victim = Person::players[k];
3648                         Person::players[i]->velocity = 0;
3649                         Person::players[i]->animCurrent = jumpreversalanim;
3650                         Person::players[i]->animTarget = jumpreversalanim;
3651                         Person::players[i]->frameCurrent = 0;
3652                         Person::players[i]->frameTarget = 1;
3653                         Person::players[i]->targettilt2 = 0;
3654                         if (Person::players[k]->coords.y < Person::players[i]->coords.y + 1) {
3655                             Person::players[k]->animTarget = rabbitkickreversedanim;
3656                             Person::players[k]->animCurrent = rabbitkickreversedanim;
3657                             Person::players[i]->animCurrent = rabbitkickreversalanim;
3658                             Person::players[i]->animTarget = rabbitkickreversalanim;
3659                             Person::players[k]->frameCurrent = 1;
3660                             Person::players[k]->frameTarget = 2;
3661                             Person::players[i]->frameCurrent = 1;
3662                             Person::players[i]->frameTarget = 2;
3663                         }
3664                         Person::players[k]->target = 0;
3665                         Person::players[i]->oldcoords = Person::players[i]->coords;
3666                         Person::players[k]->coords = Person::players[i]->coords;
3667                         Person::players[i]->targetyaw = Person::players[k]->targetyaw;
3668                         Person::players[i]->yaw = Person::players[k]->targetyaw;
3669                         if (Person::players[i]->aitype == attacktypecutoff)
3670                             Person::players[i]->stunned = .5;
3671                     }
3672                 }
3673             }
3674         }
3675 }
3676
3677 void doAerialAcrobatics()
3678 {
3679     static XYZ facing, flatfacing;
3680     for (unsigned k = 0; k < Person::players.size(); k++) {
3681         Person::players[k]->turnspeed = 500;
3682
3683         if ((Person::players[k]->isRun() &&
3684                 ((Person::players[k]->targetyaw != rabbitrunninganim &&
3685                   Person::players[k]->targetyaw != wolfrunninganim) ||
3686                  Person::players[k]->frameTarget == 4)) ||
3687                 Person::players[k]->animTarget == removeknifeanim ||
3688                 Person::players[k]->animTarget == crouchremoveknifeanim ||
3689                 Person::players[k]->animTarget == flipanim ||
3690                 Person::players[k]->animTarget == fightsidestep ||
3691                 Person::players[k]->animTarget == walkanim) {
3692             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed);
3693         }
3694
3695
3696         if (Person::players[k]->isStop() ||
3697                 Person::players[k]->isLanding() ||
3698                 Person::players[k]->animTarget == staggerbackhighanim ||
3699                 (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent == sneakanim) ||
3700                 Person::players[k]->animTarget == staggerbackhardanim ||
3701                 Person::players[k]->animTarget == backhandspringanim ||
3702                 Person::players[k]->animTarget == dodgebackanim ||
3703                 Person::players[k]->animTarget == rollanim ||
3704                 (animation[Person::players[k]->animTarget].attack &&
3705                  Person::players[k]->animTarget != rabbitkickanim &&
3706                  (Person::players[k]->animTarget != crouchstabanim || Person::players[k]->hasvictim) &&
3707                  (Person::players[k]->animTarget != swordgroundstabanim || Person::players[k]->hasvictim))) {
3708             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed * 2);
3709         }
3710
3711         if (Person::players[k]->animTarget == sneakanim && Person::players[k]->animCurrent != sneakanim) {
3712             Person::players[k]->yaw = stepTowardf(Person::players[k]->yaw, Person::players[k]->targetyaw, multiplier * Person::players[k]->turnspeed * 4);
3713         }
3714
3715         /*if(Person::players[k]->aitype!=passivetype||(distsq(&Person::players[k]->coords,&viewer)<viewdistance*viewdistance))*/
3716         Person::players[k]->DoStuff();
3717         if (Person::players[k]->immobile && k != 0)
3718             Person::players[k]->coords = Person::players[k]->realoldcoords;
3719
3720         //if player's position has changed (?)
3721         if (distsq(&Person::players[k]->coords, &Person::players[k]->realoldcoords) > 0 &&
3722                 !Person::players[k]->skeleton.free &&
3723                 Person::players[k]->animTarget != climbanim &&
3724                 Person::players[k]->animTarget != hanganim) {
3725             XYZ lowpoint, lowpointtarget, lowpoint2, lowpointtarget2, lowpoint3, lowpointtarget3, lowpoint4, lowpointtarget4, lowpoint5, lowpointtarget5, lowpoint6, lowpointtarget6, lowpoint7, lowpointtarget7, colpoint, colpoint2;
3726             int whichhit;
3727             bool tempcollide = 0;
3728
3729             if (Person::players[k]->collide < -.3)
3730                 Person::players[k]->collide = -.3;
3731             if (Person::players[k]->collide > 1)
3732                 Person::players[k]->collide = 1;
3733             Person::players[k]->collide -= multiplier * 30;
3734
3735             //clip to terrain
3736             Person::players[k]->coords.y = max(Person::players[k]->coords.y, terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z));
3737
3738             for (int l = 0; l < terrain.patchobjectnum[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz]; l++) {
3739                 int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
3740                 if (objects.type[i] != rocktype ||
3741                         objects.scale[i] > .5 && Person::players[k]->aitype == playercontrolled ||
3742                         objects.position[i].y > Person::players[k]->coords.y) {
3743                     lowpoint = Person::players[k]->coords;
3744                     if (Person::players[k]->animTarget != jumpupanim &&
3745                             Person::players[k]->animTarget != jumpdownanim &&
3746                             !Person::players[k]->isFlip())
3747                         lowpoint.y += 1.25;
3748                     else
3749                         lowpoint.y += 1.3;
3750                     if (     Person::players[k]->coords.y < terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) &&
3751                              Person::players[k]->coords.y > terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z) - .1)
3752                         Person::players[k]->coords.y = terrain.getHeight(Person::players[k]->coords.x, Person::players[k]->coords.z);
3753                     if (Person::players[k]->SphereCheck(&lowpoint, 1.3, &colpoint, &objects.position[i], &objects.yaw[i], &objects.model[i]) != -1) {
3754                         flatfacing = lowpoint - Person::players[k]->coords;
3755                         Person::players[k]->coords = lowpoint;
3756                         Person::players[k]->coords.y -= 1.3;
3757                         Person::players[k]->collide = 1;
3758                         tempcollide = 1;
3759                         //wall jumps
3760                         //TODO: refactor four similar blocks
3761                         if (Person::players[k]->aitype == playercontrolled &&
3762                                 (Person::players[k]->animTarget == jumpupanim ||
3763                                  Person::players[k]->animTarget == jumpdownanim ||
3764                                  Person::players[k]->isFlip()) &&
3765                                 !Person::players[k]->jumptogglekeydown &&
3766                                 Person::players[k]->jumpkeydown) {
3767                             lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, -90, 0) * 1.5;
3768                             XYZ tempcoords1 = lowpoint;
3769                             whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3770                             if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
3771                                 Person::players[k]->setAnimation(walljumpleftanim);
3772                                 emit_sound_at(movewhooshsound, Person::players[k]->coords);
3773                                 if (k == 0)
3774                                     pause_sound(whooshsound);
3775
3776                                 lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3777                                 Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3778                                 if (lowpointtarget.z < 0)
3779                                     Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3780                                 Person::players[k]->targetyaw = Person::players[k]->yaw;
3781                                 Person::players[k]->lowyaw = Person::players[k]->yaw;
3782                                 if (k == 0)
3783                                     numwallflipped++;
3784                             } else {
3785                                 lowpoint = tempcoords1;
3786                                 lowpointtarget = lowpoint + DoRotation(Person::players[k]->facing, 0, 90, 0) * 1.5;
3787                                 whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3788                                 if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
3789                                     Person::players[k]->setAnimation(walljumprightanim);
3790                                     emit_sound_at(movewhooshsound, Person::players[k]->coords);
3791                                     if (k == 0)
3792                                         pause_sound(whooshsound);
3793
3794                                     lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3795                                     Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3796                                     if (lowpointtarget.z < 0)
3797                                         Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3798                                     Person::players[k]->targetyaw = Person::players[k]->yaw;
3799                                     Person::players[k]->lowyaw = Person::players[k]->yaw;
3800                                     if (k == 0)
3801                                         numwallflipped++;
3802                                 } else {
3803                                     lowpoint = tempcoords1;
3804                                     lowpointtarget = lowpoint + Person::players[k]->facing * 2;
3805                                     whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3806                                     if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
3807                                         Person::players[k]->setAnimation(walljumpbackanim);
3808                                         emit_sound_at(movewhooshsound, Person::players[k]->coords);
3809                                         if (k == 0)
3810                                             pause_sound(whooshsound);
3811
3812                                         lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3813                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3814                                         if (lowpointtarget.z < 0)
3815                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3816                                         Person::players[k]->targetyaw = Person::players[k]->yaw;
3817                                         Person::players[k]->lowyaw = Person::players[k]->yaw;
3818                                         if (k == 0)
3819                                             numwallflipped++;
3820                                     } else {
3821                                         lowpoint = tempcoords1;
3822                                         lowpointtarget = lowpoint - Person::players[k]->facing * 2;
3823                                         whichhit = objects.model[i].LineCheck(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3824                                         if (whichhit != -1 && fabs(objects.model[i].facenormals[whichhit].y) < .3) {
3825                                             Person::players[k]->setAnimation(walljumpfrontanim);
3826                                             emit_sound_at(movewhooshsound, Person::players[k]->coords);
3827                                             if (k == 0)
3828                                                 pause_sound(whooshsound);
3829
3830                                             lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3831                                             Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3832                                             if (lowpointtarget.z < 0)
3833                                                 Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3834                                             Person::players[k]->yaw += 180;
3835                                             Person::players[k]->targetyaw = Person::players[k]->yaw;
3836                                             Person::players[k]->lowyaw = Person::players[k]->yaw;
3837                                             if (k == 0)
3838                                                 numwallflipped++;
3839                                         }
3840                                     }
3841                                 }
3842                             }
3843                         }
3844                     }
3845                 } else if (objects.type[i] == rocktype) {
3846                     lowpoint2 = Person::players[k]->coords;
3847                     lowpoint = Person::players[k]->coords;
3848                     lowpoint.y += 2;
3849                     if (objects.model[i].LineCheck(&lowpoint, &lowpoint2, &colpoint, &objects.position[i], &objects.yaw[i]) != -1) {
3850                         Person::players[k]->coords = colpoint;
3851                         Person::players[k]->collide = 1;
3852                         tempcollide = 1;
3853
3854                         if (Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) {
3855                             //flipped into a rock
3856                             if (Person::players[k]->isFlip() && animation[Person::players[k]->animTarget].label[Person::players[k]->frameTarget] == 7)
3857                                 Person::players[k]->RagDoll(0);
3858
3859                             if (Person::players[k]->animTarget == jumpupanim) {
3860                                 Person::players[k]->jumppower = -4;
3861                                 Person::players[k]->animTarget = Person::players[k]->getIdle();
3862                             }
3863                             Person::players[k]->target = 0;
3864                             Person::players[k]->frameTarget = 0;
3865                             Person::players[k]->onterrain = 1;
3866
3867                             if (Person::players[k]->id == 0) {
3868                                 pause_sound(whooshsound);
3869                                 OPENAL_SetVolume(channels[whooshsound], 0);
3870                             }
3871
3872                             //landing
3873                             if ((Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) && !Person::players[k]->wasLanding()) {
3874                                 if (Person::players[k]->isFlip())
3875                                     Person::players[k]->jumppower = -4;
3876                                 Person::players[k]->animTarget = Person::players[k]->getLanding();
3877                                 emit_sound_at(landsound, Person::players[k]->coords, 128.);
3878                                 if (k == 0) {
3879                                     envsound[numenvsounds] = Person::players[k]->coords;
3880                                     envsoundvol[numenvsounds] = 16;
3881                                     envsoundlife[numenvsounds] = .4;
3882                                     numenvsounds++;
3883                                 }
3884
3885                             }
3886                         }
3887                     }
3888                 }
3889             }
3890
3891             if (tempcollide)
3892                 for (int l = 0; l < terrain.patchobjectnum[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz]; l++) {
3893                     int i = terrain.patchobjects[Person::players[k]->whichpatchx][Person::players[k]->whichpatchz][l];
3894                     lowpoint = Person::players[k]->coords;
3895                     lowpoint.y += 1.35;
3896                     if (objects.type[i] != rocktype)
3897                         if (Person::players[k]->SphereCheck(&lowpoint, 1.33, &colpoint, &objects.position[i], &objects.yaw[i], &objects.model[i]) != -1) {
3898                             if (Person::players[k]->animTarget != jumpupanim &&
3899                                     Person::players[k]->animTarget != jumpdownanim &&
3900                                     Person::players[k]->onterrain)
3901                                 Person::players[k]->avoidcollided = 1;
3902                             Person::players[k]->coords = lowpoint;
3903                             Person::players[k]->coords.y -= 1.35;
3904                             Person::players[k]->collide = 1;
3905
3906                             if ((Person::players[k]->grabdelay <= 0 || Person::players[k]->aitype != playercontrolled) &&
3907                                     (Person::players[k]->animCurrent != climbanim &&
3908                                      Person::players[k]->animCurrent != hanganim &&
3909                                      !Person::players[k]->isWallJump() ||
3910                                      Person::players[k]->animTarget == jumpupanim ||
3911                                      Person::players[k]->animTarget == jumpdownanim)) {
3912                                 lowpoint = Person::players[k]->coords;
3913                                 objects.model[i].SphereCheckPossible(&lowpoint, 1.5, &objects.position[i], &objects.yaw[i]);
3914                                 lowpoint = Person::players[k]->coords;
3915                                 lowpoint.y += .05;
3916                                 facing = 0;
3917                                 facing.z = -1;
3918                                 facing = DoRotation(facing, 0, Person::players[k]->targetyaw + 180, 0);
3919                                 lowpointtarget = lowpoint + facing * 1.4;
3920                                 whichhit = objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3921                                 if (whichhit != -1) {
3922                                     lowpoint = Person::players[k]->coords;
3923                                     lowpoint.y += .1;
3924                                     lowpointtarget = lowpoint + facing * 1.4;
3925                                     lowpoint2 = lowpoint;
3926                                     lowpointtarget2 = lowpointtarget;
3927                                     lowpoint3 = lowpoint;
3928                                     lowpointtarget3 = lowpointtarget;
3929                                     lowpoint4 = lowpoint;
3930                                     lowpointtarget4 = lowpointtarget;
3931                                     lowpoint5 = lowpoint;
3932                                     lowpointtarget5 = lowpointtarget;
3933                                     lowpoint6 = lowpoint;
3934                                     lowpointtarget6 = lowpointtarget;
3935                                     lowpoint7 = lowpoint;
3936                                     lowpointtarget7 = lowpoint;
3937                                     lowpoint2.x += .1;
3938                                     lowpointtarget2.x += .1;
3939                                     lowpoint3.z += .1;
3940                                     lowpointtarget3.z += .1;
3941                                     lowpoint4.x -= .1;
3942                                     lowpointtarget4.x -= .1;
3943                                     lowpoint5.z -= .1;
3944                                     lowpointtarget5.z -= .1;
3945                                     lowpoint6.y += 45 / 13;
3946                                     lowpointtarget6.y += 45 / 13;
3947                                     lowpointtarget6 += facing * .6;
3948                                     lowpointtarget7.y += 90 / 13;
3949                                     whichhit = objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget, &colpoint, &objects.position[i], &objects.yaw[i]);
3950                                     if (objects.friction[i] > .5)
3951                                         if (whichhit != -1) {
3952                                             if (whichhit != -1 && Person::players[k]->animTarget != jumpupanim && Person::players[k]->animTarget != jumpdownanim)
3953                                                 Person::players[k]->collided = 1;
3954                                             if (checkcollide(lowpoint7, lowpointtarget7) == -1)
3955                                                 if (checkcollide(lowpoint6, lowpointtarget6) == -1)
3956                                                     if (     objects.model[i].LineCheckPossible(&lowpoint2, &lowpointtarget2,
3957                                                              &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
3958                                                              objects.model[i].LineCheckPossible(&lowpoint3, &lowpointtarget3,
3959                                                                      &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
3960                                                              objects.model[i].LineCheckPossible(&lowpoint4, &lowpointtarget4,
3961                                                                      &colpoint, &objects.position[i], &objects.yaw[i]) != -1 &&
3962                                                              objects.model[i].LineCheckPossible(&lowpoint5, &lowpointtarget5,
3963                                                                      &colpoint, &objects.position[i], &objects.yaw[i]) != -1)
3964                                                         for (int j = 0; j < 45; j++) {
3965                                                             lowpoint = Person::players[k]->coords;
3966                                                             lowpoint.y += (float)j / 13;
3967                                                             lowpointtarget = lowpoint + facing * 1.4;
3968                                                             if (objects.model[i].LineCheckPossible(&lowpoint, &lowpointtarget,
3969                                                                                                    &colpoint2, &objects.position[i], &objects.yaw[i]) == -1) {
3970                                                                 if (j <= 6 || j <= 25 && Person::players[k]->animTarget == jumpdownanim)
3971                                                                     break;
3972                                                                 if (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim) {
3973                                                                     lowpoint = Person::players[k]->coords;
3974                                                                     lowpoint.y += (float)j / 13;
3975                                                                     lowpointtarget = lowpoint + facing * 1.3;
3976                                                                     flatfacing = Person::players[k]->coords;
3977                                                                     Person::players[k]->coords = colpoint - DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[k], 0) * .01;
3978                                                                     Person::players[k]->coords.y = lowpointtarget.y - .07;
3979                                                                     Person::players[k]->currentoffset = (flatfacing - Person::players[k]->coords) / Person::players[k]->scale;
3980
3981                                                                     if (j > 10 || !Person::players[k]->isRun()) {
3982                                                                         if (Person::players[k]->animTarget == jumpdownanim || Person::players[k]->animTarget == jumpupanim) {
3983                                                                             if (k == 0)
3984                                                                                 pause_sound(whooshsound);
3985                                                                         }
3986                                                                         emit_sound_at(jumpsound, Person::players[k]->coords, 128.);
3987
3988                                                                         lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3989                                                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3990                                                                         if (lowpointtarget.z < 0)
3991                                                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3992                                                                         Person::players[k]->targetyaw = Person::players[k]->yaw;
3993                                                                         Person::players[k]->lowyaw = Person::players[k]->yaw;
3994
3995                                                                         //Person::players[k]->velocity=lowpointtarget*.03;
3996                                                                         Person::players[k]->velocity = 0;
3997
3998                                                                         //climb ledge (?)
3999                                                                         if (Person::players[k]->animTarget == jumpupanim) {
4000                                                                             Person::players[k]->animTarget = climbanim;
4001                                                                             Person::players[k]->jumppower = 0;
4002                                                                             Person::players[k]->jumpclimb = 1;
4003                                                                         }
4004                                                                         Person::players[k]->transspeed = 6;
4005                                                                         Person::players[k]->target = 0;
4006                                                                         Person::players[k]->frameTarget = 1;
4007                                                                         //hang ledge (?)
4008                                                                         if (j > 25) {
4009                                                                             Person::players[k]->setAnimation(hanganim);
4010                                                                             Person::players[k]->jumppower = 0;
4011                                                                         }
4012                                                                     }
4013                                                                     break;
4014                                                                 }
4015                                                             }
4016                                                         }
4017                                         }
4018                                 }
4019                             }
4020                         }
4021                 }
4022             if (Person::players[k]->collide <= 0) {
4023                 //in the air
4024                 if (!Person::players[k]->onterrain &&
4025                         Person::players[k]->animTarget != jumpupanim &&
4026                         Person::players[k]->animTarget != jumpdownanim &&
4027                         Person::players[k]->animTarget != climbanim &&
4028                         Person::players[k]->animTarget != hanganim &&
4029                         !Person::players[k]->isWallJump() &&
4030                         !Person::players[k]->isFlip()) {
4031                     if (Person::players[k]->animCurrent != climbanim &&
4032                             Person::players[k]->animCurrent != tempanim &&
4033                             Person::players[k]->animTarget != backhandspringanim &&
4034                             (Person::players[k]->animTarget != rollanim ||
4035                              Person::players[k]->frameTarget < 2 ||
4036                              Person::players[k]->frameTarget > 6)) {
4037                         //stagger off ledge (?)
4038                         if (Person::players[k]->animTarget == staggerbackhighanim || Person::players[k]->animTarget == staggerbackhardanim)
4039                             Person::players[k]->RagDoll(0);
4040                         Person::players[k]->setAnimation(jumpdownanim);
4041
4042                         if (!k)
4043                             emit_sound_at(whooshsound, Person::players[k]->coords, 128.);
4044                     }
4045                     //gravity
4046                     Person::players[k]->velocity.y += gravity;
4047                 }
4048             }
4049         }
4050         Person::players[k]->realoldcoords = Person::players[k]->coords;
4051     }
4052 }
4053
4054 void doAttacks()
4055 {
4056     static XYZ relative;
4057     static int randattack;
4058     static bool playerrealattackkeydown = 0;
4059
4060     if (!Input::isKeyDown(attackkey))
4061         oldattackkey = 0;
4062     if (oldattackkey)
4063         Person::players[0]->attackkeydown = 0;
4064     if (oldattackkey)
4065         playerrealattackkeydown = 0;
4066     if (!oldattackkey)
4067         playerrealattackkeydown = Input::isKeyDown(attackkey);
4068     if ((Person::players[0]->parriedrecently <= 0 ||
4069             Person::players[0]->weaponactive == -1) &&
4070             (!oldattackkey ||
4071              (realthreat &&
4072               Person::players[0]->lastattack != swordslashanim &&
4073               Person::players[0]->lastattack != knifeslashstartanim &&
4074               Person::players[0]->lastattack != staffhitanim &&
4075               Person::players[0]->lastattack != staffspinhitanim)))
4076         Person::players[0]->attackkeydown = Input::isKeyDown(attackkey);
4077     if (Input::isKeyDown(attackkey) &&
4078             !oldattackkey &&
4079             !Person::players[0]->backkeydown) {
4080         for (unsigned k = 0; k < Person::players.size(); k++) {
4081             if ((Person::players[k]->animTarget == swordslashanim ||
4082                     Person::players[k]->animTarget == staffhitanim ||
4083                     Person::players[k]->animTarget == staffspinhitanim) &&
4084                     Person::players[0]->animCurrent != dodgebackanim &&
4085                     !Person::players[k]->skeleton.free)
4086                 Person::players[k]->Reverse();
4087         }
4088     }
4089
4090     if (!hostile || indialogue != -1)
4091         Person::players[0]->attackkeydown = 0;
4092
4093     for (unsigned k = 0; k < Person::players.size(); k++) {
4094         if (indialogue != -1)
4095             Person::players[k]->attackkeydown = 0;
4096         if (Person::players[k]->animTarget != rabbitrunninganim && Person::players[k]->animTarget != wolfrunninganim) {
4097             if (Person::players[k]->aitype != playercontrolled)
4098                 Person::players[k]->victim = Person::players[0];
4099             //attack key pressed
4100             if (Person::players[k]->attackkeydown) {
4101                 //dodge backward
4102                 if (Person::players[k]->backkeydown &&
4103                         Person::players[k]->animTarget != backhandspringanim &&
4104                         (Person::players[k]->isIdle() ||
4105                          Person::players[k]->isStop() ||
4106                          Person::players[k]->isRun() ||
4107                          Person::players[k]->animTarget == walkanim)) {
4108                     if (Person::players[k]->jumppower <= 1) {
4109                         Person::players[k]->jumppower -= 2;
4110                     } else {
4111                         for (unsigned i = 0; i < Person::players.size(); i++) {
4112                             if (i == k)
4113                                 continue;
4114                             if (Person::players[i]->animTarget == swordslashanim ||
4115                                     Person::players[i]->animTarget == knifeslashstartanim ||
4116                                     Person::players[i]->animTarget == staffhitanim ||
4117                                     Person::players[i]->animTarget == staffspinhitanim)
4118                                 if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < 6.5 && !Person::players[i]->skeleton.free) {
4119                                     Person::players[k]->setAnimation(dodgebackanim);
4120                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4121                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4122                                 }
4123                         }
4124                         if (Person::players[k]->animTarget != dodgebackanim) {
4125                             if (k == 0)
4126                                 numflipped++;
4127                             Person::players[k]->setAnimation(backhandspringanim);
4128                             Person::players[k]->targetyaw = -yaw + 180;
4129                             if (Person::players[k]->leftkeydown)
4130                                 Person::players[k]->targetyaw -= 45;
4131                             if (Person::players[k]->rightkeydown)
4132                                 Person::players[k]->targetyaw += 45;
4133                             Person::players[k]->yaw = Person::players[k]->targetyaw;
4134                             Person::players[k]->jumppower -= 2;
4135                         }
4136                     }
4137                 }
4138                 //attack
4139                 if (!animation[Person::players[k]->animTarget].attack &&
4140                         !Person::players[k]->backkeydown &&
4141                         (Person::players[k]->isIdle() ||
4142                          Person::players[k]->isRun() ||
4143                          Person::players[k]->animTarget == walkanim ||
4144                          Person::players[k]->animTarget == sneakanim ||
4145                          Person::players[k]->isCrouch())) {
4146                     const int attackweapon = Person::players[k]->weaponactive == -1 ? 0 : weapons[Person::players[k]->weaponids[Person::players[k]->weaponactive]].getType();
4147                     //normal attacks (?)
4148                     Person::players[k]->hasvictim = 0;
4149                     if (Person::players.size() > 1)
4150                         for (unsigned i = 0; i < Person::players.size(); i++) {
4151                             if (i == k || !(k == 0 || i == 0))
4152                                 continue;
4153                             if (!Person::players[k]->hasvictim)
4154                                 if (animation[Person::players[k]->animTarget].attack != reversal) {
4155                                     //choose an attack
4156                                     const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
4157                                     if (distance < 4.5 &&
4158                                             !Person::players[i]->skeleton.free &&
4159                                             Person::players[i]->howactive < typedead1 &&
4160                                             Person::players[i]->animTarget != jumpreversedanim &&
4161                                             Person::players[i]->animTarget != rabbitkickreversedanim &&
4162                                             Person::players[i]->animTarget != rabbitkickanim &&
4163                                             Person::players[k]->animTarget != rabbitkickanim &&
4164                                             Person::players[i]->animTarget != getupfrombackanim &&
4165                                             (Person::players[i]->animTarget != staggerbackhighanim &&
4166                                              (Person::players[i]->animTarget != staggerbackhardanim ||
4167                                               animation[staggerbackhardanim].label[Person::players[i]->frameTarget] == 6)) &&
4168                                             Person::players[i]->animTarget != jumpdownanim &&
4169                                             Person::players[i]->animTarget != jumpupanim &&
4170                                             Person::players[i]->animTarget != getupfromfrontanim) {
4171                                         Person::players[k]->victim = Person::players[i];
4172                                         Person::players[k]->hasvictim = 1;
4173                                         if (Person::players[k]->aitype == playercontrolled) { //human player
4174                                             //sweep
4175                                             if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4176                                                     Person::players[k]->crouchkeydown &&
4177                                                     animation[Person::players[i]->animTarget].height != lowheight)
4178                                                 Person::players[k]->animTarget = sweepanim;
4179                                             //winduppunch
4180                                             else if (distance < 1.5 * sq(Person::players[k]->scale * 5) &&
4181                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4182                                                      !Person::players[k]->forwardkeydown &&
4183                                                      !Person::players[k]->leftkeydown &&
4184                                                      !Person::players[k]->rightkeydown &&
4185                                                      !Person::players[k]->crouchkeydown &&
4186                                                      !attackweapon &&
4187                                                      !reversaltrain)
4188                                                 Person::players[k]->animTarget = winduppunchanim;
4189                                             //upunch
4190                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4191                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4192                                                      !Person::players[k]->forwardkeydown &&
4193                                                      !Person::players[k]->leftkeydown &&
4194                                                      !Person::players[k]->rightkeydown &&
4195                                                      !Person::players[k]->crouchkeydown &&
4196                                                      !attackweapon)
4197                                                 Person::players[k]->animTarget = upunchanim;
4198                                             //knifefollow
4199                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4200                                                      Person::players[i]->staggerdelay > 0 &&
4201                                                      attackweapon == knife &&
4202                                                      Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2)
4203                                                 Person::players[k]->animTarget = knifefollowanim;
4204                                             //knifeslashstart
4205                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4206                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4207                                                      !Person::players[k]->forwardkeydown &&
4208                                                      !Person::players[k]->leftkeydown &&
4209                                                      !Person::players[k]->rightkeydown &&
4210                                                      !Person::players[k]->crouchkeydown &&
4211                                                      attackweapon == knife &&
4212                                                      Person::players[k]->weaponmissdelay <= 0)
4213                                                 Person::players[k]->animTarget = knifeslashstartanim;
4214                                             //swordslash
4215                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4216                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4217                                                      !Person::players[k]->crouchkeydown &&
4218                                                      attackweapon == sword &&
4219                                                      Person::players[k]->weaponmissdelay <= 0)
4220                                                 Person::players[k]->animTarget = swordslashanim;
4221                                             //staffhit
4222                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4223                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4224                                                      !Person::players[k]->crouchkeydown &&
4225                                                      attackweapon == staff &&
4226                                                      Person::players[k]->weaponmissdelay <= 0 &&
4227                                                      !Person::players[k]->leftkeydown &&
4228                                                      !Person::players[k]->rightkeydown &&
4229                                                      !Person::players[k]->forwardkeydown)
4230                                                 Person::players[k]->animTarget = staffhitanim;
4231                                             //staffspinhit
4232                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4233                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4234                                                      !Person::players[k]->crouchkeydown &&
4235                                                      attackweapon == staff &&
4236                                                      Person::players[k]->weaponmissdelay <= 0)
4237                                                 Person::players[k]->animTarget = staffspinhitanim;
4238                                             //spinkick
4239                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4240                                                      animation[Person::players[i]->animTarget].height != lowheight)
4241                                                 Person::players[k]->animTarget = spinkickanim;
4242                                             //lowkick
4243                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4244                                                      animation[Person::players[i]->animTarget].height == lowheight &&
4245                                                      animation[Person::players[k]->animTarget].attack != normalattack)
4246                                                 Person::players[k]->animTarget = lowkickanim;
4247                                         } else { //AI player
4248                                             if (distance < 4.5 * sq(Person::players[k]->scale * 5)) {
4249                                                 randattack = abs(Random() % 5);
4250                                                 if (!attackweapon && distance < 2.5 * sq(Person::players[k]->scale * 5)) {
4251                                                     //sweep
4252                                                     if (randattack == 0 && animation[Person::players[i]->animTarget].height != lowheight)
4253                                                         Person::players[k]->animTarget = sweepanim;
4254                                                     //upunch
4255                                                     else if (randattack == 1 && animation[Person::players[i]->animTarget].height != lowheight &&
4256                                                              !attackweapon)
4257                                                         Person::players[k]->animTarget = upunchanim;
4258                                                     //spinkick
4259                                                     else if (randattack == 2 && animation[Person::players[i]->animTarget].height != lowheight)
4260                                                         Person::players[k]->animTarget = spinkickanim;
4261                                                     //lowkick
4262                                                     else if (animation[Person::players[i]->animTarget].height == lowheight)
4263                                                         Person::players[k]->animTarget = lowkickanim;
4264                                                 }
4265                                                 if (attackweapon) {
4266                                                     //sweep
4267                                                     if ((tutoriallevel != 1 || !attackweapon) &&
4268                                                             distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4269                                                             randattack == 0 &&
4270                                                             animation[Person::players[i]->animTarget].height != lowheight)
4271                                                         Person::players[k]->animTarget = sweepanim;
4272                                                     //knifeslashstart
4273                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4274                                                              attackweapon == knife &&
4275                                                              Person::players[k]->weaponmissdelay <= 0)
4276                                                         Person::players[k]->animTarget = knifeslashstartanim;
4277                                                     //swordslash
4278                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4279                                                                Person::players[0]->hasvictim &&
4280                                                                Person::players[0]->animTarget == swordslashanim) &&
4281                                                              attackweapon == sword &&
4282                                                              Person::players[k]->weaponmissdelay <= 0)
4283                                                         Person::players[k]->animTarget = swordslashanim;
4284                                                     //staffhit
4285                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4286                                                                Person::players[0]->hasvictim &&
4287                                                                Person::players[0]->animTarget == swordslashanim) &&
4288                                                              attackweapon == staff &&
4289                                                              Person::players[k]->weaponmissdelay <= 0 &&
4290                                                              randattack < 3)
4291                                                         Person::players[k]->animTarget = staffhitanim;
4292                                                     //staffspinhit
4293                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4294                                                                Person::players[0]->hasvictim &&
4295                                                                Person::players[0]->animTarget == swordslashanim) &&
4296                                                              attackweapon == staff &&
4297                                                              Person::players[k]->weaponmissdelay <= 0 &&
4298                                                              randattack >= 3)
4299                                                         Person::players[k]->animTarget = staffspinhitanim;
4300                                                     //spinkick
4301                                                     else if ((tutoriallevel != 1 || !attackweapon) &&
4302                                                              distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4303                                                              randattack == 1 &&
4304                                                              animation[Person::players[i]->animTarget].height != lowheight)
4305                                                         Person::players[k]->animTarget = spinkickanim;
4306                                                     //lowkick
4307                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4308                                                              animation[Person::players[i]->animTarget].height == lowheight &&
4309                                                              animation[Person::players[k]->animTarget].attack != normalattack)
4310                                                         Person::players[k]->animTarget = lowkickanim;
4311                                                 }
4312                                             }
4313                                         }
4314                                         //upunch becomes wolfslap
4315                                         if (Person::players[k]->animTarget == upunchanim && Person::players[k]->creature == wolftype)
4316                                             Person::players[k]->animTarget = wolfslapanim;
4317                                     }
4318                                     //sneak attacks
4319                                     if ((k == 0) && (tutoriallevel != 1 || tutorialstage == 22) &&
4320                                             Person::players[i]->howactive < typedead1 &&
4321                                             distance < 1.5 * sq(Person::players[k]->scale * 5) &&
4322                                             !Person::players[i]->skeleton.free &&
4323                                             Person::players[i]->animTarget != getupfrombackanim &&
4324                                             Person::players[i]->animTarget != getupfromfrontanim &&
4325                                             (Person::players[i]->stunned > 0 && Person::players[k]->madskills ||
4326                                              Person::players[i]->surprised > 0 ||
4327                                              Person::players[i]->aitype == passivetype ||
4328                                              attackweapon && Person::players[i]->stunned > 0) &&
4329                                             normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[k]->coords) > 0) {
4330                                         //sneakattack
4331                                         if (!attackweapon) {
4332                                             Person::players[k]->animCurrent = sneakattackanim;
4333                                             Person::players[k]->animTarget = sneakattackanim;
4334                                             Person::players[i]->animCurrent = sneakattackedanim;
4335                                             Person::players[i]->animTarget = sneakattackedanim;
4336                                             Person::players[k]->oldcoords = Person::players[k]->coords;
4337                                             Person::players[k]->coords = Person::players[i]->coords;
4338                                         }
4339                                         //knifesneakattack
4340                                         if (attackweapon == knife) {
4341                                             Person::players[k]->animCurrent = knifesneakattackanim;
4342                                             Person::players[k]->animTarget = knifesneakattackanim;
4343                                             Person::players[i]->animCurrent = knifesneakattackedanim;
4344                                             Person::players[i]->animTarget = knifesneakattackedanim;
4345                                             Person::players[i]->oldcoords = Person::players[i]->coords;
4346                                             Person::players[i]->coords = Person::players[k]->coords;
4347                                         }
4348                                         //swordsneakattack
4349                                         if (attackweapon == sword) {
4350                                             Person::players[k]->animCurrent = swordsneakattackanim;
4351                                             Person::players[k]->animTarget = swordsneakattackanim;
4352                                             Person::players[i]->animCurrent = swordsneakattackedanim;
4353                                             Person::players[i]->animTarget = swordsneakattackedanim;
4354                                             Person::players[i]->oldcoords = Person::players[i]->coords;
4355                                             Person::players[i]->coords = Person::players[k]->coords;
4356                                         }
4357                                         if (attackweapon != staff) {
4358                                             Person::players[k]->victim = Person::players[i];
4359                                             Person::players[k]->hasvictim = 1;
4360                                             Person::players[i]->targettilt2 = 0;
4361                                             Person::players[i]->frameTarget = 1;
4362                                             Person::players[i]->frameCurrent = 0;
4363                                             Person::players[i]->target = 0;
4364                                             Person::players[i]->velocity = 0;
4365                                             Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
4366                                             Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
4367                                             Person::players[k]->frameTarget = Person::players[i]->frameTarget;
4368                                             Person::players[k]->target = Person::players[i]->target;
4369                                             Person::players[k]->velocity = 0;
4370                                             Person::players[k]->targetyaw = Person::players[i]->yaw;
4371                                             Person::players[k]->yaw = Person::players[i]->yaw;
4372                                             Person::players[i]->targetyaw = Person::players[i]->yaw;
4373                                         }
4374                                     }
4375                                     if (animation[Person::players[k]->animTarget].attack == normalattack &&
4376                                             Person::players[k]->victim == Person::players[i] &&
4377                                             (!Person::players[i]->skeleton.free)) {
4378                                         oldattackkey = 1;
4379                                         Person::players[k]->frameTarget = 0;
4380                                         Person::players[k]->target = 0;
4381
4382                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4383                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4384                                         Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
4385                                         Person::players[k]->lastattack2 = Person::players[k]->lastattack;
4386                                         Person::players[k]->lastattack = Person::players[k]->animTarget;
4387                                     }
4388                                     if (Person::players[k]->animTarget == knifefollowanim &&
4389                                             Person::players[k]->victim == Person::players[i]) {
4390                                         oldattackkey = 1;
4391                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4392                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4393                                         Person::players[k]->victim = Person::players[i];
4394                                         Person::players[k]->hasvictim = 1;
4395                                         Person::players[i]->animTarget = knifefollowedanim;
4396                                         Person::players[i]->animCurrent = knifefollowedanim;
4397                                         Person::players[i]->targettilt2 = 0;
4398                                         Person::players[i]->targettilt2 = Person::players[k]->targettilt2;
4399                                         Person::players[i]->frameTarget = 1;
4400                                         Person::players[i]->frameCurrent = 0;
4401                                         Person::players[i]->target = 0;
4402                                         Person::players[i]->velocity = 0;
4403                                         Person::players[k]->animCurrent = knifefollowanim;
4404                                         Person::players[k]->animTarget = knifefollowanim;
4405                                         Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
4406                                         Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
4407                                         Person::players[k]->frameTarget = Person::players[i]->frameTarget;
4408                                         Person::players[k]->target = Person::players[i]->target;
4409                                         Person::players[k]->velocity = 0;
4410                                         Person::players[k]->oldcoords = Person::players[k]->coords;
4411                                         Person::players[i]->coords = Person::players[k]->coords;
4412                                         Person::players[i]->targetyaw = Person::players[k]->targetyaw;
4413                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
4414                                         Person::players[k]->yaw = Person::players[k]->targetyaw;
4415                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
4416                                     }
4417                                 }
4418                         }
4419                     const bool hasstaff = attackweapon == staff;
4420                     if (k == 0 && Person::players.size() > 1)
4421                         for (unsigned i = 0; i < Person::players.size(); i++) {
4422                             if (i == k)
4423                                 continue;
4424                             if ((playerrealattackkeydown || Person::players[i]->dead || !hasstaff) &&
4425                                     animation[Person::players[k]->animTarget].attack == neutral) {
4426                                 const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
4427                                 if (!Person::players[i]->dead || !realthreat || (!attackweapon && Person::players[k]->crouchkeydown))
4428                                     if (Person::players[i]->skeleton.free)
4429                                         if (distance < 3.5 * sq(Person::players[k]->scale * 5) &&
4430                                                 (Person::players[i]->dead ||
4431                                                  Person::players[i]->skeleton.longdead > 1000 ||
4432                                                  Person::players[k]->isRun() ||
4433                                                  hasstaff ||
4434                                                  (attackweapon &&
4435                                                   (Person::players[i]->skeleton.longdead > 2000 ||
4436                                                    Person::players[i]->damage > Person::players[i]->damagetolerance / 8 ||
4437                                                    Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2) &&
4438                                                   distance < 1.5 * sq(Person::players[k]->scale * 5)))) {
4439                                             Person::players[k]->victim = Person::players[i];
4440                                             Person::players[k]->hasvictim = 1;
4441                                             if (attackweapon && tutoriallevel != 1) {
4442                                                 //crouchstab
4443                                                 if (Person::players[k]->crouchkeydown && attackweapon == knife && distance < 1.5 * sq(Person::players[k]->scale * 5))
4444                                                     Person::players[k]->animTarget = crouchstabanim;
4445                                                 //swordgroundstab
4446                                                 if (Person::players[k]->crouchkeydown && distance < 1.5 * sq(Person::players[k]->scale * 5) && attackweapon == sword)
4447                                                     Person::players[k]->animTarget = swordgroundstabanim;
4448                                                 //staffgroundsmash
4449                                                 if (distance < 3.5 * sq(Person::players[k]->scale * 5) && attackweapon == staff)
4450                                                     Person::players[k]->animTarget = staffgroundsmashanim;
4451                                             }
4452                                             if (distance < 2.5 &&
4453                                                     Person::players[k]->crouchkeydown &&
4454                                                     Person::players[k]->animTarget != crouchstabanim &&
4455                                                     !attackweapon &&
4456                                                     Person::players[i]->dead &&
4457                                                     Person::players[i]->skeleton.free &&
4458                                                     Person::players[i]->skeleton.longdead > 1000) {
4459                                                 Person::players[k]->animTarget = killanim;
4460                                                 //TODO: refactor this out, what does it do?
4461                                                 for (int j = 0; j < terrain.numdecals; j++) {
4462                                                     if ((terrain.decaltype[j] == blooddecal || terrain.decaltype[j] == blooddecalslow) &&
4463                                                             terrain.decalalivetime[j] < 2)
4464                                                         terrain.DeleteDecal(j);
4465                                                 }
4466                                                 for (int l = 0; l < objects.numobjects; l++) {
4467                                                     if (objects.model[l].type == decalstype)
4468                                                         for (int j = 0; j < objects.model[l].numdecals; j++) {
4469                                                             if ((objects.model[l].decaltype[j] == blooddecal ||
4470                                                                     objects.model[l].decaltype[j] == blooddecalslow) &&
4471                                                                     objects.model[l].decalalivetime[j] < 2)
4472                                                                 objects.model[l].DeleteDecal(j);
4473                                                         }
4474                                                 }
4475                                             }
4476                                             if (!Person::players[i]->dead || musictype != 2)
4477                                                 if (distance < 3.5 &&
4478                                                         (Person::players[k]->isRun() || Person::players[k]->isIdle() && Person::players[k]->attackkeydown) &&
4479                                                         Person::players[k]->staggerdelay <= 0 &&
4480                                                         (Person::players[i]->dead ||
4481                                                          Person::players[i]->skeleton.longdead < 300 &&
4482                                                          Person::players[k]->lastattack != spinkickanim &&
4483                                                          Person::players[i]->skeleton.free) &&
4484                                                         (!Person::players[i]->dead || musictype != stream_fighttheme)) {
4485                                                     Person::players[k]->animTarget = dropkickanim;
4486                                                     for (int j = 0; j < terrain.numdecals; j++) {
4487                                                         if ((terrain.decaltype[j] == blooddecal || terrain.decaltype[j] == blooddecalslow) &&
4488                                                                 terrain.decalalivetime[j] < 2) {
4489                                                             terrain.DeleteDecal(j);
4490                                                         }
4491                                                     }
4492                                                     for (int l = 0; l < objects.numobjects; l++) {
4493                                                         if (objects.model[l].type == decalstype)
4494                                                             for (int j = 0; j < objects.model[l].numdecals; j++) {
4495                                                                 if ((objects.model[l].decaltype[j] == blooddecal ||
4496                                                                         objects.model[l].decaltype[j] == blooddecalslow) &&
4497                                                                         objects.model[l].decalalivetime[j] < 2) {
4498                                                                     objects.model[l].DeleteDecal(j);
4499                                                                 }
4500                                                             }
4501                                                     }
4502                                                 }
4503                                         }
4504                                 if (animation[Person::players[k]->animTarget].attack == normalattack &&
4505                                         Person::players[k]->victim == Person::players[i] &&
4506                                         (!Person::players[i]->skeleton.free ||
4507                                          Person::players[k]->animTarget == killanim ||
4508                                          Person::players[k]->animTarget == crouchstabanim ||
4509                                          Person::players[k]->animTarget == swordgroundstabanim ||
4510                                          Person::players[k]->animTarget == staffgroundsmashanim ||
4511                                          Person::players[k]->animTarget == dropkickanim)) {
4512                                     oldattackkey = 1;
4513                                     Person::players[k]->frameTarget = 0;
4514                                     Person::players[k]->target = 0;
4515
4516                                     XYZ targetpoint = Person::players[i]->coords;
4517                                     if (Person::players[k]->animTarget == crouchstabanim ||
4518                                             Person::players[k]->animTarget == swordgroundstabanim ||
4519                                             Person::players[k]->animTarget == staffgroundsmashanim) {
4520                                         targetpoint += (Person::players[i]->jointPos(abdomen) +
4521                                                         Person::players[i]->jointPos(neck)) / 2 *
4522                                                        Person::players[i]->scale;
4523                                     }
4524                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, targetpoint);
4525                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, targetpoint);
4526
4527                                     if (Person::players[k]->animTarget == crouchstabanim || Person::players[k]->animTarget == swordgroundstabanim) {
4528                                         Person::players[k]->targetyaw += (float)(abs(Random() % 100) - 50) / 4;
4529                                     }
4530
4531                                     if (Person::players[k]->animTarget == staffgroundsmashanim)
4532                                         Person::players[k]->targettilt2 += 10;
4533
4534                                     Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
4535                                     Person::players[k]->lastattack2 = Person::players[k]->lastattack;
4536                                     Person::players[k]->lastattack = Person::players[k]->animTarget;
4537
4538                                     if (Person::players[k]->animTarget == swordgroundstabanim) {
4539                                         Person::players[k]->targetyaw += 30;
4540                                     }
4541                                 }
4542                             }
4543                         }
4544                     if (!Person::players[k]->hasvictim) {
4545                         //find victim
4546                         for (unsigned i = 0; i < Person::players.size(); i++) {
4547                             if (i == k || !(i == 0 || k == 0))
4548                                 continue;
4549                             if (!Person::players[i]->skeleton.free) {
4550                                 if (Person::players[k]->hasvictim) {
4551                                     if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) <
4552                                             distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords))
4553                                         Person::players[k]->victim = Person::players[i];
4554                                 } else {
4555                                     Person::players[k]->victim = Person::players[i];
4556                                     Person::players[k]->hasvictim = 1;
4557                                 }
4558                             }
4559                         }
4560                     }
4561                     if (Person::players[k]->aitype == playercontrolled)
4562                         //rabbit kick
4563                         if (Person::players[k]->attackkeydown &&
4564                                 Person::players[k]->isRun() &&
4565                                 Person::players[k]->wasRun() &&
4566                                 ((Person::players[k]->hasvictim &&
4567                                   distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) < 12 * sq(Person::players[k]->scale * 5) &&
4568                                   distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) > 7 * sq(Person::players[k]->scale * 5) &&
4569                                   !Person::players[k]->victim->skeleton.free &&
4570                                   Person::players[k]->victim->animTarget != getupfrombackanim &&
4571                                   Person::players[k]->victim->animTarget != getupfromfrontanim &&
4572                                   animation[Person::players[k]->victim->animTarget].height != lowheight &&
4573                                   Person::players[k]->aitype != playercontrolled && //wat???
4574                                   normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
4575                                   Person::players[k]->rabbitkickenabled) ||
4576                                  Person::players[k]->jumpkeydown)) {
4577                             oldattackkey = 1;
4578                             Person::players[k]->setAnimation(rabbitkickanim);
4579                         }
4580                     //update counts
4581                     if (animation[Person::players[k]->animTarget].attack && k == 0) {
4582                         numattacks++;
4583                         switch (attackweapon) {
4584                         case 0:
4585                             numunarmedattack++;
4586                             break;
4587                         case knife:
4588                             numknifeattack++;
4589                             break;
4590                         case sword:
4591                             numswordattack++;
4592                             break;
4593                         case staff:
4594                             numstaffattack++;
4595                             break;
4596                         }
4597                     }
4598                 }
4599             }
4600         }
4601     }
4602 }
4603
4604 void doPlayerCollisions()
4605 {
4606     static XYZ rotatetarget;
4607     static float collisionradius;
4608     if (Person::players.size() > 1)
4609         for (unsigned k = 0; k < Person::players.size(); k++)
4610             for (unsigned i = k + 1; i < Person::players.size(); i++) {
4611                 //neither player is part of a reversal
4612                 if ((animation[Person::players[i]->animTarget].attack != reversed &&
4613                         animation[Person::players[i]->animTarget].attack != reversal &&
4614                         animation[Person::players[k]->animTarget].attack != reversed &&
4615                         animation[Person::players[k]->animTarget].attack != reversal) || (i != 0 && k != 0))
4616                     if ((animation[Person::players[i]->animCurrent].attack != reversed &&
4617                             animation[Person::players[i]->animCurrent].attack != reversal &&
4618                             animation[Person::players[k]->animCurrent].attack != reversed &&
4619                             animation[Person::players[k]->animCurrent].attack != reversal) || (i != 0 && k != 0))
4620                         //neither is sleeping
4621                         if (Person::players[i]->howactive <= typesleeping && Person::players[k]->howactive <= typesleeping)
4622                             if (Person::players[i]->howactive != typesittingwall && Person::players[k]->howactive != typesittingwall)
4623                                 //in same patch, neither is climbing
4624                                 if (Person::players[i]->whichpatchx == Person::players[k]->whichpatchx &&
4625                                         Person::players[i]->whichpatchz == Person::players[k]->whichpatchz &&
4626                                         Person::players[k]->skeleton.oldfree == Person::players[k]->skeleton.free &&
4627                                         Person::players[i]->skeleton.oldfree == Person::players[i]->skeleton.free &&
4628                                         Person::players[i]->animTarget != climbanim &&
4629                                         Person::players[i]->animTarget != hanganim &&
4630                                         Person::players[k]->animTarget != climbanim &&
4631                                         Person::players[k]->animTarget != hanganim)
4632                                     //players are close (bounding box test)
4633                                     if (Person::players[i]->coords.y > Person::players[k]->coords.y - 3)
4634                                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 3)
4635                                             if (Person::players[i]->coords.x > Person::players[k]->coords.x - 3)
4636                                                 if (Person::players[i]->coords.x < Person::players[k]->coords.x + 3)
4637                                                     if (Person::players[i]->coords.z > Person::players[k]->coords.z - 3)
4638                                                         if (Person::players[i]->coords.z < Person::players[k]->coords.z + 3) {
4639                                                             //spread fire from player to player
4640                                                             if (distsq(&Person::players[i]->coords, &Person::players[k]->coords)
4641                                                                     < 3 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
4642                                                                 if (Person::players[i]->onfire || Person::players[k]->onfire) {
4643                                                                     if (!Person::players[i]->onfire)
4644                                                                         Person::players[i]->CatchFire();
4645                                                                     if (!Person::players[k]->onfire)
4646                                                                         Person::players[k]->CatchFire();
4647                                                                 }
4648                                                             }
4649
4650                                                             XYZ tempcoords1 = Person::players[i]->coords;
4651                                                             XYZ tempcoords2 = Person::players[k]->coords;
4652                                                             if (!Person::players[i]->skeleton.oldfree)
4653                                                                 tempcoords1.y += Person::players[i]->jointPos(abdomen).y * Person::players[i]->scale;
4654                                                             if (!Person::players[k]->skeleton.oldfree)
4655                                                                 tempcoords2.y += Person::players[k]->jointPos(abdomen).y * Person::players[k]->scale;
4656                                                             collisionradius = 1.2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4657                                                             if (Person::players[0]->hasvictim)
4658                                                                 if (Person::players[0]->animTarget == rabbitkickanim && (k == 0 || i == 0) && !Person::players[0]->victim->skeleton.free)
4659                                                                     collisionradius = 3;
4660                                                             if ((!Person::players[i]->skeleton.oldfree || !Person::players[k]->skeleton.oldfree) &&
4661                                                                     (distsq(&tempcoords1, &tempcoords2) < collisionradius ||
4662                                                                      distsq(&Person::players[i]->coords, &Person::players[k]->coords) < collisionradius)) {
4663                                                                 //jump down on a dead body
4664                                                                 if (k == 0 || i == 0) {
4665                                                                     int l = i ? i : k;
4666                                                                     if (Person::players[0]->animTarget == jumpdownanim &&
4667                                                                             !Person::players[0]->skeleton.oldfree &&
4668                                                                             !Person::players[0]->skeleton.free &&
4669                                                                             Person::players[l]->skeleton.oldfree &&
4670                                                                             Person::players[l]->skeleton.free &&
4671                                                                             Person::players[l]->dead &&
4672                                                                             Person::players[0]->lastcollide <= 0 &&
4673                                                                             fabs(Person::players[l]->coords.y - Person::players[0]->coords.y) < .2 &&
4674                                                                             distsq(&Person::players[0]->coords, &Person::players[l]->coords) < .7 * sq((Person::players[l]->scale + Person::players[0]->scale) * 2.5)) {
4675                                                                         Person::players[0]->coords.y = Person::players[l]->coords.y;
4676                                                                         Person::players[l]->velocity = Person::players[0]->velocity;
4677                                                                         Person::players[l]->skeleton.free = 0;
4678                                                                         Person::players[l]->yaw = 0;
4679                                                                         Person::players[l]->RagDoll(0);
4680                                                                         Person::players[l]->DoDamage(20);
4681                                                                         camerashake += .3;
4682                                                                         Person::players[l]->skeleton.longdead = 0;
4683                                                                         Person::players[0]->lastcollide = 1;
4684                                                                     }
4685                                                                 }
4686
4687                                                                 if (     (Person::players[i]->skeleton.oldfree == 1 && findLengthfast(&Person::players[i]->velocity) > 1) ||
4688                                                                          (Person::players[k]->skeleton.oldfree == 1 && findLengthfast(&Person::players[k]->velocity) > 1) ||
4689                                                                          (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0)) {
4690                                                                     rotatetarget = Person::players[k]->velocity - Person::players[i]->velocity;
4691                                                                     if ((Person::players[i]->animTarget != getupfrombackanim && Person::players[i]->animTarget != getupfromfrontanim ||
4692                                                                             Person::players[i]->skeleton.free) &&
4693                                                                             (Person::players[k]->animTarget != getupfrombackanim && Person::players[k]->animTarget != getupfromfrontanim ||
4694                                                                              Person::players[k]->skeleton.free))
4695                                                                         if ((((k != 0 && findLengthfast(&rotatetarget) > 150 ||
4696                                                                                 k == 0 && findLengthfast(&rotatetarget) > 50 && Person::players[0]->rabbitkickragdoll) &&
4697                                                                                 normaldotproduct(rotatetarget, Person::players[k]->coords - Person::players[i]->coords) > 0) &&
4698                                                                                 (k == 0 ||
4699                                                                                  k != 0 && Person::players[i]->skeleton.oldfree == 1 && animation[Person::players[k]->animCurrent].attack == neutral ||
4700                                                                                  /*i!=0&&*/Person::players[k]->skeleton.oldfree == 1 && animation[Person::players[i]->animCurrent].attack == neutral)) ||
4701                                                                                 (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) &&
4702                                                                                 (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) &&
4703                                                                                 k == 0 && !Person::players[i]->skeleton.oldfree && !Person::players[k]->skeleton.oldfree) {
4704                                                                             //If hit by body
4705                                                                             if (     (i != 0 || Person::players[i]->skeleton.free) &&
4706                                                                                      (k != 0 || Person::players[k]->skeleton.free) ||
4707                                                                                      (animation[Person::players[i]->animTarget].height == highheight &&
4708                                                                                       animation[Person::players[k]->animTarget].height == highheight)) {
4709                                                                                 if (tutoriallevel != 1) {
4710                                                                                     emit_sound_at(heavyimpactsound, Person::players[i]->coords);
4711                                                                                 }
4712
4713                                                                                 Person::players[i]->RagDoll(0);
4714                                                                                 if (Person::players[i]->damage > Person::players[i]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[i]->dead) {
4715                                                                                     award_bonus(0, aimbonus);
4716                                                                                 }
4717                                                                                 Person::players[i]->DoDamage(findLengthfast(&rotatetarget) / 4);
4718                                                                                 Person::players[k]->RagDoll(0);
4719                                                                                 if (Person::players[k]->damage > Person::players[k]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[k]->dead) {
4720                                                                                     award_bonus(0, aimbonus); // Huh, again?
4721                                                                                 }
4722                                                                                 Person::players[k]->DoDamage(findLengthfast(&rotatetarget) / 4);
4723
4724                                                                                 for (int j = 0; j < Person::players[i]->skeleton.num_joints; j++) {
4725                                                                                     Person::players[i]->skeleton.joints[j].velocity = Person::players[i]->skeleton.joints[j].velocity / 5 + Person::players[k]->velocity;
4726                                                                                 }
4727                                                                                 for (int j = 0; j < Person::players[k]->skeleton.num_joints; j++) {
4728                                                                                     Person::players[k]->skeleton.joints[j].velocity = Person::players[k]->skeleton.joints[j].velocity / 5 + Person::players[i]->velocity;
4729                                                                                 }
4730
4731                                                                             }
4732                                                                         }
4733                                                                     if (     (animation[Person::players[i]->animTarget].attack == neutral ||
4734                                                                               animation[Person::players[i]->animTarget].attack == normalattack) &&
4735                                                                              (animation[Person::players[k]->animTarget].attack == neutral ||
4736                                                                               animation[Person::players[k]->animTarget].attack == normalattack)) {
4737                                                                         //If bumped
4738                                                                         if (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0) {
4739                                                                             if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < .5 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
4740                                                                                 rotatetarget = Person::players[k]->coords - Person::players[i]->coords;
4741                                                                                 Normalise(&rotatetarget);
4742                                                                                 Person::players[k]->coords = (Person::players[k]->coords + Person::players[i]->coords) / 2;
4743                                                                                 Person::players[i]->coords = Person::players[k]->coords - rotatetarget * fast_sqrt(.6) / 2
4744                                                                                                    * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4745                                                                                 Person::players[k]->coords += rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4746                                                                                 if (Person::players[k]->howactive == typeactive || hostile)
4747                                                                                     if (Person::players[k]->isIdle()) {
4748                                                                                         if (Person::players[k]->howactive < typesleeping)
4749                                                                                             Person::players[k]->setAnimation(Person::players[k]->getStop());
4750                                                                                         else if (Person::players[k]->howactive == typesleeping)
4751                                                                                             Person::players[k]->setAnimation(getupfromfrontanim);
4752                                                                                         if (!editorenabled)
4753                                                                                             Person::players[k]->howactive = typeactive;
4754                                                                                     }
4755                                                                                 if (Person::players[i]->howactive == typeactive || hostile)
4756                                                                                     if (Person::players[i]->isIdle()) {
4757                                                                                         if (Person::players[i]->howactive < typesleeping)
4758                                                                                             Person::players[i]->setAnimation(Person::players[k]->getStop());
4759                                                                                         else
4760                                                                                             Person::players[i]->setAnimation(getupfromfrontanim);
4761                                                                                         if (!editorenabled)
4762                                                                                             Person::players[i]->howactive = typeactive;
4763                                                                                     }
4764                                                                             }
4765                                                                             //jump down on player
4766                                                                             if (hostile) {
4767                                                                                 if (k == 0 && i != 0 && Person::players[k]->animTarget == jumpdownanim &&
4768                                                                                         !Person::players[i]->isCrouch() &&
4769                                                                                         Person::players[i]->animTarget != rollanim &&
4770                                                                                         !Person::players[k]->skeleton.oldfree && !
4771                                                                                         Person::players[k]->skeleton.free &&
4772                                                                                         Person::players[k]->lastcollide <= 0 &&
4773                                                                                         Person::players[k]->velocity.y < -10) {
4774                                                                                     Person::players[i]->velocity = Person::players[k]->velocity;
4775                                                                                     Person::players[k]->velocity = Person::players[k]->velocity * -.5;
4776                                                                                     Person::players[k]->velocity.y = Person::players[i]->velocity.y;
4777                                                                                     Person::players[i]->DoDamage(20);
4778                                                                                     Person::players[i]->RagDoll(0);
4779                                                                                     Person::players[k]->lastcollide = 1;
4780                                                                                     award_bonus(k, AboveBonus);
4781                                                                                 }
4782                                                                                 if (i == 0 && k != 0 && Person::players[i]->animTarget == jumpdownanim &&
4783                                                                                         !Person::players[k]->isCrouch() &&
4784                                                                                         Person::players[k]->animTarget != rollanim &&
4785                                                                                         !Person::players[i]->skeleton.oldfree &&
4786                                                                                         !Person::players[i]->skeleton.free &&
4787                                                                                         Person::players[i]->lastcollide <= 0 &&
4788                                                                                         Person::players[i]->velocity.y < -10) {
4789                                                                                     Person::players[k]->velocity = Person::players[i]->velocity;
4790                                                                                     Person::players[i]->velocity = Person::players[i]->velocity * -.3;
4791                                                                                     Person::players[i]->velocity.y = Person::players[k]->velocity.y;
4792                                                                                     Person::players[k]->DoDamage(20);
4793                                                                                     Person::players[k]->RagDoll(0);
4794                                                                                     Person::players[i]->lastcollide = 1;
4795                                                                                     award_bonus(i, AboveBonus);
4796                                                                                 }
4797                                                                             }
4798                                                                         }
4799                                                                     }
4800                                                                 }
4801                                                                 Person::players[i]->CheckKick();
4802                                                                 Person::players[k]->CheckKick();
4803                                                             }
4804                                                         }
4805             }
4806 }
4807
4808 void doAI(unsigned i)
4809 {
4810     static bool connected;
4811     if (Person::players[i]->aitype != playercontrolled && indialogue == -1) {
4812         Person::players[i]->jumpclimb = 0;
4813         //disable movement in editor
4814         if (editorenabled)
4815             Person::players[i]->stunned = 1;
4816
4817         Person::players[i]->pause = 0;
4818         if (distsqflat(&Person::players[0]->coords, &Person::players[i]->coords) < 30 &&
4819                 Person::players[0]->coords.y > Person::players[i]->coords.y + 2 &&
4820                 !Person::players[0]->onterrain)
4821             Person::players[i]->pause = 1;
4822
4823         //pathfinding
4824         if (Person::players[i]->aitype == pathfindtype) {
4825             if (Person::players[i]->finalpathfindpoint == -1) {
4826                 float closestdistance;
4827                 float tempdist;
4828                 int closest;
4829                 XYZ colpoint;
4830                 closest = -1;
4831                 closestdistance = -1;
4832                 for (int j = 0; j < numpathpoints; j++)
4833                     if (closest == -1 || distsq(&Person::players[i]->finalfinaltarget, &pathpoint[j]) < closestdistance) {
4834                         closestdistance = distsq(&Person::players[i]->finalfinaltarget, &pathpoint[j]);
4835                         closest = j;
4836                         Person::players[i]->finaltarget = pathpoint[j];
4837                     }
4838                 Person::players[i]->finalpathfindpoint = closest;
4839                 for (int j = 0; j < numpathpoints; j++)
4840                     for (int k = 0; k < numpathpointconnect[j]; k++) {
4841                         DistancePointLine(&Person::players[i]->finalfinaltarget, &pathpoint[j], &pathpoint[pathpointconnect[j][k]], &tempdist, &colpoint );
4842                         if (sq(tempdist) < closestdistance)
4843                             if (findDistance(&colpoint, &pathpoint[j]) + findDistance(&colpoint, &pathpoint[pathpointconnect[j][k]]) <
4844                                     findDistance(&pathpoint[j], &pathpoint[pathpointconnect[j][k]]) + .1) {
4845                                 closestdistance = sq(tempdist);
4846                                 closest = j;
4847                                 Person::players[i]->finaltarget = colpoint;
4848                             }
4849                     }
4850                 Person::players[i]->finalpathfindpoint = closest;
4851
4852             }
4853             if (Person::players[i]->targetpathfindpoint == -1) {
4854                 float closestdistance;
4855                 float tempdist;
4856                 int closest;
4857                 XYZ colpoint;
4858                 closest = -1;
4859                 closestdistance = -1;
4860                 if (Person::players[i]->lastpathfindpoint == -1) {
4861                     for (int j = 0; j < numpathpoints; j++) {
4862                         if (j != Person::players[i]->lastpathfindpoint)
4863                             if (closest == -1 || (distsq(&Person::players[i]->coords, &pathpoint[j]) < closestdistance)) {
4864                                 closestdistance = distsq(&Person::players[i]->coords, &pathpoint[j]);
4865                                 closest = j;
4866                             }
4867                     }
4868                     Person::players[i]->targetpathfindpoint = closest;
4869                     for (int j = 0; j < numpathpoints; j++)
4870                         if (j != Person::players[i]->lastpathfindpoint)
4871                             for (int k = 0; k < numpathpointconnect[j]; k++) {
4872                                 DistancePointLine(&Person::players[i]->coords, &pathpoint[j], &pathpoint[pathpointconnect[j][k]], &tempdist, &colpoint );
4873                                 if (sq(tempdist) < closestdistance) {
4874                                     if (findDistance(&colpoint, &pathpoint[j]) + findDistance(&colpoint, &pathpoint[pathpointconnect[j][k]]) <
4875                                             findDistance(&pathpoint[j], &pathpoint[pathpointconnect[j][k]]) + .1) {
4876                                         closestdistance = sq(tempdist);
4877                                         closest = j;
4878                                     }
4879                                 }
4880                             }
4881                     Person::players[i]->targetpathfindpoint = closest;
4882                 } else {
4883                     for (int j = 0; j < numpathpoints; j++)
4884                         if (j != Person::players[i]->lastpathfindpoint &&
4885                                 j != Person::players[i]->lastpathfindpoint2 &&
4886                                 j != Person::players[i]->lastpathfindpoint3 &&
4887                                 j != Person::players[i]->lastpathfindpoint4) {
4888                             connected = 0;
4889                             if (numpathpointconnect[j])
4890                                 for (int k = 0; k < numpathpointconnect[j]; k++)
4891                                     if (pathpointconnect[j][k] == Person::players[i]->lastpathfindpoint)
4892                                         connected = 1;
4893                             if (!connected)
4894                                 if (numpathpointconnect[Person::players[i]->lastpathfindpoint])
4895                                     for (int k = 0; k < numpathpointconnect[Person::players[i]->lastpathfindpoint]; k++)
4896                                         if (pathpointconnect[Person::players[i]->lastpathfindpoint][k] == j)
4897                                             connected = 1;
4898                             if (connected) {
4899                                 tempdist = findPathDist(j, Person::players[i]->finalpathfindpoint);
4900                                 if (closest == -1 || tempdist < closestdistance) {
4901                                     closestdistance = tempdist;
4902                                     closest = j;
4903                                 }
4904                             }
4905                         }
4906                     Person::players[i]->targetpathfindpoint = closest;
4907                 }
4908             }
4909             Person::players[i]->losupdatedelay -= multiplier;
4910
4911             Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, pathpoint[Person::players[i]->targetpathfindpoint]);
4912             Person::players[i]->lookyaw = Person::players[i]->targetyaw;
4913
4914             //reached target point
4915             if (distsqflat(&Person::players[i]->coords, &pathpoint[Person::players[i]->targetpathfindpoint]) < .6) {
4916                 Person::players[i]->lastpathfindpoint4 = Person::players[i]->lastpathfindpoint3;
4917                 Person::players[i]->lastpathfindpoint3 = Person::players[i]->lastpathfindpoint2;
4918                 Person::players[i]->lastpathfindpoint2 = Person::players[i]->lastpathfindpoint;
4919                 Person::players[i]->lastpathfindpoint = Person::players[i]->targetpathfindpoint;
4920                 if (Person::players[i]->lastpathfindpoint2 == -1)
4921                     Person::players[i]->lastpathfindpoint2 = Person::players[i]->lastpathfindpoint;
4922                 if (Person::players[i]->lastpathfindpoint3 == -1)
4923                     Person::players[i]->lastpathfindpoint3 = Person::players[i]->lastpathfindpoint2;
4924                 if (Person::players[i]->lastpathfindpoint4 == -1)
4925                     Person::players[i]->lastpathfindpoint4 = Person::players[i]->lastpathfindpoint3;
4926                 Person::players[i]->targetpathfindpoint = -1;
4927             }
4928             if (     distsqflat(&Person::players[i]->coords, &Person::players[i]->finalfinaltarget) <
4929                      distsqflat(&Person::players[i]->coords, &Person::players[i]->finaltarget) ||
4930                      distsqflat(&Person::players[i]->coords, &Person::players[i]->finaltarget) < .6 * sq(Person::players[i]->scale * 5) ||
4931                      Person::players[i]->lastpathfindpoint == Person::players[i]->finalpathfindpoint) {
4932                 Person::players[i]->aitype = passivetype;
4933             }
4934
4935             Person::players[i]->forwardkeydown = 1;
4936             Person::players[i]->leftkeydown = 0;
4937             Person::players[i]->backkeydown = 0;
4938             Person::players[i]->rightkeydown = 0;
4939             Person::players[i]->crouchkeydown = 0;
4940             Person::players[i]->attackkeydown = 0;
4941             Person::players[i]->throwkeydown = 0;
4942
4943             if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8)
4944                 Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
4945
4946             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
4947                 Person::players[i]->jumpkeydown = 0;
4948             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
4949                 Person::players[i]->jumpkeydown = 1;
4950
4951             if ((tutoriallevel != 1 || cananger) &&
4952                     hostile &&
4953                     !Person::players[0]->dead &&
4954                     distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400 &&
4955                     Person::players[i]->occluded < 25) {
4956                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 12 &&
4957                         animation[Person::players[0]->animTarget].height != lowheight &&
4958                         !editorenabled &&
4959                         (Person::players[0]->coords.y < Person::players[i]->coords.y + 5 || Person::players[0]->onterrain))
4960                     Person::players[i]->aitype = attacktypecutoff;
4961                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 30 &&
4962                         animation[Person::players[0]->animTarget].height == highheight &&
4963                         !editorenabled)
4964                     Person::players[i]->aitype = attacktypecutoff;
4965
4966                 if (Person::players[i]->losupdatedelay < 0 && !editorenabled && Person::players[i]->occluded < 2) {
4967                     Person::players[i]->losupdatedelay = .2;
4968                     for (unsigned j = 0; j < Person::players.size(); j++)
4969                         if (j == 0 || Person::players[j]->skeleton.free || Person::players[j]->aitype != passivetype)
4970                             if (abs(Random() % 2) || animation[Person::players[j]->animTarget].height != lowheight || j != 0)
4971                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
4972                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
4973                                         if (Person::players[j]->coords.y < Person::players[i]->coords.y + 5 || Person::players[j]->onterrain)
4974                                             if (!Person::players[j]->isWallJump() && -1 == checkcollide(
4975                                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)
4976                                                         *Person::players[i]->scale + Person::players[i]->coords,
4977                                                         DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)
4978                                                         *Person::players[j]->scale + Person::players[j]->coords) ||
4979                                                     (Person::players[j]->animTarget == hanganim &&
4980                                                      normaldotproduct(Person::players[j]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0)) {
4981                                                 Person::players[i]->aitype = searchtype;
4982                                                 Person::players[i]->lastchecktime = 12;
4983                                                 Person::players[i]->lastseen = Person::players[j]->coords;
4984                                                 Person::players[i]->lastseentime = 12;
4985                                             }
4986                 }
4987             }
4988             if (Person::players[i]->aitype == attacktypecutoff && musictype != 2)
4989                 if (Person::players[i]->creature != wolftype) {
4990                     Person::players[i]->stunned = .6;
4991                     Person::players[i]->surprised = .6;
4992                 }
4993         }
4994
4995         if (Person::players[i]->aitype != passivetype && leveltime > .5)
4996             Person::players[i]->howactive = typeactive;
4997
4998         if (Person::players[i]->aitype == passivetype) {
4999             Person::players[i]->aiupdatedelay -= multiplier;
5000             Person::players[i]->losupdatedelay -= multiplier;
5001             Person::players[i]->lastseentime += multiplier;
5002             Person::players[i]->pausetime -= multiplier;
5003             if (Person::players[i]->lastseentime > 1)
5004                 Person::players[i]->lastseentime = 1;
5005
5006             if (Person::players[i]->aiupdatedelay < 0) {
5007                 if (Person::players[i]->numwaypoints > 1 && Person::players[i]->howactive == typeactive && Person::players[i]->pausetime <= 0) {
5008                     Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[i]->waypoints[Person::players[i]->waypoint]);
5009                     Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5010                     Person::players[i]->aiupdatedelay = .05;
5011
5012                     if (distsqflat(&Person::players[i]->coords, &Person::players[i]->waypoints[Person::players[i]->waypoint]) < 1) {
5013                         if (Person::players[i]->waypointtype[Person::players[i]->waypoint] == wppause)
5014                             Person::players[i]->pausetime = 4;
5015                         Person::players[i]->waypoint++;
5016                         if (Person::players[i]->waypoint > Person::players[i]->numwaypoints - 1)
5017                             Person::players[i]->waypoint = 0;
5018
5019                     }
5020                 }
5021
5022                 if (Person::players[i]->numwaypoints > 1 && Person::players[i]->howactive == typeactive && Person::players[i]->pausetime <= 0)
5023                     Person::players[i]->forwardkeydown = 1;
5024                 else
5025                     Person::players[i]->forwardkeydown = 0;
5026                 Person::players[i]->leftkeydown = 0;
5027                 Person::players[i]->backkeydown = 0;
5028                 Person::players[i]->rightkeydown = 0;
5029                 Person::players[i]->crouchkeydown = 0;
5030                 Person::players[i]->attackkeydown = 0;
5031                 Person::players[i]->throwkeydown = 0;
5032
5033                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5034                     if (!Person::players[i]->avoidsomething)
5035                         Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5036                     else {
5037                         XYZ leftpos, rightpos;
5038                         float leftdist, rightdist;
5039                         leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5040                         rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5041                         leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5042                         rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5043                         if (leftdist < rightdist)
5044                             Person::players[i]->targetyaw += 90;
5045                         else
5046                             Person::players[i]->targetyaw -= 90;
5047                     }
5048                 }
5049             }
5050             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5051                 Person::players[i]->jumpkeydown = 0;
5052             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5053                 Person::players[i]->jumpkeydown = 1;
5054
5055
5056             //hearing sounds
5057             if (!editorenabled) {
5058                 if (Person::players[i]->howactive <= typesleeping)
5059                     if (numenvsounds > 0 && (tutoriallevel != 1 || cananger) && hostile)
5060                         for (int j = 0; j < numenvsounds; j++) {
5061                             float vol = Person::players[i]->howactive == typesleeping ? envsoundvol[j] - 14 : envsoundvol[j];
5062                             if (vol > 0 && distsq(&Person::players[i]->coords, &envsound[j]) <
5063                                     2 * (vol + vol * (Person::players[i]->creature == rabbittype) * 3))
5064                                 Person::players[i]->aitype = attacktypecutoff;
5065                         }
5066
5067                 if (Person::players[i]->aitype != passivetype) {
5068                     if (Person::players[i]->howactive == typesleeping)
5069                         Person::players[i]->setAnimation(getupfromfrontanim);
5070                     Person::players[i]->howactive = typeactive;
5071                 }
5072             }
5073
5074             if (Person::players[i]->howactive < typesleeping &&
5075                     ((tutoriallevel != 1 || cananger) && hostile) &&
5076                     !Person::players[0]->dead &&
5077                     distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400 &&
5078                     Person::players[i]->occluded < 25) {
5079                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 12 &&
5080                         animation[Person::players[0]->animTarget].height != lowheight && !editorenabled)
5081                     Person::players[i]->aitype = attacktypecutoff;
5082                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 30 &&
5083                         animation[Person::players[0]->animTarget].height == highheight && !editorenabled)
5084                     Person::players[i]->aitype = attacktypecutoff;
5085
5086                 //wolf smell
5087                 if (Person::players[i]->creature == wolftype) {
5088                     XYZ windsmell;
5089                     for (unsigned j = 0; j < Person::players.size(); j++) {
5090                         if (j == 0 || (Person::players[j]->dead && Person::players[j]->bloodloss > 0)) {
5091                             float smelldistance = 50;
5092                             if (j == 0 && Person::players[j]->num_weapons > 0) {
5093                                 if (weapons[Person::players[j]->weaponids[0]].bloody)
5094                                     smelldistance = 100;
5095                                 if (Person::players[j]->num_weapons == 2)
5096                                     if (weapons[Person::players[j]->weaponids[1]].bloody)
5097                                         smelldistance = 100;
5098                             }
5099                             if (j != 0)
5100                                 smelldistance = 100;
5101                             windsmell = windvector;
5102                             Normalise(&windsmell);
5103                             windsmell = windsmell * 2 + Person::players[j]->coords;
5104                             if (distsq(&Person::players[i]->coords, &windsmell) < smelldistance && !editorenabled)
5105                                 Person::players[i]->aitype = attacktypecutoff;
5106                         }
5107                     }
5108                 }
5109
5110                 if (Person::players[i]->howactive < typesleeping && Person::players[i]->losupdatedelay < 0 && !editorenabled && Person::players[i]->occluded < 2) {
5111                     Person::players[i]->losupdatedelay = .2;
5112                     for (unsigned j = 0; j < Person::players.size(); j++) {
5113                         if (j == 0 || Person::players[j]->skeleton.free || Person::players[j]->aitype != passivetype) {
5114                             if (abs(Random() % 2) || animation[Person::players[j]->animTarget].height != lowheight || j != 0)
5115                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
5116                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
5117                                         if ((-1 == checkcollide(
5118                                                     DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
5119                                                     Person::players[i]->scale + Person::players[i]->coords,
5120                                                     DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*
5121                                                     Person::players[j]->scale + Person::players[j]->coords) &&
5122                                                 !Person::players[j]->isWallJump()) ||
5123                                                 (Person::players[j]->animTarget == hanganim &&
5124                                                  normaldotproduct(Person::players[j]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0)) {
5125                                             Person::players[i]->lastseentime -= .2;
5126                                             if (j == 0 && animation[Person::players[j]->animTarget].height == lowheight)
5127                                                 Person::players[i]->lastseentime -= .4;
5128                                             else
5129                                                 Person::players[i]->lastseentime -= .6;
5130                                         }
5131                             if (Person::players[i]->lastseentime <= 0) {
5132                                 Person::players[i]->aitype = searchtype;
5133                                 Person::players[i]->lastchecktime = 12;
5134                                 Person::players[i]->lastseen = Person::players[j]->coords;
5135                                 Person::players[i]->lastseentime = 12;
5136                             }
5137                         }
5138                     }
5139                 }
5140             }
5141             //alerted surprise
5142             if (Person::players[i]->aitype == attacktypecutoff && musictype != 2) {
5143                 if (Person::players[i]->creature != wolftype) {
5144                     Person::players[i]->stunned = .6;
5145                     Person::players[i]->surprised = .6;
5146                 }
5147                 if (Person::players[i]->creature == wolftype) {
5148                     Person::players[i]->stunned = .47;
5149                     Person::players[i]->surprised = .47;
5150                 }
5151                 numseen++;
5152             }
5153         }
5154
5155         //search for player
5156         int j;
5157         if (Person::players[i]->aitype == searchtype) {
5158             Person::players[i]->aiupdatedelay -= multiplier;
5159             Person::players[i]->losupdatedelay -= multiplier;
5160             if (!Person::players[i]->pause)
5161                 Person::players[i]->lastseentime -= multiplier;
5162             Person::players[i]->lastchecktime -= multiplier;
5163
5164             if (Person::players[i]->isRun() && !Person::players[i]->onground) {
5165                 if (Person::players[i]->coords.y > terrain.getHeight(Person::players[i]->coords.x, Person::players[i]->coords.z) + 10) {
5166                     XYZ test2 = Person::players[i]->coords + Person::players[i]->facing;
5167                     test2.y += 5;
5168                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
5169                     test.y -= 10;
5170                     j = checkcollide(test2, test, Person::players[i]->laststanding);
5171                     if (j == -1)
5172                         j = checkcollide(test2, test);
5173                     if (j == -1) {
5174                         Person::players[i]->velocity = 0;
5175                         Person::players[i]->setAnimation(Person::players[i]->getStop());
5176                         Person::players[i]->targetyaw += 180;
5177                         Person::players[i]->stunned = .5;
5178                         //Person::players[i]->aitype=passivetype;
5179                         Person::players[i]->aitype = pathfindtype;
5180                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5181                         Person::players[i]->finalpathfindpoint = -1;
5182                         Person::players[i]->targetpathfindpoint = -1;
5183                         Person::players[i]->lastpathfindpoint = -1;
5184                         Person::players[i]->lastpathfindpoint2 = -1;
5185                         Person::players[i]->lastpathfindpoint3 = -1;
5186                         Person::players[i]->lastpathfindpoint4 = -1;
5187                     } else
5188                         Person::players[i]->laststanding = j;
5189                 }
5190             }
5191             //check out last seen location
5192             if (Person::players[i]->aiupdatedelay < 0) {
5193                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[i]->lastseen);
5194                 Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5195                 Person::players[i]->aiupdatedelay = .05;
5196                 Person::players[i]->forwardkeydown = 1;
5197
5198                 if (distsqflat(&Person::players[i]->coords, &Person::players[i]->lastseen) < 1 * sq(Person::players[i]->scale * 5) || Person::players[i]->lastchecktime < 0) {
5199                     Person::players[i]->forwardkeydown = 0;
5200                     Person::players[i]->aiupdatedelay = 1;
5201                     Person::players[i]->lastseen.x += (float(Random() % 100) - 50) / 25;
5202                     Person::players[i]->lastseen.z += (float(Random() % 100) - 50) / 25;
5203                     Person::players[i]->lastchecktime = 3;
5204                 }
5205
5206                 Person::players[i]->leftkeydown = 0;
5207                 Person::players[i]->backkeydown = 0;
5208                 Person::players[i]->rightkeydown = 0;
5209                 Person::players[i]->crouchkeydown = 0;
5210                 Person::players[i]->attackkeydown = 0;
5211                 Person::players[i]->throwkeydown = 0;
5212
5213                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5214                     if (!Person::players[i]->avoidsomething)
5215                         Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5216                     else {
5217                         XYZ leftpos, rightpos;
5218                         float leftdist, rightdist;
5219                         leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5220                         rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5221                         leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5222                         rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5223                         if (leftdist < rightdist)
5224                             Person::players[i]->targetyaw += 90;
5225                         else
5226                             Person::players[i]->targetyaw -= 90;
5227                     }
5228                 }
5229             }
5230             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5231                 Person::players[i]->jumpkeydown = 0;
5232             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5233                 Person::players[i]->jumpkeydown = 1;
5234
5235             if (numenvsounds > 0 && ((tutoriallevel != 1 || cananger) && hostile))
5236                 for (int k = 0; k < numenvsounds; k++) {
5237                     if (distsq(&Person::players[i]->coords, &envsound[k]) < 2 * (envsoundvol[k] + envsoundvol[k] * (Person::players[i]->creature == rabbittype) * 3)) {
5238                         Person::players[i]->aitype = attacktypecutoff;
5239                     }
5240                 }
5241
5242             if (!Person::players[0]->dead &&
5243                     Person::players[i]->losupdatedelay < 0 &&
5244                     !editorenabled &&
5245                     Person::players[i]->occluded < 2 &&
5246                     ((tutoriallevel != 1 || cananger) && hostile)) {
5247                 Person::players[i]->losupdatedelay = .2;
5248                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 4 && animation[Person::players[i]->animTarget].height != lowheight) {
5249                     Person::players[i]->aitype = attacktypecutoff;
5250                     Person::players[i]->lastseentime = 1;
5251                 }
5252                 if (abs(Random() % 2) || animation[Person::players[i]->animTarget].height != lowheight)
5253                     //TODO: factor out canSeePlayer()
5254                     if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400)
5255                         if (normaldotproduct(Person::players[i]->facing, Person::players[0]->coords - Person::players[i]->coords) > 0)
5256                             if ((checkcollide(
5257                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
5258                                         Person::players[i]->scale + Person::players[i]->coords,
5259                                         DoRotation(Person::players[0]->jointPos(head), 0, Person::players[0]->yaw, 0)*
5260                                         Person::players[0]->scale + Person::players[0]->coords) == -1) ||
5261                                     (Person::players[0]->animTarget == hanganim && normaldotproduct(
5262                                          Person::players[0]->facing, Person::players[i]->coords - Person::players[0]->coords) < 0)) {
5263                                 /* //TODO: changed j to 0 on a whim, make sure this is correct
5264                                 (Person::players[j]->animTarget==hanganim&&normaldotproduct(
5265                                     Person::players[j]->facing,Person::players[i]->coords-Person::players[j]->coords)<0)
5266                                 */
5267                                 Person::players[i]->aitype = attacktypecutoff;
5268                                 Person::players[i]->lastseentime = 1;
5269                             }
5270             }
5271             //player escaped
5272             if (Person::players[i]->lastseentime < 0) {
5273                 //Person::players[i]->aitype=passivetype;
5274                 numescaped++;
5275                 Person::players[i]->aitype = pathfindtype;
5276                 Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5277                 Person::players[i]->finalpathfindpoint = -1;
5278                 Person::players[i]->targetpathfindpoint = -1;
5279                 Person::players[i]->lastpathfindpoint = -1;
5280                 Person::players[i]->lastpathfindpoint2 = -1;
5281                 Person::players[i]->lastpathfindpoint3 = -1;
5282                 Person::players[i]->lastpathfindpoint4 = -1;
5283             }
5284         }
5285
5286         if (Person::players[i]->aitype != gethelptype)
5287             Person::players[i]->runninghowlong = 0;
5288
5289         //get help from buddies
5290         if (Person::players[i]->aitype == gethelptype) {
5291             Person::players[i]->runninghowlong += multiplier;
5292             Person::players[i]->aiupdatedelay -= multiplier;
5293
5294             if (Person::players[i]->aiupdatedelay < 0 || Person::players[i]->ally == 0) {
5295                 Person::players[i]->aiupdatedelay = .2;
5296
5297                 //find closest ally
5298                 //TODO: factor out closest search somehow
5299                 if (!Person::players[i]->ally) {
5300                     int closest = -1;
5301                     float closestdist = -1;
5302                     for (unsigned k = 0; k < Person::players.size(); k++) {
5303                         if (k != i && k != 0 && !Person::players[k]->dead &&
5304                                 Person::players[k]->howactive < typedead1 &&
5305                                 !Person::players[k]->skeleton.free &&
5306                                 Person::players[k]->aitype == passivetype) {
5307                             float distance = distsq(&Person::players[i]->coords, &Person::players[k]->coords);
5308                             if (closestdist == -1 || distance < closestdist) {
5309                                 closestdist = distance;
5310                                 closest = k;
5311                             }
5312                             closest = k;
5313                         }
5314                     }
5315                     if (closest != -1)
5316                         Person::players[i]->ally = closest;
5317                     else
5318                         Person::players[i]->ally = 0;
5319                     Person::players[i]->lastseen = Person::players[0]->coords;
5320                     Person::players[i]->lastseentime = 12;
5321                 }
5322
5323
5324                 Person::players[i]->lastchecktime = 12;
5325
5326                 XYZ facing = Person::players[i]->coords;
5327                 XYZ flatfacing = Person::players[Person::players[i]->ally]->coords;
5328                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
5329                 flatfacing.y += Person::players[Person::players[i]->ally]->jointPos(head).y * Person::players[Person::players[i]->ally]->scale;
5330                 if (-1 != checkcollide(facing, flatfacing))
5331                     Person::players[i]->lastseentime -= .1;
5332
5333                 //no available ally, run back to player
5334                 if (Person::players[i]->ally <= 0 ||
5335                         Person::players[Person::players[i]->ally]->skeleton.free ||
5336                         Person::players[Person::players[i]->ally]->aitype != passivetype ||
5337                         Person::players[i]->lastseentime <= 0) {
5338                     Person::players[i]->aitype = searchtype;
5339                     Person::players[i]->lastseentime = 12;
5340                 }
5341
5342                 //seek out ally
5343                 if (Person::players[i]->ally > 0) {
5344                     Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[Person::players[i]->ally]->coords);
5345                     Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5346                     Person::players[i]->aiupdatedelay = .05;
5347                     Person::players[i]->forwardkeydown = 1;
5348
5349                     if (distsqflat(&Person::players[i]->coords, &Person::players[Person::players[i]->ally]->coords) < 3) {
5350                         Person::players[i]->aitype = searchtype;
5351                         Person::players[i]->lastseentime = 12;
5352                         Person::players[Person::players[i]->ally]->aitype = searchtype;
5353                         if (Person::players[Person::players[i]->ally]->lastseentime < Person::players[i]->lastseentime) {
5354                             Person::players[Person::players[i]->ally]->lastseen = Person::players[i]->lastseen;
5355                             Person::players[Person::players[i]->ally]->lastseentime = Person::players[i]->lastseentime;
5356                             Person::players[Person::players[i]->ally]->lastchecktime = Person::players[i]->lastchecktime;
5357                         }
5358                     }
5359
5360                     if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5361                         if (!Person::players[i]->avoidsomething)
5362                             Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5363                         else {
5364                             XYZ leftpos, rightpos;
5365                             float leftdist, rightdist;
5366                             leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5367                             rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5368                             leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5369                             rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5370                             if (leftdist < rightdist)
5371                                 Person::players[i]->targetyaw += 90;
5372                             else
5373                                 Person::players[i]->targetyaw -= 90;
5374                         }
5375                     }
5376                 }
5377
5378                 Person::players[i]->leftkeydown = 0;
5379                 Person::players[i]->backkeydown = 0;
5380                 Person::players[i]->rightkeydown = 0;
5381                 Person::players[i]->crouchkeydown = 0;
5382                 Person::players[i]->attackkeydown = 0;
5383             }
5384             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5385                 Person::players[i]->jumpkeydown = 0;
5386             if (Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5)
5387                 Person::players[i]->jumpkeydown = 1;
5388         }
5389
5390         //retreiving a weapon on the ground
5391         if (Person::players[i]->aitype == getweapontype) {
5392             Person::players[i]->aiupdatedelay -= multiplier;
5393             Person::players[i]->lastchecktime -= multiplier;
5394
5395             if (Person::players[i]->aiupdatedelay < 0) {
5396                 Person::players[i]->aiupdatedelay = .2;
5397
5398                 //ALLY IS WEPON
5399                 if (Person::players[i]->ally < 0) {
5400                     int closest = -1;
5401                     float closestdist = -1;
5402                     for (unsigned k = 0; k < weapons.size(); k++)
5403                         if (weapons[k].owner == -1) {
5404                             float distance = distsq(&Person::players[i]->coords, &weapons[k].position);
5405                             if (closestdist == -1 || distance < closestdist) {
5406                                 closestdist = distance;
5407                                 closest = k;
5408                             }
5409                             closest = k;
5410                         }
5411                     if (closest != -1)
5412                         Person::players[i]->ally = closest;
5413                     else
5414                         Person::players[i]->ally = -1;
5415                 }
5416
5417                 Person::players[i]->lastseentime = 12;
5418
5419                 if (!Person::players[0]->dead && ((tutoriallevel != 1 || cananger) && hostile))
5420                     if (Person::players[i]->ally < 0 || Person::players[i]->weaponactive != -1 || Person::players[i]->lastchecktime <= 0) {
5421                         Person::players[i]->aitype = attacktypecutoff;
5422                         Person::players[i]->lastseentime = 1;
5423                     }
5424                 if (!Person::players[0]->dead)
5425                     if (Person::players[i]->ally >= 0) {
5426                         if (weapons[Person::players[i]->ally].owner != -1 ||
5427                                 distsq(&Person::players[i]->coords, &weapons[Person::players[i]->ally].position) > 16) {
5428                             Person::players[i]->aitype = attacktypecutoff;
5429                             Person::players[i]->lastseentime = 1;
5430                         }
5431                         //TODO: factor these out as moveToward()
5432                         Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[Person::players[i]->ally].position);
5433                         Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5434                         Person::players[i]->aiupdatedelay = .05;
5435                         Person::players[i]->forwardkeydown = 1;
5436
5437
5438                         if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5439                             if (!Person::players[i]->avoidsomething)
5440                                 Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5441                             else {
5442                                 XYZ leftpos, rightpos;
5443                                 float leftdist, rightdist;
5444                                 leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5445                                 rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5446                                 leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5447                                 rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5448                                 if (leftdist < rightdist)
5449                                     Person::players[i]->targetyaw += 90;
5450                                 else
5451                                     Person::players[i]->targetyaw -= 90;
5452                             }
5453                         }
5454                     }
5455
5456                 Person::players[i]->leftkeydown = 0;
5457                 Person::players[i]->backkeydown = 0;
5458                 Person::players[i]->rightkeydown = 0;
5459                 Person::players[i]->attackkeydown = 0;
5460                 Person::players[i]->throwkeydown = 1;
5461                 Person::players[i]->crouchkeydown = 0;
5462                 if (Person::players[i]->animTarget != crouchremoveknifeanim &&
5463                         Person::players[i]->animTarget != removeknifeanim)
5464                     Person::players[i]->throwtogglekeydown = 0;
5465                 Person::players[i]->drawkeydown = 0;
5466             }
5467             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5468                 Person::players[i]->jumpkeydown = 0;
5469             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5470                 Person::players[i]->jumpkeydown = 1;
5471         }
5472
5473         if (Person::players[i]->aitype == attacktypecutoff) {
5474             Person::players[i]->aiupdatedelay -= multiplier;
5475             //dodge or reverse rabbit kicks, knife throws, flips
5476             if (Person::players[i]->damage < Person::players[i]->damagetolerance * 2 / 3)
5477                 if ((Person::players[0]->animTarget == rabbitkickanim ||
5478                         Person::players[0]->animTarget == knifethrowanim ||
5479                         (Person::players[0]->isFlip() &&
5480                          normaldotproduct(Person::players[0]->facing, Person::players[0]->coords - Person::players[i]->coords) < 0)) &&
5481                         !Person::players[0]->skeleton.free &&
5482                         (Person::players[i]->aiupdatedelay < .1)) {
5483                     Person::players[i]->attackkeydown = 0;
5484                     if (Person::players[i]->isIdle())
5485                         Person::players[i]->crouchkeydown = 1;
5486                     if (Person::players[0]->animTarget != rabbitkickanim && Person::players[0]->weaponactive != -1) {
5487                         if (weapons[Person::players[0]->weaponids[0]].getType() == knife) {
5488                             if (Person::players[i]->isIdle() || Person::players[i]->isCrouch() || Person::players[i]->isRun() || Person::players[i]->isFlip()) {
5489                                 if (abs(Random() % 2) == 0)
5490                                     Person::players[i]->setAnimation(backhandspringanim);
5491                                 else
5492                                     Person::players[i]->setAnimation(rollanim);
5493                                 Person::players[i]->targetyaw += 90 * (abs(Random() % 2) * 2 - 1);
5494                                 Person::players[i]->wentforweapon = 0;
5495                             }
5496                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim)
5497                                 Person::players[i]->setAnimation(flipanim);
5498                         }
5499                     }
5500                     Person::players[i]->forwardkeydown = 0;
5501                     Person::players[i]->aiupdatedelay = .02;
5502                 }
5503             //get confused by flips
5504             if (Person::players[0]->isFlip() &&
5505                     !Person::players[0]->skeleton.free &&
5506                     Person::players[0]->animTarget != walljumprightkickanim &&
5507                     Person::players[0]->animTarget != walljumpleftkickanim) {
5508                 if (distsq(&Person::players[0]->coords, &Person::players[i]->coords) < 25)
5509                     if ((1 - Person::players[i]->damage / Person::players[i]->damagetolerance) > .5)
5510                         Person::players[i]->stunned = 1;
5511             }
5512             //go for weapon on the ground
5513             if (Person::players[i]->wentforweapon < 3)
5514                 for (unsigned k = 0; k < weapons.size(); k++)
5515                     if (Person::players[i]->creature != wolftype)
5516                         if (Person::players[i]->num_weapons == 0 &&
5517                                 weapons[k].owner == -1 &&
5518                                 weapons[i].velocity.x == 0 &&
5519                                 weapons[i].velocity.z == 0 &&
5520                                 weapons[i].velocity.y == 0) {
5521                             if (distsq(&Person::players[i]->coords, &weapons[k].position) < 16) {
5522                                 Person::players[i]->wentforweapon++;
5523                                 Person::players[i]->lastchecktime = 6;
5524                                 Person::players[i]->aitype = getweapontype;
5525                                 Person::players[i]->ally = -1;
5526                             }
5527                         }
5528             //dodge/reverse walljump kicks
5529             if (Person::players[i]->damage < Person::players[i]->damagetolerance / 2)
5530                 if (animation[Person::players[i]->animTarget].height != highheight)
5531                     if (Person::players[i]->damage < Person::players[i]->damagetolerance * .5 &&
5532                             ((Person::players[0]->animTarget == walljumprightkickanim ||
5533                               Person::players[0]->animTarget == walljumpleftkickanim) &&
5534                              ((Person::players[i]->aiupdatedelay < .15 &&
5535                                difficulty == 2) ||
5536                               (Person::players[i]->aiupdatedelay < .08 &&
5537                                difficulty != 2)))) {
5538                         Person::players[i]->crouchkeydown = 1;
5539                     }
5540             //walked off a ledge (?)
5541             if (Person::players[i]->isRun() && !Person::players[i]->onground)
5542                 if (Person::players[i]->coords.y > terrain.getHeight(Person::players[i]->coords.x, Person::players[i]->coords.z) + 10) {
5543                     XYZ test2 = Person::players[i]->coords + Person::players[i]->facing;
5544                     test2.y += 5;
5545                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
5546                     test.y -= 10;
5547                     j = checkcollide(test2, test, Person::players[i]->laststanding);
5548                     if (j == -1)
5549                         j = checkcollide(test2, test);
5550                     if (j == -1) {
5551                         Person::players[i]->velocity = 0;
5552                         Person::players[i]->setAnimation(Person::players[i]->getStop());
5553                         Person::players[i]->targetyaw += 180;
5554                         Person::players[i]->stunned = .5;
5555                         Person::players[i]->aitype = pathfindtype;
5556                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5557                         Person::players[i]->finalpathfindpoint = -1;
5558                         Person::players[i]->targetpathfindpoint = -1;
5559                         Person::players[i]->lastpathfindpoint = -1;
5560                         Person::players[i]->lastpathfindpoint2 = -1;
5561                         Person::players[i]->lastpathfindpoint3 = -1;
5562                         Person::players[i]->lastpathfindpoint4 = -1;
5563                     } else
5564                         Person::players[i]->laststanding = j;
5565                 }
5566             //lose sight of player in the air (?)
5567             if (Person::players[0]->coords.y > Person::players[i]->coords.y + 5 &&
5568                     animation[Person::players[0]->animTarget].height != highheight &&
5569                     !Person::players[0]->onterrain) {
5570                 Person::players[i]->aitype = pathfindtype;
5571                 Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5572                 Person::players[i]->finalpathfindpoint = -1;
5573                 Person::players[i]->targetpathfindpoint = -1;
5574                 Person::players[i]->lastpathfindpoint = -1;
5575                 Person::players[i]->lastpathfindpoint2 = -1;
5576                 Person::players[i]->lastpathfindpoint3 = -1;
5577                 Person::players[i]->lastpathfindpoint4 = -1;
5578             }
5579             //it's time to think (?)
5580             if (Person::players[i]->aiupdatedelay < 0 &&
5581                     !animation[Person::players[i]->animTarget].attack &&
5582                     Person::players[i]->animTarget != staggerbackhighanim &&
5583                     Person::players[i]->animTarget != staggerbackhardanim &&
5584                     Person::players[i]->animTarget != backhandspringanim &&
5585                     Person::players[i]->animTarget != dodgebackanim) {
5586                 //draw weapon
5587                 if (Person::players[i]->weaponactive == -1 && Person::players[i]->num_weapons > 0)
5588                     Person::players[i]->drawkeydown = Random() % 2;
5589                 else
5590                     Person::players[i]->drawkeydown = 0;
5591                 Person::players[i]->rabbitkickenabled = Random() % 2;
5592                 //chase player
5593                 XYZ rotatetarget = Person::players[0]->coords + Person::players[0]->velocity;
5594                 XYZ targetpoint = Person::players[0]->coords;
5595                 if (distsq(&Person::players[0]->coords, &Person::players[i]->coords) <
5596                         distsq(&rotatetarget, &Person::players[i]->coords))
5597                     targetpoint += Person::players[0]->velocity *
5598                                    findDistance(&Person::players[0]->coords, &Person::players[i]->coords) / findLength(&Person::players[i]->velocity);
5599                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, targetpoint);
5600                 Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5601                 Person::players[i]->aiupdatedelay = .2 + fabs((float)(Random() % 100) / 1000);
5602
5603                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 5 && (Person::players[0]->weaponactive == -1 || Person::players[i]->weaponactive != -1))
5604                     Person::players[i]->forwardkeydown = 1;
5605                 else if ((distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 16 ||
5606                           distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 9) &&
5607                          Person::players[0]->weaponactive != -1)
5608                     Person::players[i]->forwardkeydown = 1;
5609                 else if (Random() % 6 == 0 || (Person::players[i]->creature == wolftype && Random() % 3 == 0))
5610                     Person::players[i]->forwardkeydown = 1;
5611                 else
5612                     Person::players[i]->forwardkeydown = 0;
5613                 //chill out around the corpse
5614                 if (Person::players[0]->dead) {
5615                     Person::players[i]->forwardkeydown = 0;
5616                     if (Random() % 10 == 0)
5617                         Person::players[i]->forwardkeydown = 1;
5618                     if (Random() % 100 == 0) {
5619                         Person::players[i]->aitype = pathfindtype;
5620                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5621                         Person::players[i]->finalpathfindpoint = -1;
5622                         Person::players[i]->targetpathfindpoint = -1;
5623                         Person::players[i]->lastpathfindpoint = -1;
5624                         Person::players[i]->lastpathfindpoint2 = -1;
5625                         Person::players[i]->lastpathfindpoint3 = -1;
5626                         Person::players[i]->lastpathfindpoint4 = -1;
5627                     }
5628                 }
5629                 Person::players[i]->leftkeydown = 0;
5630                 Person::players[i]->backkeydown = 0;
5631                 Person::players[i]->rightkeydown = 0;
5632                 Person::players[i]->crouchkeydown = 0;
5633                 Person::players[i]->throwkeydown = 0;
5634
5635                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8)
5636                     Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5637                 //attack!!!
5638                 if (Random() % 2 == 0 || Person::players[i]->weaponactive != -1 || Person::players[i]->creature == wolftype)
5639                     Person::players[i]->attackkeydown = 1;
5640                 else
5641                     Person::players[i]->attackkeydown = 0;
5642                 if (Person::players[i]->isRun() && Random() % 6 && distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 7)
5643                     Person::players[i]->attackkeydown = 0;
5644
5645                 //TODO: wat
5646                 if (Person::players[i]->aitype != playercontrolled &&
5647                         (Person::players[i]->isIdle() ||
5648                          Person::players[i]->isCrouch() ||
5649                          Person::players[i]->isRun())) {
5650                     int target = -2;
5651                     for (unsigned j = 0; j < Person::players.size(); j++)
5652                         if (j != i && !Person::players[j]->skeleton.free &&
5653                                 Person::players[j]->hasvictim &&
5654                                 (tutoriallevel == 1 && reversaltrain ||
5655                                  Random() % 2 == 0 && difficulty == 2 ||
5656                                  Random() % 4 == 0 && difficulty == 1 ||
5657                                  Random() % 8 == 0 && difficulty == 0 ||
5658                                  Person::players[j]->lastattack2 == Person::players[j]->animTarget &&
5659                                  Person::players[j]->lastattack3 == Person::players[j]->animTarget &&
5660                                  (Random() % 2 == 0 || difficulty == 2) ||
5661                                  (Person::players[i]->isIdle() || Person::players[i]->isRun()) &&
5662                                  Person::players[j]->weaponactive != -1 ||
5663                                  Person::players[j]->animTarget == swordslashanim &&
5664                                  Person::players[i]->weaponactive != -1 ||
5665                                  Person::players[j]->animTarget == staffhitanim ||
5666                                  Person::players[j]->animTarget == staffspinhitanim))
5667                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 4 &&
5668                                     Person::players[j]->victim == Person::players[i] &&
5669                                     (Person::players[j]->animTarget == sweepanim ||
5670                                      Person::players[j]->animTarget == spinkickanim ||
5671                                      Person::players[j]->animTarget == staffhitanim ||
5672                                      Person::players[j]->animTarget == staffspinhitanim ||
5673                                      Person::players[j]->animTarget == winduppunchanim ||
5674                                      Person::players[j]->animTarget == upunchanim ||
5675                                      Person::players[j]->animTarget == wolfslapanim ||
5676                                      Person::players[j]->animTarget == knifeslashstartanim ||
5677                                      Person::players[j]->animTarget == swordslashanim &&
5678                                      (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2 ||
5679                                       Person::players[i]->weaponactive != -1))) {
5680                                 if (target >= 0)
5681                                     target = -1;
5682                                 else
5683                                     target = j;
5684                             }
5685                     if (target >= 0)
5686                         Person::players[target]->Reverse();
5687                 }
5688
5689                 if (Person::players[i]->collided < 1)
5690                     Person::players[i]->jumpkeydown = 0;
5691                 if (Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5 ||
5692                         distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 400 &&
5693                         Person::players[i]->onterrain &&
5694                         Person::players[i]->creature == rabbittype)
5695                     Person::players[i]->jumpkeydown = 1;
5696                 //TODO: why are we controlling the human?
5697                 if (normaldotproduct(Person::players[i]->facing, Person::players[0]->coords - Person::players[i]->coords) > 0)
5698                     Person::players[0]->jumpkeydown = 0;
5699                 if (Person::players[0]->animTarget == jumpdownanim &&
5700                         distsq(&Person::players[0]->coords, &Person::players[i]->coords) < 40)
5701                     Person::players[i]->crouchkeydown = 1;
5702                 if (Person::players[i]->jumpkeydown)
5703                     Person::players[i]->attackkeydown = 0;
5704
5705                 if (tutoriallevel == 1)
5706                     if (!canattack)
5707                         Person::players[i]->attackkeydown = 0;
5708
5709
5710                 XYZ facing = Person::players[i]->coords;
5711                 XYZ flatfacing = Person::players[0]->coords;
5712                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
5713                 flatfacing.y += Person::players[0]->jointPos(head).y * Person::players[0]->scale;
5714                 if (Person::players[i]->occluded >= 2)
5715                     if (-1 != checkcollide(facing, flatfacing)) {
5716                         if (!Person::players[i]->pause)
5717                             Person::players[i]->lastseentime -= .2;
5718                         if (Person::players[i]->lastseentime <= 0 &&
5719                                 (Person::players[i]->creature != wolftype ||
5720                                  Person::players[i]->weaponstuck == -1)) {
5721                             Person::players[i]->aitype = searchtype;
5722                             Person::players[i]->lastchecktime = 12;
5723                             Person::players[i]->lastseen = Person::players[0]->coords;
5724                             Person::players[i]->lastseentime = 12;
5725                         }
5726                     } else
5727                         Person::players[i]->lastseentime = 1;
5728             }
5729         }
5730         if (animation[Person::players[0]->animTarget].height == highheight &&
5731                 (Person::players[i]->aitype == attacktypecutoff ||
5732                  Person::players[i]->aitype == searchtype))
5733             if (Person::players[0]->coords.y > terrain.getHeight(Person::players[0]->coords.x, Person::players[0]->coords.z) + 10) {
5734                 XYZ test = Person::players[0]->coords;
5735                 test.y -= 40;
5736                 if (-1 == checkcollide(Person::players[0]->coords, test))
5737                     Person::players[i]->stunned = 1;
5738             }
5739         //stunned
5740         if (Person::players[i]->aitype == passivetype && !(Person::players[i]->numwaypoints > 1) ||
5741                 Person::players[i]->stunned > 0 ||
5742                 Person::players[i]->pause && Person::players[i]->damage > Person::players[i]->superpermanentdamage) {
5743             if (Person::players[i]->pause)
5744                 Person::players[i]->lastseentime = 1;
5745             Person::players[i]->targetyaw = Person::players[i]->yaw;
5746             Person::players[i]->forwardkeydown = 0;
5747             Person::players[i]->leftkeydown = 0;
5748             Person::players[i]->backkeydown = 0;
5749             Person::players[i]->rightkeydown = 0;
5750             Person::players[i]->jumpkeydown = 0;
5751             Person::players[i]->attackkeydown = 0;
5752             Person::players[i]->crouchkeydown = 0;
5753             Person::players[i]->throwkeydown = 0;
5754         }
5755
5756
5757         XYZ facing;
5758         facing = 0;
5759         facing.z = -1;
5760
5761         XYZ flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
5762         facing = flatfacing;
5763
5764         if (Person::players[i]->aitype == attacktypecutoff) {
5765             Person::players[i]->targetheadyaw = 180 - roughDirectionTo(Person::players[i]->coords, Person::players[0]->coords);
5766             Person::players[i]->targetheadpitch = pitchTo(Person::players[i]->coords, Person::players[0]->coords);
5767         } else if (Person::players[i]->howactive >= typesleeping) {
5768             Person::players[i]->targetheadyaw = Person::players[i]->targetyaw;
5769             Person::players[i]->targetheadpitch = 0;
5770         } else {
5771             if (Person::players[i]->interestdelay <= 0) {
5772                 Person::players[i]->interestdelay = .7 + (float)(abs(Random() % 100)) / 100;
5773                 Person::players[i]->headtarget = Person::players[i]->coords;
5774                 Person::players[i]->headtarget.x += (float)(abs(Random() % 200) - 100) / 100;
5775                 Person::players[i]->headtarget.z += (float)(abs(Random() % 200) - 100) / 100;
5776                 Person::players[i]->headtarget.y += (float)(abs(Random() % 200) - 100) / 300;
5777                 Person::players[i]->headtarget += Person::players[i]->facing * 1.5;
5778             }
5779             Person::players[i]->targetheadyaw = 180 - roughDirectionTo(Person::players[i]->coords, Person::players[i]->headtarget);
5780             Person::players[i]->targetheadpitch = pitchTo(Person::players[i]->coords, Person::players[i]->headtarget);
5781         }
5782     }
5783 }
5784
5785
5786
5787 void updateSettingsMenu()
5788 {
5789     char sbuf[256];
5790     if ((float)newscreenwidth > (float)newscreenheight * 1.61 || (float)newscreenwidth < (float)newscreenheight * 1.59)
5791         sprintf (sbuf, "Resolution: %d*%d", (int)newscreenwidth, (int)newscreenheight);
5792     else
5793         sprintf (sbuf, "Resolution: %d*%d (widescreen)", (int)newscreenwidth, (int)newscreenheight);
5794     Menu::setText(0, sbuf);
5795     Menu::setText(14, fullscreen ? "Fullscreen: On" : "Fullscreen: Off");
5796     if (newdetail == 0) Menu::setText(1, "Detail: Low");
5797     if (newdetail == 1) Menu::setText(1, "Detail: Medium");
5798     if (newdetail == 2) Menu::setText(1, "Detail: High");
5799     if (bloodtoggle == 0) Menu::setText(2, "Blood: Off");
5800     if (bloodtoggle == 1) Menu::setText(2, "Blood: On, low detail");
5801     if (bloodtoggle == 2) Menu::setText(2, "Blood: On, high detail (slower)");
5802     if (difficulty == 0) Menu::setText(3, "Difficulty: Easier");
5803     if (difficulty == 1) Menu::setText(3, "Difficulty: Difficult");
5804     if (difficulty == 2) Menu::setText(3, "Difficulty: Insane");
5805     Menu::setText(4, ismotionblur ? "Blur Effects: Enabled (less compatible)" : "Blur Effects: Disabled (more compatible)");
5806     Menu::setText(5, decals ? "Decals: Enabled (slower)" : "Decals: Disabled");
5807     Menu::setText(6, musictoggle ? "Music: Enabled" : "Music: Disabled");
5808     Menu::setText(9, invertmouse ? "Invert mouse: Yes" : "Invert mouse: No");
5809     sprintf (sbuf, "Mouse Speed: %d", (int)(usermousesensitivity * 5));
5810     Menu::setText(10, sbuf);
5811     sprintf (sbuf, "Volume: %d%%", (int)(volume * 100));
5812     Menu::setText(11, sbuf);
5813     Menu::setText(13, showdamagebar ? "Damage Bar: On" : "Damage Bar: Off");
5814     if (newdetail == detail && newscreenheight == (int)screenheight && newscreenwidth == (int)screenwidth)
5815         sprintf (sbuf, "Back");
5816     else
5817         sprintf (sbuf, "Back (some changes take effect next time Lugaru is opened)");
5818     Menu::setText(8, sbuf);
5819 }
5820
5821 void updateStereoConfigMenu()
5822 {
5823     char sbuf[256];
5824     sprintf(sbuf, "Stereo mode: %s", StereoModeName(newstereomode));
5825     Menu::setText(0, sbuf);
5826     sprintf(sbuf, "Stereo separation: %.3f", stereoseparation);
5827     Menu::setText(1, sbuf);
5828     sprintf(sbuf, "Reverse stereo: %s", stereoreverse ? "Yes" : "No");
5829     Menu::setText(2, sbuf);
5830 }
5831
5832 void updateControlsMenu()
5833 {
5834     Menu::setText(0, (string)"Forwards: " + (keyselect == 0 ? "_" : Input::keyToChar(forwardkey)));
5835     Menu::setText(1, (string)"Back: "    + (keyselect == 1 ? "_" : Input::keyToChar(backkey)));
5836     Menu::setText(2, (string)"Left: "    + (keyselect == 2 ? "_" : Input::keyToChar(leftkey)));
5837     Menu::setText(3, (string)"Right: "   + (keyselect == 3 ? "_" : Input::keyToChar(rightkey)));
5838     Menu::setText(4, (string)"Crouch: "  + (keyselect == 4 ? "_" : Input::keyToChar(crouchkey)));
5839     Menu::setText(5, (string)"Jump: "    + (keyselect == 5 ? "_" : Input::keyToChar(jumpkey)));
5840     Menu::setText(6, (string)"Draw: "    + (keyselect == 6 ? "_" : Input::keyToChar(drawkey)));
5841     Menu::setText(7, (string)"Throw: "   + (keyselect == 7 ? "_" : Input::keyToChar(throwkey)));
5842     Menu::setText(8, (string)"Attack: "  + (keyselect == 8 ? "_" : Input::keyToChar(attackkey)));
5843     if (debugmode)
5844         Menu::setText(9, (string)"Console: " + (keyselect == 9 ? "_" : Input::keyToChar(consolekey)));
5845 }
5846
5847 /*
5848 Values of mainmenu :
5849 1 Main menu
5850 2 Menu pause (resume/end game)
5851 3 Option menu
5852 4 Controls configuration menu
5853 5 Main game menu (choose level or challenge)
5854 6 Deleting user menu
5855 7 User managment menu (select/add)
5856 8 Choose difficulty menu
5857 9 Challenge level selection menu
5858 10 End of the campaign congratulation (is that really a menu?)
5859 11 Same that 9 ??? => unused
5860 18 stereo configuration
5861 */
5862
5863 void Game::LoadMenu()
5864 {
5865     Menu::clearMenu();
5866     switch (mainmenu) {
5867     case 1:
5868     case 2:
5869         Menu::addImage(0, Mainmenuitems[0], 150, 480 - 128, 256, 128);
5870         Menu::addButtonImage(1, Mainmenuitems[mainmenu == 1 ? 1 : 5], 18, 480 - 152 - 32, 128, 32);
5871         Menu::addButtonImage(2, Mainmenuitems[2], 18, 480 - 228 - 32, 112, 32);
5872         Menu::addButtonImage(3, Mainmenuitems[mainmenu == 1 ? 3 : 6], 18, 480 - 306 - 32, mainmenu == 1 ? 68 : 132, 32);
5873         break;
5874     case 3:
5875         Menu::addButton( 0, "", 10 + 20, 440);
5876         Menu::addButton(14, "", 10 + 400, 440);
5877         Menu::addButton( 1, "", 10 + 60, 405);
5878         Menu::addButton( 2, "", 10 + 70, 370);
5879         Menu::addButton( 3, "", 10 + 20 - 1000, 335 - 1000);
5880         Menu::addButton( 4, "", 10   , 335);
5881         Menu::addButton( 5, "", 10 + 60, 300);
5882         Menu::addButton( 6, "", 10 + 70, 265);
5883         Menu::addButton( 9, "", 10   , 230);
5884         Menu::addButton(10, "", 20   , 195);
5885         Menu::addButton(11, "", 10 + 60, 160);
5886         Menu::addButton(13, "", 30   , 125);
5887         Menu::addButton( 7, "-Configure Controls-", 10 + 15, 90);
5888         Menu::addButton(12, "-Configure Stereo -", 10 + 15, 55);
5889         Menu::addButton(8, "Back", 10, 10);
5890         updateSettingsMenu();
5891         break;
5892     case 4:
5893         Menu::addButton(0, "", 10   , 400);
5894         Menu::addButton(1, "", 10 + 40, 360);
5895         Menu::addButton(2, "", 10 + 40, 320);
5896         Menu::addButton(3, "", 10 + 30, 280);
5897         Menu::addButton(4, "", 10 + 20, 240);
5898         Menu::addButton(5, "", 10 + 40, 200);
5899         Menu::addButton(6, "", 10 + 40, 160);
5900         Menu::addButton(7, "", 10 + 30, 120);
5901         Menu::addButton(8, "", 10 + 20, 80);
5902         if (debugmode)
5903             Menu::addButton(9, "", 10 + 10, 40);
5904         Menu::addButton(debugmode ? 10 : 9, "Back", 10, 10);
5905         updateControlsMenu();
5906         break;
5907     case 5: {
5908         LoadCampaign();
5909         Menu::addLabel(-1, accountactive->getName(), 5, 400);
5910         Menu::addButton(1, "Tutorial", 5, 300);
5911         Menu::addButton(2, "Challenge", 5, 240);
5912         Menu::addButton(3, "Delete User", 400, 10);
5913         Menu::addButton(4, "Main Menu", 5, 10);
5914         Menu::addButton(5, "Change User", 5, 180);
5915         Menu::addButton(6, "Campaign : " + accountactive->getCurrentCampaign(), 200, 420);
5916
5917         //show campaign map
5918         //with (2,-5) offset from old code
5919         Menu::addImage(-1, Mainmenuitems[7], 150 + 2, 60 - 5, 400, 400);
5920         //show levels
5921         int numlevels = accountactive->getCampaignChoicesMade();
5922         numlevels += numlevels > 0 ? campaignlevels[numlevels - 1].nextlevel.size() : 1;
5923         for (int i = 0; i < numlevels; i++) {
5924             XYZ midpoint = campaignlevels[i].getCenter();
5925             float itemsize = campaignlevels[i].getWidth();
5926             const bool active = i >= accountactive->getCampaignChoicesMade();
5927             if (!active)
5928                 itemsize /= 2;
5929
5930             if (i >= 1) {
5931                 XYZ start = campaignlevels[i - 1].getCenter();
5932                 Menu::addMapLine(start.x, start.y, midpoint.x - start.x, midpoint.y - start.y, 0.5, active ? 1 : 0.5, active ? 1 : 0.5, 0, 0);
5933             }
5934             Menu::addMapMarker(NB_CAMPAIGN_MENU_ITEM + i, Mapcircletexture,
5935                                midpoint.x - itemsize / 2, midpoint.y - itemsize / 2, itemsize, itemsize, active ? 1 : 0.5, 0, 0);
5936
5937             if (active) {
5938                 Menu::addMapLabel(-2, campaignlevels[i].description,
5939                                   campaignlevels[i].getStartX() + 10,
5940                                   campaignlevels[i].getStartY() - 4);
5941             }
5942         }
5943     }
5944     break;
5945     case 6:
5946         Menu::addLabel(-1, "Are you sure you want to delete this user?", 10, 400);
5947         Menu::addButton(1, "Yes", 10, 360);
5948         Menu::addButton(2, "No", 10, 320);
5949         break;
5950     case 7:
5951         if (Account::getNbAccounts() < 8)
5952             Menu::addButton(0, "New User", 10, 400);
5953         else
5954             Menu::addLabel(0, "No More Users", 10, 400);
5955         Menu::addLabel(-2, "", 20, 400);
5956         Menu::addButton(Account::getNbAccounts() + 1, "Back", 10, 10);
5957         for (int i = 0; i < Account::getNbAccounts(); i++)
5958             Menu::addButton(i + 1, Account::get(i)->getName(), 10, 340 - 20 * (i + 1));
5959         break;
5960     case 8:
5961         Menu::addButton(0, "Easier", 10, 400);
5962         Menu::addButton(1, "Difficult", 10, 360);
5963         Menu::addButton(2, "Insane", 10, 320);
5964         break;
5965     case 9:
5966         for (int i = 0; i < numchallengelevels; i++) {
5967             char temp[255];
5968             string name = "";
5969             sprintf (temp, "Level %d", i + 1);
5970             for (int j = strlen(temp); j < 17; j++)
5971                 strcat(temp, " ");
5972             name += temp;
5973             sprintf (temp, "%d", (int)accountactive->getHighScore(i));
5974             for (int j = strlen(temp); j < (32 - 17); j++)
5975                 strcat(temp, " ");
5976             name += temp;
5977             sprintf (temp, "%d:", (int)(((int)accountactive->getFastTime(i) - (int)(accountactive->getFastTime(i)) % 60) / 60));
5978             if ((int)(accountactive->getFastTime(i)) % 60 < 10)
5979                 strcat(temp, "0");
5980             name += temp;
5981             sprintf (temp, "%d", (int)(accountactive->getFastTime(i)) % 60);
5982             name += temp;
5983
5984             Menu::addButton(i, name, 10, 400 - i * 25, i > accountactive->getProgress() ? 0.5 : 1, 0, 0);
5985         }
5986
5987         Menu::addButton(-1, "             High Score      Best Time", 10, 440);
5988         Menu::addButton(numchallengelevels, "Back", 10, 10);
5989         break;
5990     case 10: {
5991         Menu::addLabel(0, "Congratulations!", 220, 330);
5992         Menu::addLabel(1, "You have avenged your family and", 140, 300);
5993         Menu::addLabel(2, "restored peace to the island of Lugaru.", 110, 270);
5994         Menu::addButton(3, "Back", 10, 10);
5995         char sbuf[256];
5996         sprintf(sbuf, "Your score:         %d", (int)accountactive->getCampaignScore());
5997         Menu::addLabel(4, sbuf, 190, 200);
5998         sprintf(sbuf, "Highest score:      %d", (int)accountactive->getCampaignHighScore());
5999         Menu::addLabel(5, sbuf, 190, 180);
6000     }
6001     break;
6002     case 18:
6003         Menu::addButton(0, "", 70, 400);
6004         Menu::addButton(1, "", 10, 360);
6005         Menu::addButton(2, "", 40, 320);
6006         Menu::addButton(3, "Back", 10, 10);
6007         updateStereoConfigMenu();
6008         break;
6009     }
6010 }
6011
6012 extern set<pair<int,int>> resolutions;
6013
6014 void MenuTick()
6015 {
6016     //menu buttons
6017     selected = Menu::getSelected(mousecoordh * 640 / screenwidth, 480 - mousecoordv * 480 / screenheight);
6018
6019     // some specific case where we do something even if the left mouse button is not pressed.
6020     if ((mainmenu == 5) && (endgame == 2)) {
6021         accountactive->endGame();
6022         endgame = 0;
6023     }
6024     if (mainmenu == 10)
6025         endgame = 2;
6026     if (mainmenu == 18 && Input::isKeyPressed(MOUSEBUTTON2) && selected == 1) {
6027         stereoseparation -= 0.001;
6028         updateStereoConfigMenu();
6029     }
6030
6031     static int oldmainmenu = mainmenu;
6032
6033     if (Input::MouseClicked() && (selected >= 0)) { // handling of the left mouse clic in menus
6034         set<pair<int,int>>::iterator newscreenresolution;
6035         switch (mainmenu) {
6036         case 1:
6037         case 2:
6038             switch (selected) {
6039             case 1:
6040                 if (gameon) { //resume
6041                     mainmenu = 0;
6042                     pause_sound(stream_menutheme);
6043                     resume_stream(leveltheme);
6044                 } else { //new game
6045                     fireSound(firestartsound);
6046                     flash();
6047                     mainmenu = (accountactive ? 5 : 7);
6048                     selected = -1;
6049                 }
6050                 break;
6051             case 2: //options
6052                 fireSound();
6053                 flash();
6054                 mainmenu = 3;
6055                 if (newdetail > 2)
6056                     newdetail = detail;
6057                 if (newdetail < 0)
6058                     newdetail = detail;
6059                 if (newscreenwidth > 3000)
6060                     newscreenwidth = screenwidth;
6061                 if (newscreenwidth < 0)
6062                     newscreenwidth = screenwidth;
6063                 if (newscreenheight > 3000)
6064                     newscreenheight = screenheight;
6065                 if (newscreenheight < 0)
6066                     newscreenheight = screenheight;
6067                 break;
6068             case 3:
6069                 fireSound();
6070                 flash();
6071                 if (gameon) { //end game
6072                     gameon = 0;
6073                     mainmenu = 1;
6074                 } else { //quit
6075                     tryquit = 1;
6076                     pause_sound(stream_menutheme);
6077                 }
6078                 break;
6079             }
6080             break;
6081         case 3:
6082             fireSound();
6083             switch (selected) {
6084             case 0:
6085                 newscreenresolution = resolutions.find(make_pair(newscreenwidth, newscreenheight));
6086                 /* Next one (end() + 1 is also end() so the ++ is safe even if it was not found) */
6087                 newscreenresolution++;
6088                 if (newscreenresolution == resolutions.end()) {
6089                     /* It was the last one (or not found), go back to the beginning */
6090                     newscreenresolution = resolutions.begin();
6091                 }
6092                 newscreenwidth  = newscreenresolution->first;
6093                 newscreenheight = newscreenresolution->second;
6094                 break;
6095             case 1:
6096                 newdetail++;
6097                 if (newdetail > 2)
6098                     newdetail = 0;
6099                 break;
6100             case 2:
6101                 bloodtoggle++;
6102                 if (bloodtoggle > 2)
6103                     bloodtoggle = 0;
6104                 break;
6105             case 3:
6106                 difficulty++;
6107                 if (difficulty > 2)
6108                     difficulty = 0;
6109                 break;
6110             case 4:
6111                 ismotionblur = !ismotionblur;
6112                 break;
6113             case 5:
6114                 decals = !decals;
6115                 break;
6116             case 6:
6117                 musictoggle = !musictoggle;
6118                 if (musictoggle) {
6119                     emit_stream_np(stream_menutheme);
6120                 } else {
6121                     pause_sound(leveltheme);
6122                     pause_sound(stream_fighttheme);
6123                     pause_sound(stream_menutheme);
6124
6125                     for (int i = 0; i < 4; i++) {
6126                         oldmusicvolume[i] = 0;
6127                         musicvolume[i] = 0;
6128                     }
6129                 }
6130                 break;
6131             case 7: // controls
6132                 flash();
6133                 mainmenu = 4;
6134                 selected = -1;
6135                 keyselect = -1;
6136                 break;
6137             case 8:
6138                 flash();
6139                 SaveSettings();
6140                 mainmenu = gameon ? 2 : 1;
6141                 break;
6142             case 9:
6143                 invertmouse = !invertmouse;
6144                 break;
6145             case 10:
6146                 usermousesensitivity += .2;
6147                 if (usermousesensitivity > 2)
6148                     usermousesensitivity = .2;
6149                 break;
6150             case 11:
6151                 volume += .1f;
6152                 if (volume > 1.0001f)
6153                     volume = 0;
6154                 OPENAL_SetSFXMasterVolume((int)(volume * 255));
6155                 break;
6156             case 12:
6157                 flash();
6158                 newstereomode = stereomode;
6159                 mainmenu = 18;
6160                 keyselect = -1;
6161                 break;
6162             case 13:
6163                 showdamagebar = !showdamagebar;
6164                 break;
6165             case 14:
6166                 toggleFullscreen();
6167                 break;
6168             }
6169             updateSettingsMenu();
6170             break;
6171         case 4:
6172             if (!waiting) {
6173                 fireSound();
6174                 if (selected < (debugmode ? 10 : 9) && keyselect == -1)
6175                     keyselect = selected;
6176                 if (keyselect != -1)
6177                     setKeySelected();
6178                 if (selected == (debugmode ? 10 : 9)) {
6179                     flash();
6180                     mainmenu = 3;
6181                 }
6182             }
6183             updateControlsMenu();
6184             break;
6185         case 5:
6186             fireSound();
6187             flash();
6188             if ((selected - NB_CAMPAIGN_MENU_ITEM >= accountactive->getCampaignChoicesMade())) {
6189                 startbonustotal = 0;
6190
6191                 loading = 2;
6192                 loadtime = 0;
6193                 targetlevel = 7;
6194                 if (firstload)
6195                     TickOnceAfter();
6196                 else
6197                     LoadStuff();
6198                 whichchoice = selected - NB_CAMPAIGN_MENU_ITEM - accountactive->getCampaignChoicesMade();
6199                 actuallevel = (accountactive->getCampaignChoicesMade() > 0 ? campaignlevels[accountactive->getCampaignChoicesMade() - 1].nextlevel[whichchoice] : 0);
6200                 visibleloading = 1;
6201                 stillloading = 1;
6202                 Loadlevel(campaignlevels[actuallevel].mapname.c_str());
6203                 campaign = 1;
6204                 mainmenu = 0;
6205                 gameon = 1;
6206                 pause_sound(stream_menutheme);
6207             }
6208             switch (selected) {
6209             case 1:
6210                 startbonustotal = 0;
6211
6212                 loading = 2;
6213                 loadtime = 0;
6214                 targetlevel = -1;
6215                 if (firstload) {
6216                     TickOnceAfter();
6217                 } else
6218                     LoadStuff();
6219                 Loadlevel(-1);
6220
6221                 mainmenu = 0;
6222                 gameon = 1;
6223                 pause_sound(stream_menutheme);
6224                 break;
6225             case 2:
6226                 mainmenu = 9;
6227                 break;
6228             case 3:
6229                 mainmenu = 6;
6230                 break;
6231             case 4:
6232                 mainmenu = (gameon ? 2 : 1);
6233                 break;
6234             case 5:
6235                 mainmenu = 7;
6236                 break;
6237             case 6:
6238                 vector<string> campaigns = ListCampaigns();
6239                 vector<string>::iterator c;
6240                 if ((c = find(campaigns.begin(), campaigns.end(), accountactive->getCurrentCampaign())) == campaigns.end()) {
6241                     if (!campaigns.empty())
6242                         accountactive->setCurrentCampaign(campaigns.front());
6243                 } else {
6244                     c++;
6245                     if (c == campaigns.end())
6246                         c = campaigns.begin();
6247                     accountactive->setCurrentCampaign(*c);
6248                 }
6249                 LoadMenu();
6250                 break;
6251             }
6252             break;
6253         case 6:
6254             fireSound();
6255             if (selected == 1) {
6256                 flash();
6257                 accountactive = Account::destroy(accountactive);
6258                 mainmenu = 7;
6259             } else if (selected == 2) {
6260                 flash();
6261                 mainmenu = 5;
6262             }
6263             break;
6264         case 7:
6265             fireSound();
6266             if (selected == 0 && Account::getNbAccounts() < 8) {
6267                 entername = 1;
6268             } else if (selected < Account::getNbAccounts() + 1) {
6269                 flash();
6270                 mainmenu = 5;
6271                 accountactive = Account::get(selected - 1);
6272             } else if (selected == Account::getNbAccounts() + 1) {
6273                 flash();
6274                 if (accountactive)
6275                     mainmenu = 5;
6276                 else
6277                     mainmenu = 1;
6278                 displaytext[0].clear();
6279                 displayselected = 0;
6280                 entername = 0;
6281             }
6282             break;
6283         case 8:
6284             fireSound();
6285             flash();
6286             if (selected <= 2)
6287                 accountactive->setDifficulty(selected);
6288             mainmenu = 5;
6289             break;
6290         case 9:
6291             if (selected < numchallengelevels && selected <= accountactive->getProgress()) {
6292                 fireSound();
6293                 flash();
6294
6295                 startbonustotal = 0;
6296
6297                 loading = 2;
6298                 loadtime = 0;
6299                 targetlevel = selected;
6300                 if (firstload)
6301                     TickOnceAfter();
6302                 else
6303                     LoadStuff();
6304                 Loadlevel(selected);
6305                 campaign = 0;
6306
6307                 mainmenu = 0;
6308                 gameon = 1;
6309                 pause_sound(stream_menutheme);
6310             }
6311             if (selected == numchallengelevels) {
6312                 fireSound();
6313                 flash();
6314                 mainmenu = 5;
6315             }
6316             break;
6317         case 10:
6318             if (selected == 3) {
6319                 fireSound();
6320                 flash();
6321                 mainmenu = 5;
6322             }
6323             break;
6324         case 18:
6325             if (selected == 1)
6326                 stereoseparation += 0.001;
6327             else {
6328                 fireSound();
6329                 if (selected == 0) {
6330                     newstereomode = (StereoMode)(newstereomode + 1);
6331                     while (!CanInitStereo(newstereomode)) {
6332                         printf("Failed to initialize mode %s (%i)\n", StereoModeName(newstereomode), newstereomode);
6333                         newstereomode = (StereoMode)(newstereomode + 1);
6334                         if (newstereomode >= stereoCount)
6335                             newstereomode = stereoNone;
6336                     }
6337                 } else if (selected == 2) {
6338                     stereoreverse = !stereoreverse;
6339                 } else if (selected == 3) {
6340                     flash();
6341                     mainmenu = 3;
6342
6343                     stereomode = newstereomode;
6344                     InitStereo(stereomode);
6345                 }
6346             }
6347             updateStereoConfigMenu();
6348             break;
6349         }
6350     }
6351
6352     if (Input::isKeyDown(SDL_SCANCODE_Q) && Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6353         tryquit = 1;
6354         if (mainmenu == 3) {
6355             SaveSettings();
6356         }
6357     }
6358
6359     OPENAL_SetFrequency(channels[stream_menutheme], 22050);
6360
6361     if (entername) {
6362         inputText(displaytext[0], &displayselected);
6363         if (!waiting) { // the input as finished
6364             if (!displaytext[0].empty()) { // with enter
6365                 accountactive = Account::add(string(displaytext[0]));
6366
6367                 mainmenu = 8;
6368
6369                 flash();
6370
6371                 fireSound(firestartsound);
6372
6373                 displaytext[0].clear();
6374
6375                 displayselected = 0;
6376             }
6377             entername = 0;
6378             LoadMenu();
6379         }
6380
6381         displayblinkdelay -= multiplier;
6382         if (displayblinkdelay <= 0) {
6383             displayblinkdelay = .3;
6384             displayblink = 1 - displayblink;
6385         }
6386     }
6387
6388     if (entername) {
6389         Menu::setText(0, displaytext[0], 20, 400, -1, -1);
6390         Menu::setText(-2, displayblink ? "_" : "", 20 + displayselected * 10, 400, -1, -1);
6391     }
6392
6393     if (oldmainmenu != mainmenu)
6394         LoadMenu();
6395     oldmainmenu = mainmenu;
6396
6397 }
6398
6399 void Game::Tick()
6400 {
6401     static XYZ facing, flatfacing;
6402     static int target;
6403
6404     for (int i = 0; i < 15; i++) {
6405         displaytime[i] += multiplier;
6406     }
6407
6408     keyboardfrozen = false;
6409     Input::Tick();
6410
6411     if (Input::isKeyPressed(SDL_SCANCODE_F6)) {
6412         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6413             stereoreverse = true;
6414         else
6415             stereoreverse = false;
6416
6417         if (stereoreverse)
6418             printf("Stereo reversed\n");
6419         else
6420             printf("Stereo unreversed\n");
6421     }
6422
6423     if (Input::isKeyDown(SDL_SCANCODE_F7)) {
6424         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6425             stereoseparation -= 0.001;
6426         else
6427             stereoseparation -= 0.010;
6428         printf("Stereo decreased increased to %f\n", stereoseparation);
6429     }
6430
6431     if (Input::isKeyDown(SDL_SCANCODE_F8)) {
6432         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6433             stereoseparation += 0.001;
6434         else
6435             stereoseparation += 0.010;
6436         printf("Stereo separation increased to %f\n", stereoseparation);
6437     }
6438
6439
6440     if (Input::isKeyPressed(SDL_SCANCODE_TAB) && tutoriallevel) {
6441         if (tutorialstage != 51)
6442             tutorialstagetime = tutorialmaxtime;
6443         emit_sound_np(consolefailsound, 128.);
6444     }
6445
6446     /*
6447     Values of mainmenu :
6448     1 Main menu
6449     2 Menu pause (resume/end game)
6450     3 Option menu
6451     4 Controls configuration menu
6452     5 Main game menu (choose level or challenge)
6453     6 Deleting user menu
6454     7 User managment menu (select/add)
6455     8 Choose difficulty menu
6456     9 Challenge level selection menu
6457     10 End of the campaign congratulation (is that really a menu?)
6458     11 Same that 9 ??? => unused
6459     18 stereo configuration
6460     */
6461
6462     if (!console) {
6463         //campaign over?
6464         if (mainmenu && endgame == 1)
6465             mainmenu = 10;
6466         //go to level select after completing a campaign level
6467         if (campaign && winfreeze && mainmenu == 0 && campaignlevels[actuallevel].choosenext == 1) {
6468             mainmenu = 5;
6469             gameon = 0;
6470             winfreeze = 0;
6471             fireSound();
6472             flash();
6473             if (musictoggle) {
6474                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6475                 emit_stream_np(stream_menutheme);
6476                 pause_sound(leveltheme);
6477             }
6478             LoadMenu();
6479         }
6480         //escape key pressed
6481         if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
6482                 (gameon || mainmenu == 0 || (mainmenu >= 3 && mainmenu != 8 && !(mainmenu == 7 && entername)))) {
6483             selected = -1;
6484             if (mainmenu == 0 && !winfreeze)
6485                 mainmenu = 2; //pause
6486             else if (mainmenu == 1 || mainmenu == 2) {
6487                 mainmenu = 0; //unpause
6488             }
6489             //play menu theme
6490             if (musictoggle && (mainmenu == 1 || mainmenu == 2)) {
6491                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6492                 emit_stream_np(stream_menutheme);
6493                 pause_sound(leveltheme);
6494             }
6495             //on resume, play level music
6496             if (!mainmenu) {
6497                 pause_sound(stream_menutheme);
6498                 resume_stream(leveltheme);
6499             }
6500             //finished with settings menu
6501             if (mainmenu == 3) {
6502                 SaveSettings();
6503             }
6504             //effects
6505             if (mainmenu >= 3 && mainmenu != 8) {
6506                 fireSound();
6507                 flash();
6508             }
6509             //go back
6510             switch (mainmenu) {
6511             case 3:
6512             case 5:
6513                 mainmenu = gameon ? 2 : 1;
6514                 break;
6515             case 4:
6516             case 18:
6517                 mainmenu = 3;
6518                 break;
6519             case 6:
6520             case 7:
6521             case 9:
6522             case 10:
6523                 mainmenu = 5;
6524                 break;
6525             }
6526         }
6527     }
6528
6529     if (mainmenu) {
6530         MenuTick();
6531     }
6532
6533     if (!mainmenu) {
6534         if (hostile == 1)
6535             hostiletime += multiplier;
6536         else
6537             hostiletime = 0;
6538         if (!winfreeze)
6539             leveltime += multiplier;
6540
6541         //keys
6542         if (Input::isKeyPressed(SDL_SCANCODE_V) && debugmode) {
6543             freeze = 1 - freeze;
6544             if (freeze) {
6545                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6546             }
6547         }
6548
6549         if (Input::isKeyPressed(consolekey) && debugmode) {
6550             console = !console;
6551             if (console) {
6552                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6553             } else {
6554                 freeze = 0;
6555                 waiting = false;
6556             }
6557         }
6558
6559         if (console)
6560             freeze = 1;
6561         if (console && !Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6562             inputText(consoletext[0], &consoleselected);
6563             if (!waiting) {
6564                 if (!consoletext[0].empty()) {
6565                     cmd_dispatch(consoletext[0]);
6566                     for (int k = 14; k >= 1; k--) {
6567                         consoletext[k] = consoletext[k - 1];
6568                     }
6569                     consoletext[0].clear();
6570                     consoleselected = 0;
6571                 }
6572             }
6573
6574             consoleblinkdelay -= multiplier;
6575             if (consoleblinkdelay <= 0) {
6576                 consoleblinkdelay = .3;
6577                 consoleblink = 1 - consoleblink;
6578             }
6579         }
6580
6581
6582
6583         if (Input::isKeyDown(SDL_SCANCODE_Q) && Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6584             tryquit = 1;
6585             if (mainmenu == 3) {
6586                 SaveSettings();
6587             }
6588         }
6589
6590         static int oldwinfreeze;
6591         if (winfreeze && !oldwinfreeze) {
6592             OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6593             emit_sound_np(consolesuccesssound);
6594         }
6595         if (winfreeze == 0)
6596             oldwinfreeze = winfreeze;
6597         else
6598             oldwinfreeze++;
6599
6600         if ((Input::isKeyPressed(jumpkey) || Input::isKeyPressed(SDL_SCANCODE_SPACE)) && !campaign)
6601             if (winfreeze)
6602                 winfreeze = 0;
6603         if ((Input::isKeyDown(SDL_SCANCODE_ESCAPE)) && !campaign && gameon) {
6604             if (console) {
6605                 console = false;
6606                 freeze = 0;
6607             } else if (winfreeze) {
6608                 mainmenu = 9;
6609                 gameon = 0;
6610             }
6611         }
6612
6613
6614
6615         if (!freeze && !winfreeze && !(mainmenu && gameon) && (gameon || !gamestarted)) {
6616
6617             //dialogues
6618             static float talkdelay = 0;
6619
6620             if (indialogue != -1)
6621                 talkdelay = 1;
6622             talkdelay -= multiplier;
6623
6624             if (talkdelay <= 0 && indialogue == -1 && animation[Person::players[0]->animTarget].height != highheight)
6625                 for (int i = 0; i < numdialogues; i++) {
6626                     unsigned realdialoguetype;
6627                     bool special;
6628                     /* FIXME - Seems like modulo done with ifs */
6629                     if (dialoguetype[i] > 49) {
6630                         realdialoguetype = dialoguetype[i] - 50;
6631                         special = 1;
6632                     } else if (dialoguetype[i] > 39) {
6633                         realdialoguetype = dialoguetype[i] - 40;
6634                         special = 1;
6635                     } else if (dialoguetype[i] > 29) {
6636                         realdialoguetype = dialoguetype[i] - 30;
6637                         special = 1;
6638                     } else if (dialoguetype[i] > 19) {
6639                         realdialoguetype = dialoguetype[i] - 20;
6640                         special = 1;
6641                     } else if (dialoguetype[i] > 9) {
6642                         realdialoguetype = dialoguetype[i] - 10;
6643                         special = 1;
6644                     } else {
6645                         realdialoguetype = dialoguetype[i];
6646                         special = 0;
6647                     }
6648                     if ((!hostile || dialoguetype[i] > 40 && dialoguetype[i] < 50) &&
6649                             realdialoguetype < Person::players.size() &&
6650                             realdialoguetype > 0 &&
6651                             (dialoguegonethrough[i] == 0 || !special) &&
6652                             (special || Input::isKeyPressed(attackkey))) {
6653                         if (distsq(&Person::players[0]->coords, &Person::players[realdialoguetype]->coords) < 6 ||
6654                                 Person::players[realdialoguetype]->howactive >= typedead1 ||
6655                                 dialoguetype[i] > 40 && dialoguetype[i] < 50) {
6656                             whichdialogue = i;
6657                             for (int j = 0; j < numdialogueboxes[whichdialogue]; j++) {
6658                                 Person::players[participantfocus[whichdialogue][j]]->coords = participantlocation[whichdialogue][participantfocus[whichdialogue][j]];
6659                                 Person::players[participantfocus[whichdialogue][j]]->yaw = participantyaw[whichdialogue][participantfocus[whichdialogue][j]];
6660                                 Person::players[participantfocus[whichdialogue][j]]->targetyaw = participantyaw[whichdialogue][participantfocus[whichdialogue][j]];
6661                                 Person::players[participantfocus[whichdialogue][j]]->velocity = 0;
6662                                 Person::players[participantfocus[whichdialogue][j]]->animTarget = Person::players[participantfocus[whichdialogue][j]]->getIdle();
6663                                 Person::players[participantfocus[whichdialogue][j]]->frameTarget = 0;
6664                             }
6665                             directing = 0;
6666                             indialogue = 0;
6667                             dialoguetime = 0;
6668                             dialoguegonethrough[i]++;
6669                             if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6670                                 playdialogueboxsound();
6671                             }
6672                         }
6673                     }
6674                 }
6675
6676             windvar += multiplier;
6677             smoketex += multiplier;
6678             tutorialstagetime += multiplier;
6679
6680             //hotspots
6681             static float hotspotvisual[40];
6682             if (numhotspots) {
6683                 XYZ hotspotsprite;
6684                 if (editorenabled)
6685                     for (int i = 0; i < numhotspots; i++)
6686                         hotspotvisual[i] -= multiplier / 320;
6687
6688                 for (int i = 0; i < numhotspots; i++) {
6689                     //if(hotspottype[i]<=10)
6690                     while (hotspotvisual[i] < 0) {
6691                         hotspotsprite = 0;
6692                         hotspotsprite.x = float(abs(Random() % 100000)) / 100000 * hotspotsize[i];
6693                         hotspotsprite = DoRotation(hotspotsprite, 0, 0, Random() % 360);
6694                         hotspotsprite = DoRotation(hotspotsprite, 0, Random() % 360, 0);
6695                         hotspotsprite += hotspot[i];
6696                         Sprite::MakeSprite(breathsprite, hotspotsprite, hotspotsprite * 0, 1, 0.5, 0, 7, 0.4);
6697                         hotspotvisual[i] += 0.1 / hotspotsize[i] / hotspotsize[i] / hotspotsize[i];
6698                     }
6699                 }
6700
6701                 for (int i = 0; i < numhotspots; i++) {
6702                     if (hotspottype[i] <= 10 && hotspottype[i] > 0) {
6703                         hotspot[i] = Person::players[hotspottype[i]]->coords;
6704                     }
6705                 }
6706             }
6707
6708             //Tutorial
6709             if (tutoriallevel) {
6710                 doTutorial();
6711             }
6712
6713             //bonuses
6714             if (tutoriallevel != 1) {
6715                 if (bonustime == 0 &&
6716                         bonus != solidhit &&
6717                         bonus != spinecrusher &&
6718                         bonus != tracheotomy &&
6719                         bonus != backstab &&
6720                         bonusvalue > 10) {
6721                     emit_sound_np(consolesuccesssound);
6722                 }
6723             } else if (bonustime == 0) {
6724                 emit_sound_np(fireendsound);
6725             }
6726             if (bonustime == 0) {
6727                 if (bonus != solidhit &&
6728                         bonus != twoxcombo &&
6729                         bonus != threexcombo &&
6730                         bonus != fourxcombo &&
6731                         bonus != megacombo)
6732                     bonusnum[bonus]++;
6733                 else
6734                     bonusnum[bonus] += 0.15;
6735                 if (tutoriallevel)
6736                     bonusvalue = 0;
6737                 bonusvalue /= bonusnum[bonus];
6738                 bonustotal += bonusvalue;
6739             }
6740             bonustime += multiplier;
6741
6742             //snow effects
6743             if (environment == snowyenvironment) {
6744                 precipdelay -= multiplier;
6745                 while (precipdelay < 0) {
6746                     precipdelay += .04;
6747                     if (!detail)
6748                         precipdelay += .04;
6749                     XYZ footvel, footpoint;
6750
6751                     footvel = 0;
6752                     footpoint = viewer + viewerfacing * 6;
6753                     footpoint.y += ((float)abs(Random() % 1200)) / 100 - 6;
6754                     footpoint.x += ((float)abs(Random() % 1200)) / 100 - 6;
6755                     footpoint.z += ((float)abs(Random() % 1200)) / 100 - 6;
6756                     Sprite::MakeSprite(snowsprite, footpoint, footvel, 1, 1, 1, .1, 1);
6757                 }
6758             }
6759
6760
6761             doAerialAcrobatics();
6762
6763
6764             static XYZ oldviewer;
6765
6766             //control keys
6767             if (indialogue == -1) {
6768                 Person::players[0]->forwardkeydown = Input::isKeyDown(forwardkey);
6769                 Person::players[0]->leftkeydown = Input::isKeyDown(leftkey);
6770                 Person::players[0]->backkeydown = Input::isKeyDown(backkey);
6771                 Person::players[0]->rightkeydown = Input::isKeyDown(rightkey);
6772                 Person::players[0]->jumpkeydown = Input::isKeyDown(jumpkey);
6773                 Person::players[0]->crouchkeydown = Input::isKeyDown(crouchkey);
6774                 Person::players[0]->drawkeydown = Input::isKeyDown(drawkey);
6775                 Person::players[0]->throwkeydown = Input::isKeyDown(throwkey);
6776             } else {
6777                 Person::players[0]->forwardkeydown = 0;
6778                 Person::players[0]->leftkeydown = 0;
6779                 Person::players[0]->backkeydown = 0;
6780                 Person::players[0]->rightkeydown = 0;
6781                 Person::players[0]->jumpkeydown = 0;
6782                 Person::players[0]->crouchkeydown = 0;
6783                 Person::players[0]->drawkeydown = 0;
6784                 Person::players[0]->throwkeydown = 0;
6785             }
6786
6787             if (!Person::players[0]->jumpkeydown)
6788                 Person::players[0]->jumpclimb = 0;
6789
6790
6791             if (indialogue != -1) {
6792                 cameramode = 1;
6793                 if (directing) {
6794                     facing = 0;
6795                     facing.z = -1;
6796
6797                     facing = DoRotation(facing, -pitch, 0, 0);
6798                     facing = DoRotation(facing, 0, 0 - yaw, 0);
6799
6800                     flatfacing = 0;
6801                     flatfacing.z = -1;
6802
6803                     flatfacing = DoRotation(flatfacing, 0, -yaw, 0);
6804
6805                     if (Input::isKeyDown(forwardkey))
6806                         viewer += facing * multiplier * 4;
6807                     if (Input::isKeyDown(backkey))
6808                         viewer -= facing * multiplier * 4;
6809                     if (Input::isKeyDown(leftkey))
6810                         viewer += DoRotation(flatfacing * multiplier, 0, 90, 0) * 4;
6811                     if (Input::isKeyDown(rightkey))
6812                         viewer += DoRotation(flatfacing * multiplier, 0, -90, 0) * 4;
6813                     if (Input::isKeyDown(jumpkey))
6814                         viewer.y += multiplier * 4;
6815                     if (Input::isKeyDown(crouchkey))
6816                         viewer.y -= multiplier * 4;
6817                     if (     Input::isKeyPressed(SDL_SCANCODE_1) ||
6818                              Input::isKeyPressed(SDL_SCANCODE_2) ||
6819                              Input::isKeyPressed(SDL_SCANCODE_3) ||
6820                              Input::isKeyPressed(SDL_SCANCODE_4) ||
6821                              Input::isKeyPressed(SDL_SCANCODE_5) ||
6822                              Input::isKeyPressed(SDL_SCANCODE_6) ||
6823                              Input::isKeyPressed(SDL_SCANCODE_7) ||
6824                              Input::isKeyPressed(SDL_SCANCODE_8) ||
6825                              Input::isKeyPressed(SDL_SCANCODE_9) ||
6826                              Input::isKeyPressed(SDL_SCANCODE_0) ||
6827                              Input::isKeyPressed(SDL_SCANCODE_MINUS)) {
6828                         int whichend;
6829                         if (Input::isKeyPressed(SDL_SCANCODE_1)) whichend = 1;
6830                         if (Input::isKeyPressed(SDL_SCANCODE_2)) whichend = 2;
6831                         if (Input::isKeyPressed(SDL_SCANCODE_3)) whichend = 3;
6832                         if (Input::isKeyPressed(SDL_SCANCODE_4)) whichend = 4;
6833                         if (Input::isKeyPressed(SDL_SCANCODE_5)) whichend = 5;
6834                         if (Input::isKeyPressed(SDL_SCANCODE_6)) whichend = 6;
6835                         if (Input::isKeyPressed(SDL_SCANCODE_7)) whichend = 7;
6836                         if (Input::isKeyPressed(SDL_SCANCODE_8)) whichend = 8;
6837                         if (Input::isKeyPressed(SDL_SCANCODE_9)) whichend = 9;
6838                         if (Input::isKeyPressed(SDL_SCANCODE_0)) whichend = 0;
6839                         if (Input::isKeyPressed(SDL_SCANCODE_MINUS))
6840                             whichend = -1;
6841                         if (whichend != -1) {
6842                             participantfocus[whichdialogue][indialogue] = whichend;
6843                             participantlocation[whichdialogue][whichend] = Person::players[whichend]->coords;
6844                             participantyaw[whichdialogue][whichend] = Person::players[whichend]->yaw;
6845                         }
6846                         if (whichend == -1) {
6847                             participantfocus[whichdialogue][indialogue] = -1;
6848                         }
6849                         if (Person::players[participantfocus[whichdialogue][indialogue]]->dead) {
6850                             indialogue = -1;
6851                             directing = 0;
6852                             cameramode = 0;
6853                         }
6854                         dialoguecamera[whichdialogue][indialogue] = viewer;
6855                         dialoguecamerayaw[whichdialogue][indialogue] = yaw;
6856                         dialoguecamerapitch[whichdialogue][indialogue] = pitch;
6857                         indialogue++;
6858                         if (indialogue < numdialogueboxes[whichdialogue]) {
6859                             if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6860                                 playdialogueboxsound();
6861                             }
6862                         }
6863
6864                         for (unsigned j = 0; j < Person::players.size(); j++) {
6865                             participantfacing[whichdialogue][indialogue][j] = participantfacing[whichdialogue][indialogue - 1][j];
6866                         }
6867                     }
6868                     //TODO: should these be KeyDown or KeyPressed?
6869                     if (     Input::isKeyDown(SDL_SCANCODE_KP_1) ||
6870                              Input::isKeyDown(SDL_SCANCODE_KP_2) ||
6871                              Input::isKeyDown(SDL_SCANCODE_KP_3) ||
6872                              Input::isKeyDown(SDL_SCANCODE_KP_4) ||
6873                              Input::isKeyDown(SDL_SCANCODE_KP_5) ||
6874                              Input::isKeyDown(SDL_SCANCODE_KP_6) ||
6875                              Input::isKeyDown(SDL_SCANCODE_KP_7) ||
6876                              Input::isKeyDown(SDL_SCANCODE_KP_8) ||
6877                              Input::isKeyDown(SDL_SCANCODE_KP_9) ||
6878                              Input::isKeyDown(SDL_SCANCODE_KP_0)) {
6879                         int whichend;
6880                         if (Input::isKeyDown(SDL_SCANCODE_KP_1)) whichend = 1;
6881                         if (Input::isKeyDown(SDL_SCANCODE_KP_2)) whichend = 2;
6882                         if (Input::isKeyDown(SDL_SCANCODE_KP_3)) whichend = 3;
6883                         if (Input::isKeyDown(SDL_SCANCODE_KP_4)) whichend = 4;
6884                         if (Input::isKeyDown(SDL_SCANCODE_KP_5)) whichend = 5;
6885                         if (Input::isKeyDown(SDL_SCANCODE_KP_6)) whichend = 6;
6886                         if (Input::isKeyDown(SDL_SCANCODE_KP_7)) whichend = 7;
6887                         if (Input::isKeyDown(SDL_SCANCODE_KP_8)) whichend = 8;
6888                         if (Input::isKeyDown(SDL_SCANCODE_KP_9)) whichend = 9;
6889                         if (Input::isKeyDown(SDL_SCANCODE_KP_0)) whichend = 0;
6890                         participantfacing[whichdialogue][indialogue][whichend] = facing;
6891                     }
6892                     if (indialogue >= numdialogueboxes[whichdialogue]) {
6893                         indialogue = -1;
6894                         directing = 0;
6895                         cameramode = 0;
6896                     }
6897                 }
6898                 if (!directing) {
6899                     pause_sound(whooshsound);
6900                     viewer = dialoguecamera[whichdialogue][indialogue];
6901                     viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .1);
6902                     yaw = dialoguecamerayaw[whichdialogue][indialogue];
6903                     pitch = dialoguecamerapitch[whichdialogue][indialogue];
6904                     if (dialoguetime > 0.5)
6905                         if (     Input::isKeyPressed(SDL_SCANCODE_1) ||
6906                                  Input::isKeyPressed(SDL_SCANCODE_2) ||
6907                                  Input::isKeyPressed(SDL_SCANCODE_3) ||
6908                                  Input::isKeyPressed(SDL_SCANCODE_4) ||
6909                                  Input::isKeyPressed(SDL_SCANCODE_5) ||
6910                                  Input::isKeyPressed(SDL_SCANCODE_6) ||
6911                                  Input::isKeyPressed(SDL_SCANCODE_7) ||
6912                                  Input::isKeyPressed(SDL_SCANCODE_8) ||
6913                                  Input::isKeyPressed(SDL_SCANCODE_9) ||
6914                                  Input::isKeyPressed(SDL_SCANCODE_0) ||
6915                                  Input::isKeyPressed(SDL_SCANCODE_MINUS) ||
6916                                  Input::isKeyPressed(attackkey)) {
6917                             indialogue++;
6918                             if (indialogue < numdialogueboxes[whichdialogue]) {
6919                                 if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6920                                     playdialogueboxsound();
6921                                     if (dialogueboxsound[whichdialogue][indialogue] == -5) {
6922                                         hotspot[numhotspots] = Person::players[0]->coords;
6923                                         hotspotsize[numhotspots] = 10;
6924                                         hotspottype[numhotspots] = -1;
6925
6926                                         numhotspots++;
6927                                     }
6928                                     if (dialogueboxsound[whichdialogue][indialogue] == -6) {
6929                                         hostile = 1;
6930                                     }
6931
6932                                     if (Person::players[participantfocus[whichdialogue][indialogue]]->dead) {
6933                                         indialogue = -1;
6934                                         directing = 0;
6935                                         cameramode = 0;
6936                                     }
6937                                 }
6938                             }
6939                         }
6940                     if (indialogue >= numdialogueboxes[whichdialogue]) {
6941                         indialogue = -1;
6942                         directing = 0;
6943                         cameramode = 0;
6944                         if (dialoguetype[whichdialogue] > 19 && dialoguetype[whichdialogue] < 30) {
6945                             hostile = 1;
6946                         }
6947                         if (dialoguetype[whichdialogue] > 29 && dialoguetype[whichdialogue] < 40) {
6948                             windialogue = true;
6949                         }
6950                         if (dialoguetype[whichdialogue] > 49 && dialoguetype[whichdialogue] < 60) {
6951                             hostile = 1;
6952                             for (unsigned i = 1; i < Person::players.size(); i++) {
6953                                 Person::players[i]->aitype = attacktypecutoff;
6954                             }
6955                         }
6956                     }
6957                 }
6958             }
6959
6960             if (!Person::players[0]->jumpkeydown) {
6961                 Person::players[0]->jumptogglekeydown = 0;
6962             }
6963             if (Person::players[0]->jumpkeydown &&
6964                     Person::players[0]->animTarget != jumpupanim &&
6965                     Person::players[0]->animTarget != jumpdownanim &&
6966                     !Person::players[0]->isFlip())
6967                 Person::players[0]->jumptogglekeydown = 1;
6968
6969
6970             dialoguetime += multiplier;
6971             hawkyaw += multiplier * 25;
6972             realhawkcoords = 0;
6973             realhawkcoords.x = 25;
6974             realhawkcoords = DoRotation(realhawkcoords, 0, hawkyaw, 0) + hawkcoords;
6975             hawkcalldelay -= multiplier / 2;
6976
6977             if (hawkcalldelay <= 0) {
6978                 emit_sound_at(hawksound, realhawkcoords);
6979
6980                 hawkcalldelay = 16 + abs(Random() % 8);
6981             }
6982
6983             doDebugKeys();
6984
6985             doAttacks();
6986
6987             doPlayerCollisions();
6988
6989             doJumpReversals();
6990
6991             for (unsigned k = 0; k < Person::players.size(); k++)
6992                 if (k != 0 && Person::players[k]->immobile)
6993                     Person::players[k]->coords = Person::players[k]->realoldcoords;
6994
6995             for (unsigned k = 0; k < Person::players.size(); k++) {
6996                 if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
6997                     if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
6998                         Person::players[k]->DoDamage(1000);
6999                     }
7000                 }
7001             }
7002
7003             //respawn
7004             static bool respawnkeydown;
7005             if (!editorenabled &&
7006                     (whichlevel != -2 &&
7007                      (Input::isKeyDown(SDL_SCANCODE_Z) &&
7008                       Input::isKeyDown(SDL_SCANCODE_LGUI) &&
7009                       debugmode) ||
7010                      (Input::isKeyDown(jumpkey) &&
7011                       !respawnkeydown &&
7012                       !oldattackkey &&
7013                       Person::players[0]->dead))) {
7014                 targetlevel = whichlevel;
7015                 loading = 1;
7016                 leveltime = 5;
7017             }
7018             if (!Input::isKeyDown(jumpkey))
7019                 respawnkeydown = 0;
7020             if (Input::isKeyDown(jumpkey))
7021                 respawnkeydown = 1;
7022
7023
7024
7025
7026             static bool movekey;
7027
7028             //?
7029             for (unsigned i = 0; i < Person::players.size(); i++) {
7030                 static float oldtargetyaw;
7031                 if (!Person::players[i]->skeleton.free) {
7032                     oldtargetyaw = Person::players[i]->targetyaw;
7033                     if (i == 0 && indialogue == -1) {
7034                         //TODO: refactor repetitive code
7035                         if (!animation[Person::players[0]->animTarget].attack &&
7036                                 Person::players[0]->animTarget != staggerbackhighanim &&
7037                                 Person::players[0]->animTarget != staggerbackhardanim &&
7038                                 Person::players[0]->animTarget != crouchremoveknifeanim &&
7039                                 Person::players[0]->animTarget != removeknifeanim &&
7040                                 Person::players[0]->animTarget != backhandspringanim &&
7041                                 Person::players[0]->animTarget != dodgebackanim &&
7042                                 Person::players[0]->animTarget != walljumprightkickanim &&
7043                                 Person::players[0]->animTarget != walljumpleftkickanim) {
7044                             if (cameramode)
7045                                 Person::players[0]->targetyaw = 0;
7046                             else
7047                                 Person::players[0]->targetyaw = -yaw + 180;
7048                         }
7049
7050                         facing = 0;
7051                         facing.z = -1;
7052
7053                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
7054                         if (cameramode) {
7055                             facing = flatfacing;
7056                         } else {
7057                             facing = DoRotation(facing, -pitch, 0, 0);
7058                             facing = DoRotation(facing, 0, 0 - yaw, 0);
7059                         }
7060
7061                         Person::players[0]->lookyaw = -yaw;
7062
7063                         Person::players[i]->targetheadyaw = yaw;
7064                         Person::players[i]->targetheadpitch = pitch;
7065                     }
7066                     if (i != 0 && Person::players[i]->aitype == playercontrolled && indialogue == -1) {
7067                         if (!animation[Person::players[i]->animTarget].attack &&
7068                                 Person::players[i]->animTarget != staggerbackhighanim &&
7069                                 Person::players[i]->animTarget != staggerbackhardanim &&
7070                                 Person::players[i]->animTarget != crouchremoveknifeanim &&
7071                                 Person::players[i]->animTarget != removeknifeanim &&
7072                                 Person::players[i]->animTarget != backhandspringanim &&
7073                                 Person::players[i]->animTarget != dodgebackanim &&
7074                                 Person::players[i]->animTarget != walljumprightkickanim &&
7075                                 Person::players[i]->animTarget != walljumpleftkickanim) {
7076                             Person::players[i]->targetyaw = -Person::players[i]->lookyaw + 180;
7077                         }
7078
7079                         facing = 0;
7080                         facing.z = -1;
7081
7082                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
7083
7084                         facing = DoRotation(facing, -Person::players[i]->lookpitch, 0, 0);
7085                         facing = DoRotation(facing, 0, 0 - Person::players[i]->lookyaw, 0);
7086
7087                         Person::players[i]->targetheadyaw = Person::players[i]->lookyaw;
7088                         Person::players[i]->targetheadpitch = Person::players[i]->lookpitch;
7089                     }
7090                     if (indialogue != -1) {
7091                         Person::players[i]->targetheadyaw = 180 - roughDirection(participantfacing[whichdialogue][indialogue][i]);
7092                         Person::players[i]->targetheadpitch = pitchOf(participantfacing[whichdialogue][indialogue][i]);
7093                     }
7094
7095                     if (leveltime < .5)
7096                         numenvsounds = 0;
7097
7098                     Person::players[i]->avoidsomething = 0;
7099
7100                     //avoid flaming things
7101                     for (int j = 0; j < objects.numobjects; j++)
7102                         if (objects.onfire[j])
7103                             if (distsq(&Person::players[i]->coords, &objects.position[j]) < sq(objects.scale[j]) * 200)
7104                                 if (     distsq(&Person::players[i]->coords, &objects.position[j]) <
7105                                          distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
7106                                     Person::players[i]->collided = 0;
7107                                     Person::players[i]->avoidcollided = 1;
7108                                     if (Person::players[i]->avoidsomething == 0 ||
7109                                             distsq(&Person::players[i]->coords, &objects.position[j]) <
7110                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
7111                                         Person::players[i]->avoidwhere = objects.position[j];
7112                                         Person::players[i]->avoidsomething = 1;
7113                                     }
7114                                 }
7115
7116                     //avoid flaming players
7117                     for (unsigned j = 0; j < Person::players.size(); j++)
7118                         if (Person::players[j]->onfire)
7119                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < sq(0.3) * 200)
7120                                 if (     distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
7121                                          distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
7122                                     Person::players[i]->collided = 0;
7123                                     Person::players[i]->avoidcollided = 1;
7124                                     if (Person::players[i]->avoidsomething == 0 ||
7125                                             distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
7126                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
7127                                         Person::players[i]->avoidwhere = Person::players[j]->coords;
7128                                         Person::players[i]->avoidsomething = 1;
7129                                     }
7130                                 }
7131
7132                     if (Person::players[i]->collided > .8)
7133                         Person::players[i]->avoidcollided = 0;
7134
7135                     doAI(i);
7136
7137                     if (animation[Person::players[i]->animTarget].attack == reversed) {
7138                         //Person::players[i]->targetyaw=Person::players[i]->yaw;
7139                         Person::players[i]->forwardkeydown = 0;
7140                         Person::players[i]->leftkeydown = 0;
7141                         Person::players[i]->backkeydown = 0;
7142                         Person::players[i]->rightkeydown = 0;
7143                         Person::players[i]->jumpkeydown = 0;
7144                         Person::players[i]->attackkeydown = 0;
7145                         //Person::players[i]->crouchkeydown=0;
7146                         Person::players[i]->throwkeydown = 0;
7147                     }
7148
7149                     if (indialogue != -1) {
7150                         Person::players[i]->forwardkeydown = 0;
7151                         Person::players[i]->leftkeydown = 0;
7152                         Person::players[i]->backkeydown = 0;
7153                         Person::players[i]->rightkeydown = 0;
7154                         Person::players[i]->jumpkeydown = 0;
7155                         Person::players[i]->crouchkeydown = 0;
7156                         Person::players[i]->drawkeydown = 0;
7157                         Person::players[i]->throwkeydown = 0;
7158                     }
7159
7160                     if (Person::players[i]->collided < -.3)
7161                         Person::players[i]->collided = -.3;
7162                     if (Person::players[i]->collided > 1)
7163                         Person::players[i]->collided = 1;
7164                     Person::players[i]->collided -= multiplier * 4;
7165                     Person::players[i]->whichdirectiondelay -= multiplier;
7166                     if (Person::players[i]->avoidcollided < -.3 || Person::players[i]->whichdirectiondelay <= 0) {
7167                         Person::players[i]->avoidcollided = -.3;
7168                         Person::players[i]->whichdirection = abs(Random() % 2);
7169                         Person::players[i]->whichdirectiondelay = .4;
7170                     }
7171                     if (Person::players[i]->avoidcollided > 1)
7172                         Person::players[i]->avoidcollided = 1;
7173                     Person::players[i]->avoidcollided -= multiplier / 4;
7174                     if (!Person::players[i]->skeleton.free) {
7175                         Person::players[i]->stunned -= multiplier;
7176                         Person::players[i]->surprised -= multiplier;
7177                     }
7178                     if (i != 0 && Person::players[i]->surprised <= 0 &&
7179                             Person::players[i]->aitype == attacktypecutoff &&
7180                             !Person::players[i]->dead &&
7181                             !Person::players[i]->skeleton.free &&
7182                             animation[Person::players[i]->animTarget].attack == neutral)
7183                         numresponded = 1;
7184
7185                     if (!Person::players[i]->throwkeydown)
7186                         Person::players[i]->throwtogglekeydown = 0;
7187
7188                     //pick up weapon
7189                     if (Person::players[i]->throwkeydown && !Person::players[i]->throwtogglekeydown) {
7190                         if (Person::players[i]->weaponactive == -1 &&
7191                                 Person::players[i]->num_weapons < 2 &&
7192                                 (Person::players[i]->isIdle() ||
7193                                  Person::players[i]->isCrouch() ||
7194                                  Person::players[i]->animTarget == sneakanim ||
7195                                  Person::players[i]->animTarget == rollanim ||
7196                                  Person::players[i]->animTarget == backhandspringanim ||
7197                                  Person::players[i]->isFlip() ||
7198                                  Person::players[i]->aitype != playercontrolled)) {
7199                             for (unsigned j = 0; j < weapons.size(); j++) {
7200                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
7201                                         Person::players[i]->aitype == playercontrolled) &&
7202                                         weapons[j].owner == -1 &&
7203                                         Person::players[i]->weaponactive == -1)
7204                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2) {
7205                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 2) {
7206                                             if (Person::players[i]->isCrouch() ||
7207                                                     Person::players[i]->animTarget == sneakanim ||
7208                                                     Person::players[i]->isRun() ||
7209                                                     Person::players[i]->isIdle() ||
7210                                                     Person::players[i]->aitype != playercontrolled) {
7211                                                 Person::players[i]->throwtogglekeydown = 1;
7212                                                 Person::players[i]->setAnimation(crouchremoveknifeanim);
7213                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
7214                                                 Person::players[i]->hasvictim = 0;
7215                                             }
7216                                             if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
7217                                                 Person::players[i]->throwtogglekeydown = 1;
7218                                                 Person::players[i]->hasvictim = 0;
7219
7220                                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
7221                                                         Person::players[i]->aitype == playercontrolled) &&
7222                                                         weapons[j].owner == -1 ||
7223                                                         Person::players[i]->victim &&
7224                                                         weapons[j].owner == int(Person::players[i]->victim->id))
7225                                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2 && Person::players[i]->weaponactive == -1)
7226                                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 1 || Person::players[i]->victim) {
7227                                                             if (weapons[j].getType() != staff)
7228                                                                 emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7229
7230                                                             Person::players[i]->weaponactive = 0;
7231                                                             weapons[j].owner = Person::players[i]->id;
7232                                                             if (Person::players[i]->num_weapons > 0)
7233                                                                 Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7234                                                             Person::players[i]->num_weapons++;
7235                                                             Person::players[i]->weaponids[0] = j;
7236                                                         }
7237                                             }
7238                                         } else if ((Person::players[i]->isIdle() ||
7239                                                     Person::players[i]->isFlip() ||
7240                                                     Person::players[i]->aitype != playercontrolled) &&
7241                                                    distsq(&Person::players[i]->coords, &weapons[j].position) < 5 &&
7242                                                    Person::players[i]->coords.y < weapons[j].position.y) {
7243                                             if (!Person::players[i]->isFlip()) {
7244                                                 Person::players[i]->throwtogglekeydown = 1;
7245                                                 Person::players[i]->setAnimation(removeknifeanim);
7246                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
7247                                             }
7248                                             if (Person::players[i]->isFlip()) {
7249                                                 Person::players[i]->throwtogglekeydown = 1;
7250                                                 Person::players[i]->hasvictim = 0;
7251
7252                                                 for (unsigned k = 0; k < weapons.size(); k++) {
7253                                                     if (Person::players[i]->weaponactive == -1)
7254                                                         if ((weapons[k].velocity.x == 0 && weapons[k].velocity.y == 0 && weapons[k].velocity.z == 0 ||
7255                                                                 Person::players[i]->aitype == playercontrolled) &&
7256                                                                 weapons[k].owner == -1 ||
7257                                                                 Person::players[i]->victim &&
7258                                                                 weapons[k].owner == int(Person::players[i]->victim->id))
7259                                                             if (distsqflat(&Person::players[i]->coords, &weapons[k].position) < 3 &&
7260                                                                     Person::players[i]->weaponactive == -1) {
7261                                                                 if (weapons[k].getType() != staff)
7262                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7263
7264                                                                 Person::players[i]->weaponactive = 0;
7265                                                                 weapons[k].owner = Person::players[i]->id;
7266                                                                 if (Person::players[i]->num_weapons > 0)
7267                                                                     Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7268                                                                 Person::players[i]->num_weapons++;
7269                                                                 Person::players[i]->weaponids[0] = k;
7270                                                             }
7271                                                 }
7272                                             }
7273                                         }
7274                                     }
7275                             }
7276                             if (Person::players[i]->isCrouch() ||
7277                                     Person::players[i]->animTarget == sneakanim ||
7278                                     Person::players[i]->isRun() ||
7279                                     Person::players[i]->isIdle() || Person::players[i]->animTarget == rollanim ||
7280                                     Person::players[i]->animTarget == backhandspringanim) {
7281                                 if (Person::players.size() > 1)
7282                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7283                                         if (Person::players[i]->weaponactive == -1)
7284                                             if (j != i)
7285                                                 if (Person::players[j]->num_weapons &&
7286                                                         Person::players[j]->skeleton.free &&
7287                                                         distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 2/*&&Person::players[j]->dead*/ &&
7288                                                         (((Person::players[j]->skeleton.forward.y < 0 &&
7289                                                            Person::players[j]->weaponstuckwhere == 0) ||
7290                                                           (Person::players[j]->skeleton.forward.y > 0 &&
7291                                                            Person::players[j]->weaponstuckwhere == 1)) ||
7292                                                          Person::players[j]->weaponstuck == -1 ||
7293                                                          Person::players[j]->num_weapons > 1)) {
7294                                                     if (Person::players[i]->animTarget != rollanim && Person::players[i]->animTarget != backhandspringanim) {
7295                                                         Person::players[i]->throwtogglekeydown = 1;
7296                                                         Person::players[i]->victim = Person::players[j];
7297                                                         Person::players[i]->hasvictim = 1;
7298                                                         Person::players[i]->setAnimation(crouchremoveknifeanim);
7299                                                         Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
7300                                                     }
7301                                                     if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
7302                                                         Person::players[i]->throwtogglekeydown = 1;
7303                                                         Person::players[i]->victim = Person::players[j];
7304                                                         Person::players[i]->hasvictim = 1;
7305                                                         int k = Person::players[j]->weaponids[0];
7306                                                         if (Person::players[i]->hasvictim) {
7307                                                             bool fleshstuck;
7308                                                             fleshstuck = 0;
7309                                                             if (Person::players[i]->victim->weaponstuck != -1) {
7310                                                                 if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
7311                                                                     fleshstuck = 1;
7312                                                                 }
7313                                                             }
7314                                                             if (!fleshstuck) {
7315                                                                 if (weapons[k].getType() != staff)
7316                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7317                                                             }
7318                                                             if (fleshstuck)
7319                                                                 emit_sound_at(fleshstabremovesound, Person::players[i]->coords, 128.);
7320
7321                                                             Person::players[i]->weaponactive = 0;
7322                                                             if (weapons[k].owner != -1) {
7323                                                                 if (Person::players[i]->victim->num_weapons == 1)
7324                                                                     Person::players[i]->victim->num_weapons = 0;
7325                                                                 else
7326                                                                     Person::players[i]->victim->num_weapons = 1;
7327
7328                                                                 Person::players[i]->victim->skeleton.longdead = 0;
7329                                                                 Person::players[i]->victim->skeleton.free = 1;
7330                                                                 Person::players[i]->victim->skeleton.broken = 0;
7331
7332                                                                 for (int l = 0; l < Person::players[i]->victim->skeleton.num_joints; l++) {
7333                                                                     Person::players[i]->victim->skeleton.joints[l].velchange = 0;
7334                                                                     Person::players[i]->victim->skeleton.joints[l].locked = 0;
7335                                                                 }
7336
7337                                                                 XYZ relative;
7338                                                                 relative = 0;
7339                                                                 relative.y = 10;
7340                                                                 Normalise(&relative);
7341                                                                 XYZ footvel, footpoint;
7342                                                                 footvel = 0;
7343                                                                 footpoint = weapons[k].position;
7344                                                                 if (Person::players[i]->victim->weaponstuck != -1) {
7345                                                                     if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
7346                                                                         if (bloodtoggle)
7347                                                                             Sprite::MakeSprite(cloudimpactsprite, footpoint, footvel, 1, 0, 0, .8, .3);
7348                                                                         weapons[k].bloody = 2;
7349                                                                         weapons[k].blooddrip = 5;
7350                                                                         Person::players[i]->victim->weaponstuck = -1;
7351                                                                         Person::players[i]->victim->bloodloss += 2000;
7352                                                                         Person::players[i]->victim->DoDamage(2000);
7353                                                                     }
7354                                                                 }
7355                                                                 if (Person::players[i]->victim->num_weapons > 0) {
7356                                                                     if (Person::players[i]->victim->weaponstuck != 0 && Person::players[i]->victim->weaponstuck != -1)
7357                                                                         Person::players[i]->victim->weaponstuck = 0;
7358                                                                     if (Person::players[i]->victim->weaponids[0] == k)
7359                                                                         Person::players[i]->victim->weaponids[0] = Person::players[i]->victim->weaponids[Person::players[i]->victim->num_weapons];
7360                                                                 }
7361
7362                                                                 Person::players[i]->victim->weaponactive = -1;
7363
7364                                                                 Person::players[i]->victim->jointVel(abdomen) += relative * 6;
7365                                                                 Person::players[i]->victim->jointVel(neck) += relative * 6;
7366                                                                 Person::players[i]->victim->jointVel(rightshoulder) += relative * 6;
7367                                                                 Person::players[i]->victim->jointVel(leftshoulder) += relative * 6;
7368                                                             }
7369                                                             weapons[k].owner = i;
7370                                                             if (Person::players[i]->num_weapons > 0) {
7371                                                                 Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7372                                                             }
7373                                                             Person::players[i]->num_weapons++;
7374                                                             Person::players[i]->weaponids[0] = k;
7375                                                         }
7376                                                     }
7377                                                 }
7378                                     }
7379                             }
7380                         }
7381                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
7382                             if (weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7383                                 if (Person::players[i]->isIdle() ||
7384                                         Person::players[i]->isRun() ||
7385                                         Person::players[i]->isCrouch() ||
7386                                         Person::players[i]->animTarget == sneakanim ||
7387                                         Person::players[i]->isFlip())
7388                                     if (Person::players.size() > 1)
7389                                         for (unsigned j = 0; j < Person::players.size(); j++) {
7390                                             if (i != j)
7391                                                 if (tutoriallevel != 1 || tutorialstage == 49)
7392                                                     if (hostile)
7393                                                         if (normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0 &&
7394                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
7395                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
7396                                                                 !Person::players[j]->skeleton.free &&
7397                                                                 -1 == 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)) {
7398                                                             if (!Person::players[i]->isFlip()) {
7399                                                                 Person::players[i]->throwtogglekeydown = 1;
7400                                                                 Person::players[i]->victim = Person::players[j];
7401                                                                 Person::players[i]->setAnimation(knifethrowanim);
7402                                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
7403                                                                 Person::players[i]->targettilt2 = pitchTo(Person::players[i]->coords, Person::players[j]->coords);
7404                                                             }
7405                                                             if (Person::players[i]->isFlip()) {
7406                                                                 if (Person::players[i]->weaponactive != -1) {
7407                                                                     Person::players[i]->throwtogglekeydown = 1;
7408                                                                     Person::players[i]->victim = Person::players[j];
7409                                                                     XYZ aim;
7410                                                                     weapons[Person::players[i]->weaponids[0]].owner = -1;
7411                                                                     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);
7412                                                                     Normalise(&aim);
7413
7414                                                                     aim = DoRotation(aim, (float)abs(Random() % 30) - 15, (float)abs(Random() % 30) - 15, 0);
7415
7416                                                                     weapons[Person::players[i]->weaponids[0]].velocity = aim * 50;
7417                                                                     weapons[Person::players[i]->weaponids[0]].tipvelocity = aim * 50;
7418                                                                     weapons[Person::players[i]->weaponids[0]].missed = 0;
7419                                                                     weapons[Person::players[i]->weaponids[0]].freetime = 0;
7420                                                                     weapons[Person::players[i]->weaponids[0]].firstfree = 1;
7421                                                                     weapons[Person::players[i]->weaponids[0]].physics = 0;
7422                                                                     Person::players[i]->num_weapons--;
7423                                                                     if (Person::players[i]->num_weapons) {
7424                                                                         Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
7425                                                                     }
7426                                                                     Person::players[i]->weaponactive = -1;
7427                                                                 }
7428                                                             }
7429                                                         }
7430                                         }
7431                             }
7432                         }
7433                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
7434                             if (Person::players[i]->isCrouch() || Person::players[i]->animTarget == sneakanim) {
7435                                 Person::players[i]->throwtogglekeydown = 1;
7436                                 weapons[Person::players[i]->weaponids[0]].owner = -1;
7437                                 weapons[Person::players[i]->weaponids[0]].velocity = Person::players[i]->velocity * .2;
7438                                 if (weapons[Person::players[i]->weaponids[0]].velocity.x == 0)
7439                                     weapons[Person::players[i]->weaponids[0]].velocity.x = .1;
7440                                 weapons[Person::players[i]->weaponids[0]].tipvelocity = weapons[Person::players[i]->weaponids[0]].velocity;
7441                                 weapons[Person::players[i]->weaponids[0]].missed = 1;
7442                                 weapons[Person::players[i]->weaponids[0]].freetime = 0;
7443                                 weapons[Person::players[i]->weaponids[0]].firstfree = 1;
7444                                 weapons[Person::players[i]->weaponids[0]].physics = 1;
7445                                 Person::players[i]->num_weapons--;
7446                                 if (Person::players[i]->num_weapons) {
7447                                     Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
7448                                     if (Person::players[i]->weaponstuck == Person::players[i]->num_weapons)
7449                                         Person::players[i]->weaponstuck = 0;
7450                                 }
7451
7452                                 Person::players[i]->weaponactive = -1;
7453                                 for (unsigned j = 0; j < Person::players.size(); j++) {
7454                                     Person::players[j]->wentforweapon = 0;
7455                                 }
7456                             }
7457                         }
7458
7459                     }
7460
7461                     //draw weapon
7462                     if (i == 0 || !Person::players[0]->dead || (Person::players[i]->weaponactive != -1)) {
7463                         if (Person::players[i]->drawkeydown && !Person::players[i]->drawtogglekeydown ||
7464                                 (Person::players[i]->num_weapons == 2) &&
7465                                 (Person::players[i]->weaponactive == -1) &&
7466                                 Person::players[i]->isIdle() ||
7467                                 Person::players[0]->dead &&
7468                                 (Person::players[i]->weaponactive != -1) &&
7469                                 i != 0) {
7470                             bool isgood = true;
7471                             if (Person::players[i]->weaponactive != -1)
7472                                 if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == staff)
7473                                     isgood = false;
7474                             if (isgood && Person::players[i]->creature != wolftype) {
7475                                 if (Person::players[i]->isIdle() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7476                                     Person::players[i]->setAnimation(drawrightanim);
7477                                     Person::players[i]->drawtogglekeydown = 1;
7478                                 }
7479                                 if ((Person::players[i]->isIdle() ||
7480                                         (Person::players[i]->aitype != playercontrolled &&
7481                                          Person::players[0]->weaponactive != -1 &&
7482                                          Person::players[i]->isRun())) &&
7483                                         Person::players[i]->num_weapons &&
7484                                         weapons[Person::players[i]->weaponids[0]].getType() == sword) {
7485                                     Person::players[i]->setAnimation(drawleftanim);
7486                                     Person::players[i]->drawtogglekeydown = 1;
7487                                 }
7488                                 if (Person::players[i]->isCrouch() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7489                                     Person::players[i]->setAnimation(crouchdrawrightanim);
7490                                     Person::players[i]->drawtogglekeydown = 1;
7491                                 }
7492                             }
7493                         }
7494                     }
7495
7496                     //clean weapon
7497                     if (Person::players[i]->weaponactive != -1) {
7498                         if (Person::players[i]->isCrouch() &&
7499                                 weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
7500                                 bloodtoggle &&
7501                                 Person::players[i]->onterrain &&
7502                                 Person::players[i]->num_weapons &&
7503                                 Person::players[i]->attackkeydown &&
7504                                 musictype != stream_fighttheme) {
7505                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == knife)
7506                                 Person::players[i]->setAnimation(crouchstabanim);
7507                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == sword)
7508                                 Person::players[i]->setAnimation(swordgroundstabanim);
7509                             Person::players[i]->hasvictim = 0;
7510                         }
7511                     }
7512
7513                     if (!Person::players[i]->drawkeydown)
7514                         Person::players[i]->drawtogglekeydown = 0;
7515
7516                     XYZ absflatfacing;
7517                     if (i == 0) {
7518                         absflatfacing = 0;
7519                         absflatfacing.z = -1;
7520
7521                         absflatfacing = DoRotation(absflatfacing, 0, -yaw, 0);
7522                     } else
7523                         absflatfacing = flatfacing;
7524
7525                     if (indialogue != -1) {
7526                         Person::players[i]->forwardkeydown = 0;
7527                         Person::players[i]->leftkeydown = 0;
7528                         Person::players[i]->backkeydown = 0;
7529                         Person::players[i]->rightkeydown = 0;
7530                         Person::players[i]->jumpkeydown = 0;
7531                         Person::players[i]->crouchkeydown = 0;
7532                         Person::players[i]->drawkeydown = 0;
7533                         Person::players[i]->throwkeydown = 0;
7534                     }
7535                     movekey = 0;
7536                     //Do controls
7537                     if (!animation[Person::players[i]->animTarget].attack &&
7538                             Person::players[i]->animTarget != staggerbackhighanim &&
7539                             Person::players[i]->animTarget != staggerbackhardanim &&
7540                             Person::players[i]->animTarget != backhandspringanim &&
7541                             Person::players[i]->animTarget != dodgebackanim) {
7542                         if (!Person::players[i]->forwardkeydown)
7543                             Person::players[i]->forwardstogglekeydown = 0;
7544                         if (Person::players[i]->crouchkeydown) {
7545                             //Crouch
7546                             target = -2;
7547                             if (i == 0) {
7548                                 Person::players[i]->superruntoggle = 1;
7549                                 if (Person::players.size() > 1)
7550                                     for (unsigned j = 0; j < Person::players.size(); j++)
7551                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->aitype == passivetype)
7552                                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 16)
7553                                                 Person::players[i]->superruntoggle = 0;
7554                             }
7555
7556                             if (Person::players.size() > 1)
7557                                 for (unsigned j = 0; j < Person::players.size(); j++) {
7558                                     if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim && Person::players[i]->lowreversaldelay <= 0) {
7559                                         if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7560                                                 Person::players[j]->victim == Person::players[i] &&
7561                                                 (Person::players[j]->animTarget == sweepanim ||
7562                                                  Person::players[j]->animTarget == upunchanim ||
7563                                                  Person::players[j]->animTarget == wolfslapanim ||
7564                                                  ((Person::players[j]->animTarget == swordslashanim ||
7565                                                    Person::players[j]->animTarget == knifeslashstartanim ||
7566                                                    Person::players[j]->animTarget == staffhitanim ||
7567                                                    Person::players[j]->animTarget == staffspinhitanim) &&
7568                                                   distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2))) {
7569                                             if (target >= 0)
7570                                                 target = -1;
7571                                             else
7572                                                 target = j;
7573                                         }
7574                                     }
7575                                 }
7576                             if (target >= 0)
7577                                 Person::players[target]->Reverse();
7578                             Person::players[i]->lowreversaldelay = .5;
7579
7580                             if (Person::players[i]->isIdle()) {
7581                                 Person::players[i]->setAnimation(Person::players[i]->getCrouch());
7582                                 Person::players[i]->transspeed = 10;
7583                             }
7584                             if (Person::players[i]->isRun() ||
7585                                     (Person::players[i]->isStop() &&
7586                                      (Person::players[i]->leftkeydown ||
7587                                       Person::players[i]->rightkeydown ||
7588                                       Person::players[i]->forwardkeydown ||
7589                                       Person::players[i]->backkeydown))) {
7590                                 Person::players[i]->setAnimation(rollanim);
7591                                 Person::players[i]->transspeed = 20;
7592                             }
7593                         }
7594                         if (!Person::players[i]->crouchkeydown) {
7595                             //Uncrouch
7596                             if (!Person::players[i]->isRun() && Person::players[i]->animTarget != sneakanim && i == 0)
7597                                 Person::players[i]->superruntoggle = 0;
7598                             target = -2;
7599                             if (Person::players[i]->isCrouch()) {
7600                                 if (Person::players.size() > 1)
7601                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7602                                         if (j != i &&
7603                                                 !Person::players[j]->skeleton.free &&
7604                                                 Person::players[j]->victim &&
7605                                                 Person::players[i]->highreversaldelay <= 0) {
7606                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7607                                                     Person::players[j]->victim == Person::players[i] &&
7608                                                     (Person::players[j]->animTarget == spinkickanim) &&
7609                                                     Person::players[i]->isCrouch()) {
7610                                                 if (target >= 0)
7611                                                     target = -1;
7612                                                 else
7613                                                     target = j;
7614                                             }
7615                                         }
7616                                     }
7617                                 if (target >= 0)
7618                                     Person::players[target]->Reverse();
7619                                 Person::players[i]->highreversaldelay = .5;
7620
7621                                 if (Person::players[i]->isCrouch()) {
7622                                     if (!Person::players[i]->wasCrouch()) {
7623                                         Person::players[i]->animCurrent = Person::players[i]->getCrouch();
7624                                         Person::players[i]->frameCurrent = 0;
7625                                     }
7626                                     Person::players[i]->setAnimation(Person::players[i]->getIdle());
7627                                     Person::players[i]->transspeed = 10;
7628                                 }
7629                             }
7630                             if (Person::players[i]->animTarget == sneakanim) {
7631                                 Person::players[i]->setAnimation(Person::players[i]->getIdle());
7632                                 Person::players[i]->transspeed = 10;
7633                             }
7634                         }
7635                         if (Person::players[i]->forwardkeydown) {
7636                             if (Person::players[i]->isIdle() ||
7637                                     (Person::players[i]->isStop() &&
7638                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7639                                     (Person::players[i]->isLanding() &&
7640                                      Person::players[i]->frameTarget > 0 &&
7641                                      !Person::players[i]->jumpkeydown) ||
7642                                     (Person::players[i]->isLandhard() &&
7643                                      Person::players[i]->frameTarget > 0 &&
7644                                      !Person::players[i]->jumpkeydown &&
7645                                      Person::players[i]->crouchkeydown)) {
7646                                 if (Person::players[i]->aitype == passivetype)
7647                                     Person::players[i]->setAnimation(walkanim);
7648                                 else
7649                                     Person::players[i]->setAnimation(Person::players[i]->getRun());
7650                             }
7651                             if (Person::players[i]->isCrouch()) {
7652                                 Person::players[i]->animTarget = sneakanim;
7653                                 if (Person::players[i]->wasCrouch())
7654                                     Person::players[i]->target = 0;
7655                                 Person::players[i]->frameTarget = 0;
7656                             }
7657                             if (Person::players[i]->animTarget == hanganim/*&&(!Person::players[i]->forwardstogglekeydown||Person::players[i]->aitype!=playercontrolled)*/) {
7658                                 Person::players[i]->setAnimation(climbanim);
7659                                 Person::players[i]->frameTarget = 1;
7660                                 Person::players[i]->jumpclimb = 1;
7661                             }
7662                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7663                                 Person::players[i]->velocity += absflatfacing * 5 * multiplier;
7664                             }
7665                             Person::players[i]->forwardstogglekeydown = 1;
7666                             movekey = 1;
7667                         }
7668                         if (Person::players[i]->rightkeydown) {
7669                             if (Person::players[i]->isIdle() ||
7670                                     (Person::players[i]->isStop() &&
7671                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7672                                     (Person::players[i]->isLanding() &&
7673                                      Person::players[i]->frameTarget > 0 &&
7674                                      !Person::players[i]->jumpkeydown) ||
7675                                     (Person::players[i]->isLandhard() &&
7676                                      Person::players[i]->frameTarget > 0 &&
7677                                      !Person::players[i]->jumpkeydown &&
7678                                      Person::players[i]->crouchkeydown)) {
7679                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7680                             }
7681                             if (Person::players[i]->isCrouch()) {
7682                                 Person::players[i]->animTarget = sneakanim;
7683                                 if (Person::players[i]->wasCrouch())
7684                                     Person::players[i]->target = 0;
7685                                 Person::players[i]->frameTarget = 0;
7686                             }
7687                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7688                                 Person::players[i]->velocity += DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
7689                             }
7690                             Person::players[i]->targetyaw -= 90;
7691                             if (Person::players[i]->forwardkeydown)
7692                                 Person::players[i]->targetyaw += 45;
7693                             if (Person::players[i]->backkeydown)
7694                                 Person::players[i]->targetyaw -= 45;
7695                             movekey = 1;
7696                         }
7697                         if ( Person::players[i]->leftkeydown) {
7698                             if (Person::players[i]->isIdle() ||
7699                                     (Person::players[i]->isStop() &&
7700                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7701                                     (Person::players[i]->isLanding() &&
7702                                      Person::players[i]->frameTarget > 0 &&
7703                                      !Person::players[i]->jumpkeydown) ||
7704                                     (Person::players[i]->isLandhard() &&
7705                                      Person::players[i]->frameTarget > 0 &&
7706                                      !Person::players[i]->jumpkeydown &&
7707                                      Person::players[i]->crouchkeydown)) {
7708                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7709                             }
7710                             if (Person::players[i]->isCrouch()) {
7711                                 Person::players[i]->animTarget = sneakanim;
7712                                 if (Person::players[i]->wasCrouch())
7713                                     Person::players[i]->target = 0;
7714                                 Person::players[i]->frameTarget = 0;
7715                             }
7716                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7717                                 Person::players[i]->velocity -= DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
7718                             }
7719                             Person::players[i]->targetyaw += 90;
7720                             if (Person::players[i]->forwardkeydown)
7721                                 Person::players[i]->targetyaw -= 45;
7722                             if (Person::players[i]->backkeydown)
7723                                 Person::players[i]->targetyaw += 45;
7724                             movekey = 1;
7725                         }
7726                         if (Person::players[i]->backkeydown) {
7727                             if (Person::players[i]->isIdle() ||
7728                                     (Person::players[i]->isStop() &&
7729                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7730                                     (Person::players[i]->isLanding() &&
7731                                      Person::players[i]->frameTarget > 0 &&
7732                                      !Person::players[i]->jumpkeydown) ||
7733                                     (Person::players[i]->isLandhard() &&
7734                                      Person::players[i]->frameTarget > 0 &&
7735                                      !Person::players[i]->jumpkeydown &&
7736                                      Person::players[i]->crouchkeydown)) {
7737                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7738                             }
7739                             if (Person::players[i]->isCrouch()) {
7740                                 Person::players[i]->animTarget = sneakanim;
7741                                 if (Person::players[i]->wasCrouch())
7742                                     Person::players[i]->target = 0;
7743                                 Person::players[i]->frameTarget = 0;
7744                             }
7745                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7746                                 Person::players[i]->velocity -= absflatfacing * 5 * multiplier;
7747                             }
7748                             if (Person::players[i]->animTarget == hanganim) {
7749                                 Person::players[i]->animCurrent = jumpdownanim;
7750                                 Person::players[i]->animTarget = jumpdownanim;
7751                                 Person::players[i]->target = 0;
7752                                 Person::players[i]->frameCurrent = 0;
7753                                 Person::players[i]->frameTarget = 1;
7754                                 Person::players[i]->velocity = 0;
7755                                 Person::players[i]->velocity.y += gravity;
7756                                 Person::players[i]->coords.y -= 1.4;
7757                                 Person::players[i]->grabdelay = 1;
7758                             }
7759                             if ( !Person::players[i]->leftkeydown && !Person::players[i]->rightkeydown)
7760                                 Person::players[i]->targetyaw += 180;
7761                             movekey = 1;
7762                         }
7763                         if ((Person::players[i]->jumpkeydown && !Person::players[i]->jumpclimb) || Person::players[i]->jumpstart) {
7764                             if ((((Person::players[i]->isLanding() && Person::players[i]->frameTarget >= 3) ||
7765                                     Person::players[i]->isRun() ||
7766                                     Person::players[i]->animTarget == walkanim ||
7767                                     Person::players[i]->isCrouch() ||
7768                                     Person::players[i]->animTarget == sneakanim) &&
7769                                     Person::players[i]->jumppower > 1) &&
7770                                     ((Person::players[i]->animTarget != rabbitrunninganim &&
7771                                       Person::players[i]->animTarget != wolfrunninganim) || i != 0)) {
7772                                 Person::players[i]->jumpstart = 0;
7773                                 Person::players[i]->setAnimation(jumpupanim);
7774                                 Person::players[i]->yaw = Person::players[i]->targetyaw;
7775                                 Person::players[i]->transspeed = 20;
7776                                 Person::players[i]->FootLand(0, 1);
7777                                 Person::players[i]->FootLand(1, 1);
7778
7779                                 facing = 0;
7780                                 facing.z = -1;
7781                                 flatfacing = DoRotation(facing, 0, Person::players[i]->targetyaw + 180, 0);
7782
7783                                 if (movekey)
7784                                     Person::players[i]->velocity = flatfacing * Person::players[i]->speed * 45 * Person::players[i]->scale;
7785                                 if (!movekey)
7786                                     Person::players[i]->velocity = 0;
7787
7788                                 //Dodge sweep?
7789                                 target = -2;
7790                                 if (Person::players.size() > 1)
7791                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7792                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim) {
7793                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7794                                                     (Person::players[j]->victim == Person::players[i]) &&
7795                                                     (Person::players[j]->animTarget == sweepanim)) {
7796                                                 if (target >= 0)
7797                                                     target = -1;
7798                                                 else
7799                                                     target = j;
7800                                             }
7801                                         }
7802                                     }
7803                                 if (target >= 0)
7804                                     Person::players[i]->velocity.y = 1;
7805                                 else
7806                                     if (Person::players[i]->crouchkeydown || Person::players[i]->aitype != playercontrolled) {
7807                                     Person::players[i]->velocity.y = 7;
7808                                     Person::players[i]->crouchtogglekeydown = 1;
7809                                 } else Person::players[i]->velocity.y = 5;
7810
7811                                 if (mousejump && i == 0 && debugmode) {
7812                                     if (!Person::players[i]->isLanding())
7813                                         Person::players[i]->tempdeltav = deltav;
7814                                     if (Person::players[i]->tempdeltav < 0)
7815                                         Person::players[i]->velocity.y -= (float)(Person::players[i]->tempdeltav) / multiplier / 1000;
7816                                 }
7817
7818                                 Person::players[i]->coords.y += .2;
7819                                 Person::players[i]->jumppower -= 1;
7820
7821                                 if (!i)
7822                                     emit_sound_at(whooshsound, Person::players[i]->coords, 128.);
7823
7824                                 emit_sound_at(jumpsound, Person::players[i]->coords, 128.);
7825                             }
7826                             if ((Person::players[i]->isIdle()) && Person::players[i]->jumppower > 1) {
7827                                 Person::players[i]->setAnimation(Person::players[i]->getLanding());
7828                                 Person::players[i]->frameTarget = 2;
7829                                 Person::players[i]->landhard = 0;
7830                                 Person::players[i]->jumpstart = 1;
7831                                 Person::players[i]->tempdeltav = deltav;
7832                             }
7833                             if (Person::players[i]->animTarget == jumpupanim &&
7834                                     (((!floatjump &&
7835                                        !editorenabled) ||
7836                                       !debugmode) ||
7837                                      Person::players[i]->aitype != playercontrolled)) {
7838                                 if (Person::players[i]->jumppower > multiplier * 6) {
7839                                     Person::players[i]->velocity.y += multiplier * 6;
7840                                     Person::players[i]->jumppower -= multiplier * 6;
7841                                 }
7842                                 if (Person::players[i]->jumppower <= multiplier * 6) {
7843                                     Person::players[i]->velocity.y += Person::players[i]->jumppower;
7844                                     Person::players[i]->jumppower = 0;
7845                                 }
7846                             }
7847                             if (((floatjump || editorenabled) && debugmode) && i == 0)
7848                                 Person::players[i]->velocity.y += multiplier * 30;
7849                         }
7850
7851                         if (!movekey) {
7852                             if (Person::players[i]->isRun() || Person::players[i]->animTarget == walkanim)
7853                                 Person::players[i]->setAnimation(Person::players[i]->getStop());
7854                             if (Person::players[i]->animTarget == sneakanim) {
7855                                 Person::players[i]->animTarget = Person::players[i]->getCrouch();
7856                                 if (Person::players[i]->animCurrent == sneakanim)
7857                                     Person::players[i]->target = 0;
7858                                 Person::players[i]->frameTarget = 0;
7859                             }
7860                         }
7861                         if (Person::players[i]->animTarget == walkanim &&
7862                                 (Person::players[i]->aitype == attacktypecutoff ||
7863                                  Person::players[i]->aitype == searchtype ||
7864                                  (Person::players[i]->aitype == passivetype &&
7865                                   Person::players[i]->numwaypoints <= 1)))
7866                             Person::players[i]->setAnimation(Person::players[i]->getStop());
7867                         if (Person::players[i]->isRun() && (Person::players[i]->aitype == passivetype))
7868                             Person::players[i]->setAnimation(Person::players[i]->getStop());
7869                     }
7870                 }
7871                 if (Person::players[i]->animTarget == rollanim)
7872                     Person::players[i]->targetyaw = oldtargetyaw;
7873             }
7874
7875             //Rotation
7876             for (unsigned k = 0; k < Person::players.size(); k++) {
7877                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 180) {
7878                     if (Person::players[k]->yaw > Person::players[k]->targetyaw)
7879                         Person::players[k]->yaw -= 360;
7880                     else
7881                         Person::players[k]->yaw += 360;
7882                 }
7883
7884                 //stop to turn in right direction
7885                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 90 && (Person::players[k]->isRun() || Person::players[k]->animTarget == walkanim))
7886                     Person::players[k]->setAnimation(Person::players[k]->getStop());
7887
7888                 if (Person::players[k]->animTarget == backhandspringanim || Person::players[k]->animTarget == dodgebackanim)
7889                     Person::players[k]->targettilt = 0;
7890
7891                 if (Person::players[k]->animTarget != jumpupanim &&
7892                         Person::players[k]->animTarget != backhandspringanim &&
7893                         Person::players[k]->animTarget != jumpdownanim &&
7894                         !Person::players[k]->isFlip()) {
7895                     Person::players[k]->targettilt = 0;
7896                     if (Person::players[k]->jumppower < 0 && !Person::players[k]->jumpkeydown)
7897                         Person::players[k]->jumppower = 0;
7898                     Person::players[k]->jumppower += multiplier * 7;
7899                     if (Person::players[k]->isCrouch())
7900                         Person::players[k]->jumppower += multiplier * 7;
7901                     if (Person::players[k]->jumppower > 5)
7902                         Person::players[k]->jumppower = 5;
7903                 }
7904
7905                 if (Person::players[k]->isRun())
7906                     Person::players[k]->targettilt = (Person::players[k]->yaw - Person::players[k]->targetyaw) / 4;
7907
7908                 Person::players[k]->tilt = stepTowardf(Person::players[k]->tilt, Person::players[k]->targettilt, multiplier * 150);
7909                 Person::players[k]->grabdelay -= multiplier;
7910             }
7911
7912             //do animations
7913             for (unsigned k = 0; k < Person::players.size(); k++) {
7914                 Person::players[k]->DoAnimations();
7915                 Person::players[k]->whichpatchx = Person::players[k]->coords.x / (terrain.size / subdivision * terrain.scale);
7916                 Person::players[k]->whichpatchz = Person::players[k]->coords.z / (terrain.size / subdivision * terrain.scale);
7917             }
7918
7919             //do stuff
7920             objects.DoStuff();
7921
7922             for (int j = numenvsounds - 1; j >= 0; j--) {
7923                 envsoundlife[j] -= multiplier;
7924                 if (envsoundlife[j] < 0) {
7925                     numenvsounds--;
7926                     envsoundlife[j] = envsoundlife[numenvsounds];
7927                     envsound[j] = envsound[numenvsounds];
7928                 }
7929             }
7930             if (slomo)
7931                 OPENAL_SetFrequency(OPENAL_ALL, slomofreq);
7932             else
7933                 OPENAL_SetFrequency(OPENAL_ALL, 22050);
7934
7935             if (tutoriallevel == 1) {
7936                 XYZ temp;
7937                 XYZ temp2;
7938                 XYZ temp3;
7939                 XYZ oldtemp;
7940                 XYZ oldtemp2;
7941                 temp.x = 1011;
7942                 temp.y = 84;
7943                 temp.z = 491;
7944                 temp2.x = 1025;
7945                 temp2.y = 75;
7946                 temp2.z = 447;
7947                 temp3.x = 1038;
7948                 temp3.y = 76;
7949                 temp3.z = 453;
7950                 oldtemp = temp;
7951                 oldtemp2 = temp2;
7952                 if (tutorialstage >= 51)
7953                     if (distsq(&temp, &Person::players[0]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[0]->coords) < 4) {
7954                         OPENAL_StopSound(OPENAL_ALL);  // hack...OpenAL renderer isn't stopping music after tutorial goes to level menu...
7955                         OPENAL_SetFrequency(OPENAL_ALL, 0.001);
7956
7957                         emit_stream_np(stream_menutheme);
7958
7959                         gameon = 0;
7960                         mainmenu = 5;
7961
7962                         fireSound();
7963
7964                         flash();
7965                     }
7966                 if (tutorialstage < 51)
7967                     if (distsq(&temp, &Person::players[0]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[0]->coords) < 4) {
7968                         emit_sound_at(fireendsound, Person::players[0]->coords);
7969
7970                         Person::players[0]->coords = (oldtemp + oldtemp2) / 2;
7971
7972                         flash();
7973                     }
7974                 if (tutorialstage >= 14 && tutorialstage < 50)
7975                     if (distsq(&temp, &Person::players[1]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[1]->coords) < 4) {
7976                         emit_sound_at(fireendsound, Person::players[1]->coords);
7977
7978                         for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
7979                             if (Random() % 2 == 0) {
7980                                 if (!Person::players[1]->skeleton.free)
7981                                     temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
7982                                 if (Person::players[1]->skeleton.free)
7983                                     temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
7984                                 if (!Person::players[1]->skeleton.free)
7985                                     temp = DoRotation(DoRotation(DoRotation(Person::players[1]->skeleton.joints[i].position, 0, 0, Person::players[1]->tilt), Person::players[1]->tilt2, 0, 0), 0, Person::players[1]->yaw, 0) * Person::players[1]->scale + Person::players[1]->coords;
7986                                 if (Person::players[1]->skeleton.free)
7987                                     temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
7988                                 Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
7989                             }
7990                         }
7991
7992                         Person::players[1]->coords = (oldtemp + oldtemp2) / 2;
7993                         for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
7994                             Person::players[1]->skeleton.joints[i].velocity = 0;
7995                             if (Random() % 2 == 0) {
7996                                 if (!Person::players[1]->skeleton.free)
7997                                     temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
7998                                 if (Person::players[1]->skeleton.free)
7999                                     temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
8000                                 if (!Person::players[1]->skeleton.free)
8001                                     temp = DoRotation(DoRotation(DoRotation(Person::players[1]->skeleton.joints[i].position, 0, 0, Person::players[1]->tilt), Person::players[1]->tilt2, 0, 0), 0, Person::players[1]->yaw, 0) * Person::players[1]->scale + Person::players[1]->coords;
8002                                 if (Person::players[1]->skeleton.free)
8003                                     temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
8004                                 Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
8005                             }
8006                         }
8007                     }
8008             }
8009
8010
8011             //3d sound
8012             static float gLoc[3];
8013             gLoc[0] = viewer.x;
8014             gLoc[1] = viewer.y;
8015             gLoc[2] = viewer.z;
8016             static float vel[3];
8017             vel[0] = (viewer.x - oldviewer.x) / multiplier;
8018             vel[1] = (viewer.y - oldviewer.y) / multiplier;
8019             vel[2] = (viewer.z - oldviewer.z) / multiplier;
8020
8021             //Set orientation with forward and up vectors
8022             static XYZ upvector;
8023             upvector = 0;
8024             upvector.z = -1;
8025
8026             upvector = DoRotation(upvector, -pitch + 90, 0, 0);
8027             upvector = DoRotation(upvector, 0, 0 - yaw, 0);
8028
8029             facing = 0;
8030             facing.z = -1;
8031
8032             facing = DoRotation(facing, -pitch, 0, 0);
8033             facing = DoRotation(facing, 0, 0 - yaw, 0);
8034
8035
8036             static float ori[6];
8037             ori[0] = -facing.x;
8038             ori[1] = facing.y;
8039             ori[2] = -facing.z;
8040             ori[3] = -upvector.x;
8041             ori[4] = upvector.y;
8042             ori[5] = -upvector.z;
8043
8044             OPENAL_3D_Listener_SetAttributes(&gLoc[0], &vel[0], ori[0], ori[1], ori[2], ori[3], ori[4], ori[5]);
8045             OPENAL_Update();
8046
8047             oldviewer = viewer;
8048         }
8049     }
8050
8051     if (Input::isKeyPressed(SDL_SCANCODE_F1))
8052         Screenshot();
8053 }
8054
8055 void Game::TickOnce()
8056 {
8057     if (mainmenu)
8058         yaw += multiplier * 5;
8059     else if (directing || indialogue == -1) {
8060         yaw += deltah * .7;
8061         if (!invertmouse)
8062             pitch += deltav * .7;
8063         if (invertmouse)
8064             pitch -= deltav * .7;
8065         if (pitch > 90)
8066             pitch = 90;
8067         if (pitch < -70)
8068             pitch = -70;
8069     }
8070 }
8071
8072 void Game::TickOnceAfter()
8073 {
8074     static XYZ colviewer;
8075     static XYZ coltarget;
8076     static XYZ target;
8077     static XYZ col;
8078     static XYZ facing;
8079     static float changedelay;
8080     static bool alldead;
8081     static float unseendelay;
8082     static float cameraspeed;
8083
8084     if (!mainmenu) {
8085         static int oldmusictype = musictype;
8086
8087         if (environment == snowyenvironment)
8088             leveltheme = stream_snowtheme;
8089         if (environment == grassyenvironment)
8090             leveltheme = stream_grasstheme;
8091         if (environment == desertenvironment)
8092             leveltheme = stream_deserttheme;
8093
8094         realthreat = 0;
8095
8096         musictype = leveltheme;
8097         for (unsigned i = 0; i < Person::players.size(); i++) {
8098             if ((Person::players[i]->aitype == attacktypecutoff ||
8099                     Person::players[i]->aitype == getweapontype ||
8100                     Person::players[i]->aitype == gethelptype ||
8101                     Person::players[i]->aitype == searchtype) &&
8102                     !Person::players[i]->dead/*&&Person::players[i]->surprised<=0*/ &&
8103                     (Person::players[i]->animTarget != sneakattackedanim &&
8104                      Person::players[i]->animTarget != knifesneakattackedanim &&
8105                      Person::players[i]->animTarget != swordsneakattackedanim)) {
8106                 musictype = stream_fighttheme;
8107                 realthreat = 1;
8108             }
8109         }
8110         if (Person::players[0]->dead)
8111             musictype = stream_menutheme;
8112
8113
8114         if (musictype == stream_fighttheme)
8115             unseendelay = 1;
8116
8117         if (oldmusictype == stream_fighttheme && musictype != stream_fighttheme) {
8118             unseendelay -= multiplier;
8119             if (unseendelay > 0)
8120                 musictype = stream_fighttheme;
8121         }
8122
8123
8124         if (loading == 2) {
8125             musictype = stream_menutheme;
8126             musicvolume[2] = 512;
8127             musicvolume[0] = 0;
8128             musicvolume[1] = 0;
8129             musicvolume[3] = 0;
8130         }
8131
8132         if (musictoggle)
8133             if (musictype != oldmusictype && musictype == stream_fighttheme)
8134                 emit_sound_np(alarmsound);
8135         musicselected = musictype;
8136
8137         if (musicselected == leveltheme)
8138             musicvolume[0] += multiplier * 450;
8139         else
8140             musicvolume[0] -= multiplier * 450;
8141         if (musicselected == stream_fighttheme)
8142             musicvolume[1] += multiplier * 450;
8143         else
8144             musicvolume[1] -= multiplier * 450;
8145         if (musicselected == stream_menutheme)
8146             musicvolume[2] += multiplier * 450;
8147         else
8148             musicvolume[2] -= multiplier * 450;
8149
8150         for (int i = 0; i < 3; i++) {
8151             if (musicvolume[i] < 0)
8152                 musicvolume[i] = 0;
8153             if (musicvolume[i] > 512)
8154                 musicvolume[i] = 512;
8155         }
8156
8157         if (musicvolume[2] > 128 && !loading && !mainmenu)
8158             musicvolume[2] = 128;
8159
8160         if (musictoggle) {
8161             if (musicvolume[0] > 0 && oldmusicvolume[0] <= 0)
8162                 emit_stream_np(leveltheme, musicvolume[0]);
8163             if (musicvolume[1] > 0 && oldmusicvolume[1] <= 0)
8164                 emit_stream_np(stream_fighttheme, musicvolume[1]);
8165             if (musicvolume[2] > 0 && oldmusicvolume[2] <= 0)
8166                 emit_stream_np(stream_menutheme, musicvolume[2]);
8167             if (musicvolume[0] <= 0 && oldmusicvolume[0] > 0)
8168                 pause_sound(leveltheme);
8169             if (musicvolume[1] <= 0 && oldmusicvolume[1] > 0)
8170                 pause_sound(stream_fighttheme);
8171             if (musicvolume[2] <= 0 && oldmusicvolume[2] > 0)
8172                 pause_sound(stream_menutheme);
8173
8174             if (musicvolume[0] != oldmusicvolume[0])
8175                 OPENAL_SetVolume(channels[leveltheme], musicvolume[0]);
8176             if (musicvolume[1] != oldmusicvolume[1])
8177                 OPENAL_SetVolume(channels[stream_fighttheme], musicvolume[1]);
8178             if (musicvolume[2] != oldmusicvolume[2])
8179                 OPENAL_SetVolume(channels[stream_menutheme], musicvolume[2]);
8180
8181             for (int i = 0; i < 3; i++)
8182                 oldmusicvolume[i] = musicvolume[i];
8183         } else {
8184             pause_sound(leveltheme);
8185             pause_sound(stream_fighttheme);
8186             pause_sound(stream_menutheme);
8187
8188             for (int i = 0; i < 4; i++) {
8189                 oldmusicvolume[i] = 0;
8190                 musicvolume[i] = 0;
8191             }
8192         }
8193
8194         killhotspot = 2;
8195         for (int i = 0; i < numhotspots; i++) {
8196             if (hotspottype[i] > 10 && hotspottype[i] < 20) {
8197                 if (Person::players[hotspottype[i] - 10]->dead == 0)
8198                     killhotspot = 0;
8199                 else if (killhotspot == 2)
8200                     killhotspot = 1;
8201             }
8202         }
8203         if (killhotspot == 2)
8204             killhotspot = 0;
8205
8206
8207         winhotspot = false;
8208         for (int i = 0; i < numhotspots; i++)
8209             if (hotspottype[i] == -1)
8210                 if (distsq(&Person::players[0]->coords, &hotspot[i]) < hotspotsize[i])
8211                     winhotspot = true;
8212
8213         int numalarmed = 0;
8214         for (unsigned i = 1; i < Person::players.size(); i++)
8215             if (!Person::players[i]->dead && Person::players[i]->aitype == attacktypecutoff && Person::players[i]->surprised <= 0)
8216                 numalarmed++;
8217         if (numalarmed > maxalarmed)
8218             maxalarmed = numalarmed;
8219
8220         if (changedelay <= 0 && !loading && !editorenabled && gameon && !tutoriallevel && changedelay != -999 && !won) {
8221             if (Person::players[0]->dead && changedelay <= 0) {
8222                 changedelay = 1;
8223                 targetlevel = whichlevel;
8224             }
8225             alldead = true;
8226             for (unsigned i = 1; i < Person::players.size(); i++) {
8227                 if (!Person::players[i]->dead && Person::players[i]->howactive < typedead1) {
8228                     alldead = false;
8229                     break;
8230                 }
8231             }
8232
8233
8234             if (alldead && !Person::players[0]->dead && maptype == mapkilleveryone) {
8235                 changedelay = 1;
8236                 targetlevel = whichlevel + 1;
8237                 if (targetlevel > numchallengelevels - 1)
8238                     targetlevel = 0;
8239             }
8240             if (winhotspot || windialogue) {
8241                 changedelay = 0.1;
8242                 targetlevel = whichlevel + 1;
8243                 if (targetlevel > numchallengelevels - 1)
8244                     targetlevel = 0;
8245             }
8246
8247
8248             if (killhotspot) {
8249                 changedelay = 1;
8250                 targetlevel = whichlevel + 1;
8251                 if (targetlevel > numchallengelevels - 1)
8252                     targetlevel = 0;
8253             }
8254
8255             if (changedelay > 0 && !Person::players[0]->dead && !won) {
8256                 //high scores, awards, win
8257                 if (campaign) {
8258                     accountactive->winCampaignLevel(whichchoice, bonustotal, leveltime);
8259                     scoreadded = 1;
8260                 } else {
8261                     accountactive->winLevel(whichlevel, bonustotal - startbonustotal, leveltime);
8262                 }
8263                 won = 1;
8264             }
8265         }
8266
8267         if (!winfreeze) {
8268
8269             if (leveltime < 1) {
8270                 loading = 0;
8271                 changedelay = .1;
8272                 alldead = false;
8273                 winhotspot = false;
8274                 killhotspot = 0;
8275             }
8276
8277             if (!editorenabled && gameon && !mainmenu) {
8278                 if (changedelay != -999)
8279                     changedelay -= multiplier / 7;
8280                 if (Person::players[0]->dead)
8281                     targetlevel = whichlevel;
8282                 if (loading == 2 && !campaign) {
8283                     flash();
8284
8285                     fireSound(firestartsound);
8286
8287                     if (!Person::players[0]->dead && targetlevel != whichlevel)
8288                         startbonustotal = bonustotal;
8289                     if (Person::players[0]->dead)
8290                         Loadlevel(whichlevel);
8291                     else
8292                         Loadlevel(targetlevel);
8293
8294                     fireSound();
8295
8296                     loading = 3;
8297                 }
8298                 if (loading == 2 && targetlevel == whichlevel) {
8299                     flash();
8300                     loadtime = 0;
8301
8302                     fireSound(firestartsound);
8303
8304                     Loadlevel(campaignlevels[accountactive->getCampaignChoicesMade()].mapname.c_str());
8305
8306                     fireSound();
8307
8308                     loading = 3;
8309                 }
8310                 if (changedelay <= -999 &&
8311                         whichlevel != -2 &&
8312                         !loading &&
8313                         (Person::players[0]->dead ||
8314                          (alldead && maptype == mapkilleveryone) ||
8315                          (winhotspot) ||
8316                          (killhotspot)))
8317                     loading = 1;
8318                 if ((Person::players[0]->dead ||
8319                         (alldead && maptype == mapkilleveryone) ||
8320                         (winhotspot) ||
8321                         (windialogue) ||
8322                         (killhotspot)) &&
8323                         changedelay <= 0) {
8324                     if (whichlevel != -2 && !loading && !Person::players[0]->dead) {
8325                         winfreeze = true;
8326                         changedelay = -999;
8327                     }
8328                     if (Person::players[0]->dead)
8329                         loading = 1;
8330                 }
8331             }
8332
8333             if (campaign) {
8334                 // campaignchoosenext determines what to do when the level is complete:
8335                 // 0 = load next level
8336                 // 1 = go back to level select screen
8337                 // 2 = stealthload next level
8338                 if (mainmenu == 0 && winfreeze && (campaignlevels[actuallevel].choosenext) == 1) {
8339                     if (campaignlevels[actuallevel].nextlevel.empty())
8340                         endgame = 1;
8341                 } else if (mainmenu == 0 && winfreeze) {
8342                     stealthloading = (campaignlevels[actuallevel].choosenext == 2);
8343
8344                     if (!stealthloading) {
8345                         fireSound(firestartsound);
8346
8347                         flash();
8348                     }
8349
8350                     startbonustotal = 0;
8351
8352                     LoadCampaign();
8353
8354                     loading = 2;
8355                     loadtime = 0;
8356                     targetlevel = 7;
8357                     if (!firstload)
8358                         LoadStuff();
8359                     whichchoice = 0;
8360                     actuallevel = campaignlevels[actuallevel].nextlevel.front();
8361                     visibleloading = 1;
8362                     stillloading = 1;
8363                     Loadlevel(campaignlevels[actuallevel].mapname.c_str());
8364                     campaign = 1;
8365                     mainmenu = 0;
8366                     gameon = 1;
8367                     pause_sound(stream_menutheme);
8368
8369                     stealthloading = 0;
8370                 }
8371             }
8372
8373             if (loading == 3)
8374                 loading = 0;
8375
8376         }
8377
8378         oldmusictype = musictype;
8379     }
8380
8381     facing = 0;
8382     facing.z = -1;
8383
8384     facing = DoRotation(facing, -pitch, 0, 0);
8385     facing = DoRotation(facing, 0, 0 - yaw, 0);
8386     viewerfacing = facing;
8387
8388     if (!cameramode) {
8389         if ((animation[Person::players[0]->animTarget].attack != 3 && animation[Person::players[0]->animCurrent].attack != 3) || Person::players[0]->skeleton.free)
8390             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;
8391         else
8392             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;
8393         target.y += .1;
8394         if (Person::players[0]->skeleton.free) {
8395             for (int i = 0; i < Person::players[0]->skeleton.num_joints; i++) {
8396                 if (Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y > target.y)
8397                     target.y = Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y;
8398             }
8399             target.y += .1;
8400         }
8401         if (Person::players[0]->skeleton.free != 2/*&&!autocam*/) {
8402             cameraspeed = 20;
8403             if (findLengthfast(&Person::players[0]->velocity) > 400) {
8404                 cameraspeed = 20 + (findLength(&Person::players[0]->velocity) - 20) * .96;
8405             }
8406             if (Person::players[0]->skeleton.free == 0 && Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim)
8407                 target.y += 1.4;
8408             coltarget = target - cameraloc;
8409             if (findLengthfast(&coltarget) < multiplier * multiplier * 400)
8410                 cameraloc = target;
8411             else {
8412                 Normalise(&coltarget);
8413                 if (Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim && Person::players[0]->animCurrent != climbanim && Person::players[0]->currentoffset.x == 0)
8414                     cameraloc = cameraloc + coltarget * multiplier * cameraspeed;
8415                 else
8416                     cameraloc = cameraloc + coltarget * multiplier * 8;
8417             }
8418             if (editorenabled)
8419                 cameraloc = target;
8420             cameradist += multiplier * 5;
8421             if (cameradist > 2.3)
8422                 cameradist = 2.3;
8423             viewer = cameraloc - facing * cameradist;
8424             colviewer = viewer;
8425             coltarget = cameraloc;
8426             objects.SphereCheckPossible(&colviewer, findDistance(&colviewer, &coltarget));
8427             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8428                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
8429                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8430                     colviewer = viewer;
8431                     coltarget = cameraloc;
8432                     if (objects.model[i].LineCheckPossible(&colviewer, &coltarget, &col, &objects.position[i], &objects.yaw[i]) != -1)
8433                         viewer = col;
8434                 }
8435             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8436                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
8437                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8438                     colviewer = viewer;
8439                     if (objects.model[i].SphereCheck(&colviewer, .15, &col, &objects.position[i], &objects.yaw[i]) != -1) {
8440                         viewer = colviewer;
8441                     }
8442                 }
8443             cameradist = findDistance(&viewer, &target);
8444             viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .6);
8445             if (cameraloc.y < terrain.getHeight(cameraloc.x, cameraloc.z)) {
8446                 cameraloc.y = terrain.getHeight(cameraloc.x, cameraloc.z);
8447             }
8448         }
8449         /*
8450         //what did autocam do?
8451         if(Person::players[0]->skeleton.free!=2&&autocam){
8452             cameraspeed=20;
8453             if(findLengthfast(&Person::players[0]->velocity)>400){
8454                 cameraspeed=20+(findLength(&Person::players[0]->velocity)-20)*.96;
8455             }
8456             if(Person::players[0]->skeleton.free==0&&Person::players[0]->animTarget!=hanganim&&Person::players[0]->animTarget!=climbanim)target.y+=1.4;
8457             cameradist+=multiplier*5;
8458             if(cameradist>3.3)cameradist=3.3;
8459             coltarget=target-cameraloc;
8460             if(findLengthfast(&coltarget)<multiplier*multiplier*400)cameraloc=target;
8461             else if(findLengthfast(&coltarget)>1)
8462             {
8463                 Normalise(&coltarget);
8464                 if(Person::players[0]->animTarget!=hanganim&&Person::players[0]->animTarget!=climbanim&&Person::players[0]->animCurrent!=climbanim&&Person::players[0]->currentoffset.x==0)cameraloc=cameraloc+coltarget*multiplier*cameraspeed;
8465                 else cameraloc=cameraloc+coltarget*multiplier*8;
8466             }
8467             if(editorenabled)cameraloc=target;
8468             viewer=cameraloc;
8469             colviewer=viewer;
8470             coltarget=cameraloc;
8471             objects.SphereCheckPossible(&colviewer, findDistance(&colviewer,&coltarget));
8472             if(terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8473                 for(int j=0;j<terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz];j++){
8474                     int i=terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8475                     colviewer=viewer;
8476                     coltarget=cameraloc;
8477                     if(objects.model[i].LineCheckPossible(&colviewer,&coltarget,&col,&objects.position[i],&objects.yaw[i])!=-1)viewer=col;
8478                 }
8479             if(terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8480                 for(int j=0;j<terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz];j++){
8481                     int i=terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8482                     colviewer=viewer;
8483                     if(objects.model[i].SphereCheck(&colviewer,.15,&col,&objects.position[i],&objects.yaw[i])!=-1){
8484                         viewer=colviewer;
8485                     }
8486                 }
8487             cameradist=findDistance(&viewer,&target);
8488             viewer.y=max((double)viewer.y,terrain.getHeight(viewer.x,viewer.z)+.6);
8489             if(cameraloc.y<terrain.getHeight(cameraloc.x,cameraloc.z)){
8490                 cameraloc.y=terrain.getHeight(cameraloc.x,cameraloc.z);
8491             }
8492         }
8493         */
8494         if (camerashake > .8)
8495             camerashake = .8;
8496         //if(woozy>10)woozy=10;
8497         //woozy+=multiplier;
8498         woozy += multiplier;
8499         if (Person::players[0]->dead)
8500             camerashake = 0;
8501         if (Person::players[0]->dead)
8502             woozy = 0;
8503         camerashake -= multiplier * 2;
8504         blackout -= multiplier * 2;
8505         //if(Person::players[0]->isCrouch())woozy-=multiplier*8;
8506         if (camerashake < 0)
8507             camerashake = 0;
8508         if (blackout < 0)
8509             blackout = 0;
8510         //if(woozy<0)woozy=0;
8511         if (camerashake) {
8512             viewer.x += (float)(Random() % 100) * .0005 * camerashake;
8513             viewer.y += (float)(Random() % 100) * .0005 * camerashake;
8514             viewer.z += (float)(Random() % 100) * .0005 * camerashake;
8515         }
8516     }
8517 }
8518