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 && (/*Person::players[k]->jumptogglekeydown*/1 == 1 || Person::players[k]->aitype != playercontrolled))
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 = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[k], 0);
3974                                                                     lowpoint = Person::players[k]->coords;
3975                                                                     lowpoint.y += (float)j / 13;
3976                                                                     lowpointtarget = lowpoint + facing * 1.3;
3977                                                                     flatfacing = Person::players[k]->coords;
3978                                                                     Person::players[k]->coords = colpoint - DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[k], 0) * .01;
3979                                                                     Person::players[k]->coords.y = lowpointtarget.y - .07;
3980                                                                     Person::players[k]->currentoffset = (flatfacing - Person::players[k]->coords) / Person::players[k]->scale;
3981
3982                                                                     if (j > 10 || !Person::players[k]->isRun()) {
3983                                                                         if (Person::players[k]->animTarget == jumpdownanim || Person::players[k]->animTarget == jumpupanim) {
3984                                                                             if (k == 0)
3985                                                                                 pause_sound(whooshsound);
3986                                                                         }
3987                                                                         emit_sound_at(jumpsound, Person::players[k]->coords, 128.);
3988
3989                                                                         lowpointtarget = DoRotation(objects.model[i].facenormals[whichhit], 0, objects.yaw[i], 0);
3990                                                                         Person::players[k]->yaw = -asin(0 - lowpointtarget.x) * 180 / M_PI;
3991                                                                         if (lowpointtarget.z < 0)
3992                                                                             Person::players[k]->yaw = 180 - Person::players[k]->yaw;
3993                                                                         Person::players[k]->targetyaw = Person::players[k]->yaw;
3994                                                                         Person::players[k]->lowyaw = Person::players[k]->yaw;
3995
3996                                                                         //Person::players[k]->velocity=lowpointtarget*.03;
3997                                                                         Person::players[k]->velocity = 0;
3998
3999                                                                         //climb ledge (?)
4000                                                                         if (Person::players[k]->animTarget == jumpupanim) {
4001                                                                             Person::players[k]->animTarget = climbanim;
4002                                                                             Person::players[k]->jumppower = 0;
4003                                                                             Person::players[k]->jumpclimb = 1;
4004                                                                         }
4005                                                                         Person::players[k]->transspeed = 6;
4006                                                                         Person::players[k]->target = 0;
4007                                                                         Person::players[k]->frameTarget = 1;
4008                                                                         //hang ledge (?)
4009                                                                         if (j > 25) {
4010                                                                             Person::players[k]->setAnimation(hanganim);
4011                                                                             Person::players[k]->jumppower = 0;
4012                                                                         }
4013                                                                     }
4014                                                                     break;
4015                                                                 }
4016                                                             }
4017                                                         }
4018                                         }
4019                                 }
4020                             }
4021                         }
4022                 }
4023             if (Person::players[k]->collide <= 0) {
4024                 //in the air
4025                 if (!Person::players[k]->onterrain &&
4026                         Person::players[k]->animTarget != jumpupanim &&
4027                         Person::players[k]->animTarget != jumpdownanim &&
4028                         Person::players[k]->animTarget != climbanim &&
4029                         Person::players[k]->animTarget != hanganim &&
4030                         !Person::players[k]->isWallJump() &&
4031                         !Person::players[k]->isFlip()) {
4032                     if (Person::players[k]->animCurrent != climbanim &&
4033                             Person::players[k]->animCurrent != tempanim &&
4034                             Person::players[k]->animTarget != backhandspringanim &&
4035                             (Person::players[k]->animTarget != rollanim ||
4036                              Person::players[k]->frameTarget < 2 ||
4037                              Person::players[k]->frameTarget > 6)) {
4038                         //stagger off ledge (?)
4039                         if (Person::players[k]->animTarget == staggerbackhighanim || Person::players[k]->animTarget == staggerbackhardanim)
4040                             Person::players[k]->RagDoll(0);
4041                         Person::players[k]->setAnimation(jumpdownanim);
4042
4043                         if (!k)
4044                             emit_sound_at(whooshsound, Person::players[k]->coords, 128.);
4045                     }
4046                     //gravity
4047                     Person::players[k]->velocity.y += gravity;
4048                 }
4049             }
4050         }
4051         Person::players[k]->realoldcoords = Person::players[k]->coords;
4052     }
4053 }
4054
4055 void doAttacks()
4056 {
4057     static XYZ relative;
4058     static int randattack;
4059     static bool playerrealattackkeydown = 0;
4060
4061     if (!Input::isKeyDown(attackkey))
4062         oldattackkey = 0;
4063     if (oldattackkey)
4064         Person::players[0]->attackkeydown = 0;
4065     if (oldattackkey)
4066         playerrealattackkeydown = 0;
4067     if (!oldattackkey)
4068         playerrealattackkeydown = Input::isKeyDown(attackkey);
4069     if ((Person::players[0]->parriedrecently <= 0 ||
4070             Person::players[0]->weaponactive == -1) &&
4071             (!oldattackkey ||
4072              (realthreat &&
4073               Person::players[0]->lastattack != swordslashanim &&
4074               Person::players[0]->lastattack != knifeslashstartanim &&
4075               Person::players[0]->lastattack != staffhitanim &&
4076               Person::players[0]->lastattack != staffspinhitanim)))
4077         Person::players[0]->attackkeydown = Input::isKeyDown(attackkey);
4078     if (Input::isKeyDown(attackkey) &&
4079             !oldattackkey &&
4080             !Person::players[0]->backkeydown) {
4081         for (unsigned k = 0; k < Person::players.size(); k++) {
4082             if ((Person::players[k]->animTarget == swordslashanim ||
4083                     Person::players[k]->animTarget == staffhitanim ||
4084                     Person::players[k]->animTarget == staffspinhitanim) &&
4085                     Person::players[0]->animCurrent != dodgebackanim &&
4086                     !Person::players[k]->skeleton.free)
4087                 Person::players[k]->Reverse();
4088         }
4089     }
4090
4091     if (!hostile || indialogue != -1)
4092         Person::players[0]->attackkeydown = 0;
4093
4094     for (unsigned k = 0; k < Person::players.size(); k++) {
4095         if (indialogue != -1)
4096             Person::players[k]->attackkeydown = 0;
4097         if (Person::players[k]->animTarget != rabbitrunninganim && Person::players[k]->animTarget != wolfrunninganim) {
4098             if (Person::players[k]->aitype != playercontrolled)
4099                 Person::players[k]->victim = Person::players[0];
4100             //attack key pressed
4101             if (Person::players[k]->attackkeydown) {
4102                 //dodge backward
4103                 if (Person::players[k]->backkeydown &&
4104                         Person::players[k]->animTarget != backhandspringanim &&
4105                         (Person::players[k]->isIdle() ||
4106                          Person::players[k]->isStop() ||
4107                          Person::players[k]->isRun() ||
4108                          Person::players[k]->animTarget == walkanim)) {
4109                     if (Person::players[k]->jumppower <= 1) {
4110                         Person::players[k]->jumppower -= 2;
4111                     } else {
4112                         for (unsigned i = 0; i < Person::players.size(); i++) {
4113                             if (i == k)
4114                                 continue;
4115                             if (Person::players[i]->animTarget == swordslashanim ||
4116                                     Person::players[i]->animTarget == knifeslashstartanim ||
4117                                     Person::players[i]->animTarget == staffhitanim ||
4118                                     Person::players[i]->animTarget == staffspinhitanim)
4119                                 if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < 6.5 && !Person::players[i]->skeleton.free) {
4120                                     Person::players[k]->setAnimation(dodgebackanim);
4121                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4122                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4123                                 }
4124                         }
4125                         if (Person::players[k]->animTarget != dodgebackanim) {
4126                             if (k == 0)
4127                                 numflipped++;
4128                             Person::players[k]->setAnimation(backhandspringanim);
4129                             Person::players[k]->targetyaw = -yaw + 180;
4130                             if (Person::players[k]->leftkeydown)
4131                                 Person::players[k]->targetyaw -= 45;
4132                             if (Person::players[k]->rightkeydown)
4133                                 Person::players[k]->targetyaw += 45;
4134                             Person::players[k]->yaw = Person::players[k]->targetyaw;
4135                             Person::players[k]->jumppower -= 2;
4136                         }
4137                     }
4138                 }
4139                 //attack
4140                 if (!animation[Person::players[k]->animTarget].attack &&
4141                         !Person::players[k]->backkeydown &&
4142                         (Person::players[k]->isIdle() ||
4143                          Person::players[k]->isRun() ||
4144                          Person::players[k]->animTarget == walkanim ||
4145                          Person::players[k]->animTarget == sneakanim ||
4146                          Person::players[k]->isCrouch())) {
4147                     const int attackweapon = Person::players[k]->weaponactive == -1 ? 0 : weapons[Person::players[k]->weaponids[Person::players[k]->weaponactive]].getType();
4148                     //normal attacks (?)
4149                     Person::players[k]->hasvictim = 0;
4150                     if (Person::players.size() > 1)
4151                         for (unsigned i = 0; i < Person::players.size(); i++) {
4152                             if (i == k || !(k == 0 || i == 0))
4153                                 continue;
4154                             if (!Person::players[k]->hasvictim)
4155                                 if (animation[Person::players[k]->animTarget].attack != reversal) {
4156                                     //choose an attack
4157                                     const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
4158                                     if (distance < 4.5 &&
4159                                             !Person::players[i]->skeleton.free &&
4160                                             Person::players[i]->howactive < typedead1 &&
4161                                             Person::players[i]->animTarget != jumpreversedanim &&
4162                                             Person::players[i]->animTarget != rabbitkickreversedanim &&
4163                                             Person::players[i]->animTarget != rabbitkickanim &&
4164                                             Person::players[k]->animTarget != rabbitkickanim &&
4165                                             Person::players[i]->animTarget != getupfrombackanim &&
4166                                             (Person::players[i]->animTarget != staggerbackhighanim &&
4167                                              (Person::players[i]->animTarget != staggerbackhardanim ||
4168                                               animation[staggerbackhardanim].label[Person::players[i]->frameTarget] == 6)) &&
4169                                             Person::players[i]->animTarget != jumpdownanim &&
4170                                             Person::players[i]->animTarget != jumpupanim &&
4171                                             Person::players[i]->animTarget != getupfromfrontanim) {
4172                                         Person::players[k]->victim = Person::players[i];
4173                                         Person::players[k]->hasvictim = 1;
4174                                         if (Person::players[k]->aitype == playercontrolled) { //human player
4175                                             //sweep
4176                                             if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4177                                                     Person::players[k]->crouchkeydown &&
4178                                                     animation[Person::players[i]->animTarget].height != lowheight)
4179                                                 Person::players[k]->animTarget = sweepanim;
4180                                             //winduppunch
4181                                             else if (distance < 1.5 * sq(Person::players[k]->scale * 5) &&
4182                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4183                                                      !Person::players[k]->forwardkeydown &&
4184                                                      !Person::players[k]->leftkeydown &&
4185                                                      !Person::players[k]->rightkeydown &&
4186                                                      !Person::players[k]->crouchkeydown &&
4187                                                      !attackweapon &&
4188                                                      !reversaltrain)
4189                                                 Person::players[k]->animTarget = winduppunchanim;
4190                                             //upunch
4191                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4192                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4193                                                      !Person::players[k]->forwardkeydown &&
4194                                                      !Person::players[k]->leftkeydown &&
4195                                                      !Person::players[k]->rightkeydown &&
4196                                                      !Person::players[k]->crouchkeydown &&
4197                                                      !attackweapon)
4198                                                 Person::players[k]->animTarget = upunchanim;
4199                                             //knifefollow
4200                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4201                                                      Person::players[i]->staggerdelay > 0 &&
4202                                                      attackweapon == knife &&
4203                                                      Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2)
4204                                                 Person::players[k]->animTarget = knifefollowanim;
4205                                             //knifeslashstart
4206                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4207                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4208                                                      !Person::players[k]->forwardkeydown &&
4209                                                      !Person::players[k]->leftkeydown &&
4210                                                      !Person::players[k]->rightkeydown &&
4211                                                      !Person::players[k]->crouchkeydown &&
4212                                                      attackweapon == knife &&
4213                                                      Person::players[k]->weaponmissdelay <= 0)
4214                                                 Person::players[k]->animTarget = knifeslashstartanim;
4215                                             //swordslash
4216                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4217                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4218                                                      !Person::players[k]->crouchkeydown &&
4219                                                      attackweapon == sword &&
4220                                                      Person::players[k]->weaponmissdelay <= 0)
4221                                                 Person::players[k]->animTarget = swordslashanim;
4222                                             //staffhit
4223                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4224                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4225                                                      !Person::players[k]->crouchkeydown &&
4226                                                      attackweapon == staff &&
4227                                                      Person::players[k]->weaponmissdelay <= 0 &&
4228                                                      !Person::players[k]->leftkeydown &&
4229                                                      !Person::players[k]->rightkeydown &&
4230                                                      !Person::players[k]->forwardkeydown)
4231                                                 Person::players[k]->animTarget = staffhitanim;
4232                                             //staffspinhit
4233                                             else if (distance < 4.5 * sq(Person::players[k]->scale * 5) &&
4234                                                      animation[Person::players[i]->animTarget].height != lowheight &&
4235                                                      !Person::players[k]->crouchkeydown &&
4236                                                      attackweapon == staff &&
4237                                                      Person::players[k]->weaponmissdelay <= 0)
4238                                                 Person::players[k]->animTarget = staffspinhitanim;
4239                                             //spinkick
4240                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4241                                                      animation[Person::players[i]->animTarget].height != lowheight)
4242                                                 Person::players[k]->animTarget = spinkickanim;
4243                                             //lowkick
4244                                             else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4245                                                      animation[Person::players[i]->animTarget].height == lowheight &&
4246                                                      animation[Person::players[k]->animTarget].attack != normalattack)
4247                                                 Person::players[k]->animTarget = lowkickanim;
4248                                         } else { //AI player
4249                                             if (distance < 4.5 * sq(Person::players[k]->scale * 5)) {
4250                                                 randattack = abs(Random() % 5);
4251                                                 if (!attackweapon && distance < 2.5 * sq(Person::players[k]->scale * 5)) {
4252                                                     //sweep
4253                                                     if (randattack == 0 && animation[Person::players[i]->animTarget].height != lowheight)
4254                                                         Person::players[k]->animTarget = sweepanim;
4255                                                     //upunch
4256                                                     else if (randattack == 1 && animation[Person::players[i]->animTarget].height != lowheight &&
4257                                                              !attackweapon)
4258                                                         Person::players[k]->animTarget = upunchanim;
4259                                                     //spinkick
4260                                                     else if (randattack == 2 && animation[Person::players[i]->animTarget].height != lowheight)
4261                                                         Person::players[k]->animTarget = spinkickanim;
4262                                                     //lowkick
4263                                                     else if (animation[Person::players[i]->animTarget].height == lowheight)
4264                                                         Person::players[k]->animTarget = lowkickanim;
4265                                                 }
4266                                                 if (attackweapon) {
4267                                                     //sweep
4268                                                     if ((tutoriallevel != 1 || !attackweapon) &&
4269                                                             distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4270                                                             randattack == 0 &&
4271                                                             animation[Person::players[i]->animTarget].height != lowheight)
4272                                                         Person::players[k]->animTarget = sweepanim;
4273                                                     //knifeslashstart
4274                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4275                                                              attackweapon == knife &&
4276                                                              Person::players[k]->weaponmissdelay <= 0)
4277                                                         Person::players[k]->animTarget = knifeslashstartanim;
4278                                                     //swordslash
4279                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4280                                                                Person::players[0]->hasvictim &&
4281                                                                Person::players[0]->animTarget == swordslashanim) &&
4282                                                              attackweapon == sword &&
4283                                                              Person::players[k]->weaponmissdelay <= 0)
4284                                                         Person::players[k]->animTarget = swordslashanim;
4285                                                     //staffhit
4286                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4287                                                                Person::players[0]->hasvictim &&
4288                                                                Person::players[0]->animTarget == swordslashanim) &&
4289                                                              attackweapon == staff &&
4290                                                              Person::players[k]->weaponmissdelay <= 0 &&
4291                                                              randattack < 3)
4292                                                         Person::players[k]->animTarget = staffhitanim;
4293                                                     //staffspinhit
4294                                                     else if (!(Person::players[0]->victim == Person::players[i] &&
4295                                                                Person::players[0]->hasvictim &&
4296                                                                Person::players[0]->animTarget == swordslashanim) &&
4297                                                              attackweapon == staff &&
4298                                                              Person::players[k]->weaponmissdelay <= 0 &&
4299                                                              randattack >= 3)
4300                                                         Person::players[k]->animTarget = staffspinhitanim;
4301                                                     //spinkick
4302                                                     else if ((tutoriallevel != 1 || !attackweapon) &&
4303                                                              distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4304                                                              randattack == 1 &&
4305                                                              animation[Person::players[i]->animTarget].height != lowheight)
4306                                                         Person::players[k]->animTarget = spinkickanim;
4307                                                     //lowkick
4308                                                     else if (distance < 2.5 * sq(Person::players[k]->scale * 5) &&
4309                                                              animation[Person::players[i]->animTarget].height == lowheight &&
4310                                                              animation[Person::players[k]->animTarget].attack != normalattack)
4311                                                         Person::players[k]->animTarget = lowkickanim;
4312                                                 }
4313                                             }
4314                                         }
4315                                         //upunch becomes wolfslap
4316                                         if (Person::players[k]->animTarget == upunchanim && Person::players[k]->creature == wolftype)
4317                                             Person::players[k]->animTarget = wolfslapanim;
4318                                     }
4319                                     //sneak attacks
4320                                     if ((k == 0) && (tutoriallevel != 1 || tutorialstage == 22) &&
4321                                             Person::players[i]->howactive < typedead1 &&
4322                                             distance < 1.5 * sq(Person::players[k]->scale * 5) &&
4323                                             !Person::players[i]->skeleton.free &&
4324                                             Person::players[i]->animTarget != getupfrombackanim &&
4325                                             Person::players[i]->animTarget != getupfromfrontanim &&
4326                                             (Person::players[i]->stunned > 0 && Person::players[k]->madskills ||
4327                                              Person::players[i]->surprised > 0 ||
4328                                              Person::players[i]->aitype == passivetype ||
4329                                              attackweapon && Person::players[i]->stunned > 0) &&
4330                                             normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[k]->coords) > 0) {
4331                                         //sneakattack
4332                                         if (!attackweapon) {
4333                                             Person::players[k]->animCurrent = sneakattackanim;
4334                                             Person::players[k]->animTarget = sneakattackanim;
4335                                             Person::players[i]->animCurrent = sneakattackedanim;
4336                                             Person::players[i]->animTarget = sneakattackedanim;
4337                                             Person::players[k]->oldcoords = Person::players[k]->coords;
4338                                             Person::players[k]->coords = Person::players[i]->coords;
4339                                         }
4340                                         //knifesneakattack
4341                                         if (attackweapon == knife) {
4342                                             Person::players[k]->animCurrent = knifesneakattackanim;
4343                                             Person::players[k]->animTarget = knifesneakattackanim;
4344                                             Person::players[i]->animCurrent = knifesneakattackedanim;
4345                                             Person::players[i]->animTarget = knifesneakattackedanim;
4346                                             Person::players[i]->oldcoords = Person::players[i]->coords;
4347                                             Person::players[i]->coords = Person::players[k]->coords;
4348                                         }
4349                                         //swordsneakattack
4350                                         if (attackweapon == sword) {
4351                                             Person::players[k]->animCurrent = swordsneakattackanim;
4352                                             Person::players[k]->animTarget = swordsneakattackanim;
4353                                             Person::players[i]->animCurrent = swordsneakattackedanim;
4354                                             Person::players[i]->animTarget = swordsneakattackedanim;
4355                                             Person::players[i]->oldcoords = Person::players[i]->coords;
4356                                             Person::players[i]->coords = Person::players[k]->coords;
4357                                         }
4358                                         if (attackweapon != staff) {
4359                                             Person::players[k]->victim = Person::players[i];
4360                                             Person::players[k]->hasvictim = 1;
4361                                             Person::players[i]->targettilt2 = 0;
4362                                             Person::players[i]->frameTarget = 1;
4363                                             Person::players[i]->frameCurrent = 0;
4364                                             Person::players[i]->target = 0;
4365                                             Person::players[i]->velocity = 0;
4366                                             Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
4367                                             Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
4368                                             Person::players[k]->frameTarget = Person::players[i]->frameTarget;
4369                                             Person::players[k]->target = Person::players[i]->target;
4370                                             Person::players[k]->velocity = 0;
4371                                             Person::players[k]->targetyaw = Person::players[i]->yaw;
4372                                             Person::players[k]->yaw = Person::players[i]->yaw;
4373                                             Person::players[i]->targetyaw = Person::players[i]->yaw;
4374                                         }
4375                                     }
4376                                     if (animation[Person::players[k]->animTarget].attack == normalattack &&
4377                                             Person::players[k]->victim == Person::players[i] &&
4378                                             (!Person::players[i]->skeleton.free)) {
4379                                         oldattackkey = 1;
4380                                         Person::players[k]->frameTarget = 0;
4381                                         Person::players[k]->target = 0;
4382
4383                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4384                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4385                                         Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
4386                                         Person::players[k]->lastattack2 = Person::players[k]->lastattack;
4387                                         Person::players[k]->lastattack = Person::players[k]->animTarget;
4388                                     }
4389                                     if (Person::players[k]->animTarget == knifefollowanim &&
4390                                             Person::players[k]->victim == Person::players[i]) {
4391                                         oldattackkey = 1;
4392                                         Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, Person::players[i]->coords);
4393                                         Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, Person::players[i]->coords);
4394                                         Person::players[k]->victim = Person::players[i];
4395                                         Person::players[k]->hasvictim = 1;
4396                                         Person::players[i]->animTarget = knifefollowedanim;
4397                                         Person::players[i]->animCurrent = knifefollowedanim;
4398                                         Person::players[i]->targettilt2 = 0;
4399                                         Person::players[i]->targettilt2 = Person::players[k]->targettilt2;
4400                                         Person::players[i]->frameTarget = 1;
4401                                         Person::players[i]->frameCurrent = 0;
4402                                         Person::players[i]->target = 0;
4403                                         Person::players[i]->velocity = 0;
4404                                         Person::players[k]->animCurrent = knifefollowanim;
4405                                         Person::players[k]->animTarget = knifefollowanim;
4406                                         Person::players[k]->targettilt2 = Person::players[i]->targettilt2;
4407                                         Person::players[k]->frameCurrent = Person::players[i]->frameCurrent;
4408                                         Person::players[k]->frameTarget = Person::players[i]->frameTarget;
4409                                         Person::players[k]->target = Person::players[i]->target;
4410                                         Person::players[k]->velocity = 0;
4411                                         Person::players[k]->oldcoords = Person::players[k]->coords;
4412                                         Person::players[i]->coords = Person::players[k]->coords;
4413                                         Person::players[i]->targetyaw = Person::players[k]->targetyaw;
4414                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
4415                                         Person::players[k]->yaw = Person::players[k]->targetyaw;
4416                                         Person::players[i]->yaw = Person::players[k]->targetyaw;
4417                                     }
4418                                 }
4419                         }
4420                     const bool hasstaff = attackweapon == staff;
4421                     if (k == 0 && Person::players.size() > 1)
4422                         for (unsigned i = 0; i < Person::players.size(); i++) {
4423                             if (i == k)
4424                                 continue;
4425                             if ((playerrealattackkeydown || Person::players[i]->dead || !hasstaff) &&
4426                                     animation[Person::players[k]->animTarget].attack == neutral) {
4427                                 const float distance = distsq(&Person::players[k]->coords, &Person::players[i]->coords);
4428                                 if (!Person::players[i]->dead || !realthreat || (!attackweapon && Person::players[k]->crouchkeydown))
4429                                     if (Person::players[i]->skeleton.free)
4430                                         if (distance < 3.5 * sq(Person::players[k]->scale * 5) &&
4431                                                 (Person::players[i]->dead ||
4432                                                  Person::players[i]->skeleton.longdead > 1000 ||
4433                                                  Person::players[k]->isRun() ||
4434                                                  hasstaff ||
4435                                                  (attackweapon &&
4436                                                   (Person::players[i]->skeleton.longdead > 2000 ||
4437                                                    Person::players[i]->damage > Person::players[i]->damagetolerance / 8 ||
4438                                                    Person::players[i]->bloodloss > Person::players[i]->damagetolerance / 2) &&
4439                                                   distance < 1.5 * sq(Person::players[k]->scale * 5)))) {
4440                                             Person::players[k]->victim = Person::players[i];
4441                                             Person::players[k]->hasvictim = 1;
4442                                             if (attackweapon && tutoriallevel != 1) {
4443                                                 //crouchstab
4444                                                 if (Person::players[k]->crouchkeydown && attackweapon == knife && distance < 1.5 * sq(Person::players[k]->scale * 5))
4445                                                     Person::players[k]->animTarget = crouchstabanim;
4446                                                 //swordgroundstab
4447                                                 if (Person::players[k]->crouchkeydown && distance < 1.5 * sq(Person::players[k]->scale * 5) && attackweapon == sword)
4448                                                     Person::players[k]->animTarget = swordgroundstabanim;
4449                                                 //staffgroundsmash
4450                                                 if (distance < 3.5 * sq(Person::players[k]->scale * 5) && attackweapon == staff)
4451                                                     Person::players[k]->animTarget = staffgroundsmashanim;
4452                                             }
4453                                             if (distance < 2.5 &&
4454                                                     Person::players[k]->crouchkeydown &&
4455                                                     Person::players[k]->animTarget != crouchstabanim &&
4456                                                     !attackweapon &&
4457                                                     Person::players[i]->dead &&
4458                                                     Person::players[i]->skeleton.free &&
4459                                                     Person::players[i]->skeleton.longdead > 1000) {
4460                                                 Person::players[k]->animTarget = killanim;
4461                                                 //TODO: refactor this out, what does it do?
4462                                                 for (int j = 0; j < terrain.numdecals; j++) {
4463                                                     if ((terrain.decaltype[j] == blooddecal || terrain.decaltype[j] == blooddecalslow) &&
4464                                                             terrain.decalalivetime[j] < 2)
4465                                                         terrain.DeleteDecal(j);
4466                                                 }
4467                                                 for (int l = 0; l < objects.numobjects; l++) {
4468                                                     if (objects.model[l].type == decalstype)
4469                                                         for (int j = 0; j < objects.model[l].numdecals; j++) {
4470                                                             if ((objects.model[l].decaltype[j] == blooddecal ||
4471                                                                     objects.model[l].decaltype[j] == blooddecalslow) &&
4472                                                                     objects.model[l].decalalivetime[j] < 2)
4473                                                                 objects.model[l].DeleteDecal(j);
4474                                                         }
4475                                                 }
4476                                             }
4477                                             if (!Person::players[i]->dead || musictype != 2)
4478                                                 if (distance < 3.5 &&
4479                                                         (Person::players[k]->isRun() || Person::players[k]->isIdle() && Person::players[k]->attackkeydown) &&
4480                                                         Person::players[k]->staggerdelay <= 0 &&
4481                                                         (Person::players[i]->dead ||
4482                                                          Person::players[i]->skeleton.longdead < 300 &&
4483                                                          Person::players[k]->lastattack != spinkickanim &&
4484                                                          Person::players[i]->skeleton.free) &&
4485                                                         (!Person::players[i]->dead || musictype != stream_fighttheme)) {
4486                                                     Person::players[k]->animTarget = dropkickanim;
4487                                                     for (int j = 0; j < terrain.numdecals; j++) {
4488                                                         if ((terrain.decaltype[j] == blooddecal || terrain.decaltype[j] == blooddecalslow) &&
4489                                                                 terrain.decalalivetime[j] < 2) {
4490                                                             terrain.DeleteDecal(j);
4491                                                         }
4492                                                     }
4493                                                     for (int l = 0; l < objects.numobjects; l++) {
4494                                                         if (objects.model[l].type == decalstype)
4495                                                             for (int j = 0; j < objects.model[l].numdecals; j++) {
4496                                                                 if ((objects.model[l].decaltype[j] == blooddecal ||
4497                                                                         objects.model[l].decaltype[j] == blooddecalslow) &&
4498                                                                         objects.model[l].decalalivetime[j] < 2) {
4499                                                                     objects.model[l].DeleteDecal(j);
4500                                                                 }
4501                                                             }
4502                                                     }
4503                                                 }
4504                                         }
4505                                 if (animation[Person::players[k]->animTarget].attack == normalattack &&
4506                                         Person::players[k]->victim == Person::players[i] &&
4507                                         (!Person::players[i]->skeleton.free ||
4508                                          Person::players[k]->animTarget == killanim ||
4509                                          Person::players[k]->animTarget == crouchstabanim ||
4510                                          Person::players[k]->animTarget == swordgroundstabanim ||
4511                                          Person::players[k]->animTarget == staffgroundsmashanim ||
4512                                          Person::players[k]->animTarget == dropkickanim)) {
4513                                     oldattackkey = 1;
4514                                     Person::players[k]->frameTarget = 0;
4515                                     Person::players[k]->target = 0;
4516
4517                                     XYZ targetpoint = Person::players[i]->coords;
4518                                     if (Person::players[k]->animTarget == crouchstabanim ||
4519                                             Person::players[k]->animTarget == swordgroundstabanim ||
4520                                             Person::players[k]->animTarget == staffgroundsmashanim) {
4521                                         targetpoint += (Person::players[i]->jointPos(abdomen) +
4522                                                         Person::players[i]->jointPos(neck)) / 2 *
4523                                                        Person::players[i]->scale;
4524                                     }
4525                                     Person::players[k]->targetyaw = roughDirectionTo(Person::players[k]->coords, targetpoint);
4526                                     Person::players[k]->targettilt2 = pitchTo(Person::players[k]->coords, targetpoint);
4527
4528                                     if (Person::players[k]->animTarget == crouchstabanim || Person::players[k]->animTarget == swordgroundstabanim) {
4529                                         Person::players[k]->targetyaw += (float)(abs(Random() % 100) - 50) / 4;
4530                                     }
4531
4532                                     if (Person::players[k]->animTarget == staffgroundsmashanim)
4533                                         Person::players[k]->targettilt2 += 10;
4534
4535                                     Person::players[k]->lastattack3 = Person::players[k]->lastattack2;
4536                                     Person::players[k]->lastattack2 = Person::players[k]->lastattack;
4537                                     Person::players[k]->lastattack = Person::players[k]->animTarget;
4538
4539                                     if (Person::players[k]->animTarget == swordgroundstabanim) {
4540                                         Person::players[k]->targetyaw += 30;
4541                                     }
4542                                 }
4543                             }
4544                         }
4545                     if (!Person::players[k]->hasvictim) {
4546                         //find victim
4547                         for (unsigned i = 0; i < Person::players.size(); i++) {
4548                             if (i == k || !(i == 0 || k == 0))
4549                                 continue;
4550                             if (!Person::players[i]->skeleton.free) {
4551                                 if (Person::players[k]->hasvictim) {
4552                                     if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) <
4553                                             distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords))
4554                                         Person::players[k]->victim = Person::players[i];
4555                                 } else {
4556                                     Person::players[k]->victim = Person::players[i];
4557                                     Person::players[k]->hasvictim = 1;
4558                                 }
4559                             }
4560                         }
4561                     }
4562                     if (Person::players[k]->aitype == playercontrolled)
4563                         //rabbit kick
4564                         if (Person::players[k]->attackkeydown &&
4565                                 Person::players[k]->isRun() &&
4566                                 Person::players[k]->wasRun() &&
4567                                 ((Person::players[k]->hasvictim &&
4568                                   distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) < 12 * sq(Person::players[k]->scale * 5) &&
4569                                   distsq(&Person::players[k]->coords, &Person::players[k]->victim->coords) > 7 * sq(Person::players[k]->scale * 5) &&
4570                                   !Person::players[k]->victim->skeleton.free &&
4571                                   Person::players[k]->victim->animTarget != getupfrombackanim &&
4572                                   Person::players[k]->victim->animTarget != getupfromfrontanim &&
4573                                   animation[Person::players[k]->victim->animTarget].height != lowheight &&
4574                                   Person::players[k]->aitype != playercontrolled && //wat???
4575                                   normaldotproduct(Person::players[k]->facing, Person::players[k]->victim->coords - Person::players[k]->coords) > 0 &&
4576                                   Person::players[k]->rabbitkickenabled) ||
4577                                  Person::players[k]->jumpkeydown)) {
4578                             oldattackkey = 1;
4579                             Person::players[k]->setAnimation(rabbitkickanim);
4580                         }
4581                     //update counts
4582                     if (animation[Person::players[k]->animTarget].attack && k == 0) {
4583                         numattacks++;
4584                         switch (attackweapon) {
4585                         case 0:
4586                             numunarmedattack++;
4587                             break;
4588                         case knife:
4589                             numknifeattack++;
4590                             break;
4591                         case sword:
4592                             numswordattack++;
4593                             break;
4594                         case staff:
4595                             numstaffattack++;
4596                             break;
4597                         }
4598                     }
4599                 }
4600             }
4601         }
4602     }
4603 }
4604
4605 void doPlayerCollisions()
4606 {
4607     static XYZ rotatetarget;
4608     static float collisionradius;
4609     if (Person::players.size() > 1)
4610         for (unsigned k = 0; k < Person::players.size(); k++)
4611             for (unsigned i = k + 1; i < Person::players.size(); i++) {
4612                 //neither player is part of a reversal
4613                 if ((animation[Person::players[i]->animTarget].attack != reversed &&
4614                         animation[Person::players[i]->animTarget].attack != reversal &&
4615                         animation[Person::players[k]->animTarget].attack != reversed &&
4616                         animation[Person::players[k]->animTarget].attack != reversal) || (i != 0 && k != 0))
4617                     if ((animation[Person::players[i]->animCurrent].attack != reversed &&
4618                             animation[Person::players[i]->animCurrent].attack != reversal &&
4619                             animation[Person::players[k]->animCurrent].attack != reversed &&
4620                             animation[Person::players[k]->animCurrent].attack != reversal) || (i != 0 && k != 0))
4621                         //neither is sleeping
4622                         if (Person::players[i]->howactive <= typesleeping && Person::players[k]->howactive <= typesleeping)
4623                             if (Person::players[i]->howactive != typesittingwall && Person::players[k]->howactive != typesittingwall)
4624                                 //in same patch, neither is climbing
4625                                 if (Person::players[i]->whichpatchx == Person::players[k]->whichpatchx &&
4626                                         Person::players[i]->whichpatchz == Person::players[k]->whichpatchz &&
4627                                         Person::players[k]->skeleton.oldfree == Person::players[k]->skeleton.free &&
4628                                         Person::players[i]->skeleton.oldfree == Person::players[i]->skeleton.free &&
4629                                         Person::players[i]->animTarget != climbanim &&
4630                                         Person::players[i]->animTarget != hanganim &&
4631                                         Person::players[k]->animTarget != climbanim &&
4632                                         Person::players[k]->animTarget != hanganim)
4633                                     //players are close (bounding box test)
4634                                     if (Person::players[i]->coords.y > Person::players[k]->coords.y - 3)
4635                                         if (Person::players[i]->coords.y < Person::players[k]->coords.y + 3)
4636                                             if (Person::players[i]->coords.x > Person::players[k]->coords.x - 3)
4637                                                 if (Person::players[i]->coords.x < Person::players[k]->coords.x + 3)
4638                                                     if (Person::players[i]->coords.z > Person::players[k]->coords.z - 3)
4639                                                         if (Person::players[i]->coords.z < Person::players[k]->coords.z + 3) {
4640                                                             //spread fire from player to player
4641                                                             if (distsq(&Person::players[i]->coords, &Person::players[k]->coords)
4642                                                                     < 3 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
4643                                                                 if (Person::players[i]->onfire || Person::players[k]->onfire) {
4644                                                                     if (!Person::players[i]->onfire)
4645                                                                         Person::players[i]->CatchFire();
4646                                                                     if (!Person::players[k]->onfire)
4647                                                                         Person::players[k]->CatchFire();
4648                                                                 }
4649                                                             }
4650
4651                                                             XYZ tempcoords1 = Person::players[i]->coords;
4652                                                             XYZ tempcoords2 = Person::players[k]->coords;
4653                                                             if (!Person::players[i]->skeleton.oldfree)
4654                                                                 tempcoords1.y += Person::players[i]->jointPos(abdomen).y * Person::players[i]->scale;
4655                                                             if (!Person::players[k]->skeleton.oldfree)
4656                                                                 tempcoords2.y += Person::players[k]->jointPos(abdomen).y * Person::players[k]->scale;
4657                                                             collisionradius = 1.2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4658                                                             if (Person::players[0]->hasvictim)
4659                                                                 if (Person::players[0]->animTarget == rabbitkickanim && (k == 0 || i == 0) && !Person::players[0]->victim->skeleton.free)
4660                                                                     collisionradius = 3;
4661                                                             if ((!Person::players[i]->skeleton.oldfree || !Person::players[k]->skeleton.oldfree) &&
4662                                                                     (distsq(&tempcoords1, &tempcoords2) < collisionradius ||
4663                                                                      distsq(&Person::players[i]->coords, &Person::players[k]->coords) < collisionradius)) {
4664                                                                 //jump down on a dead body
4665                                                                 if (k == 0 || i == 0) {
4666                                                                     int l = i ? i : k;
4667                                                                     if (Person::players[0]->animTarget == jumpdownanim &&
4668                                                                             !Person::players[0]->skeleton.oldfree &&
4669                                                                             !Person::players[0]->skeleton.free &&
4670                                                                             Person::players[l]->skeleton.oldfree &&
4671                                                                             Person::players[l]->skeleton.free &&
4672                                                                             Person::players[l]->dead &&
4673                                                                             Person::players[0]->lastcollide <= 0 &&
4674                                                                             fabs(Person::players[l]->coords.y - Person::players[0]->coords.y) < .2 &&
4675                                                                             distsq(&Person::players[0]->coords, &Person::players[l]->coords) < .7 * sq((Person::players[l]->scale + Person::players[0]->scale) * 2.5)) {
4676                                                                         Person::players[0]->coords.y = Person::players[l]->coords.y;
4677                                                                         Person::players[l]->velocity = Person::players[0]->velocity;
4678                                                                         Person::players[l]->skeleton.free = 0;
4679                                                                         Person::players[l]->yaw = 0;
4680                                                                         Person::players[l]->RagDoll(0);
4681                                                                         Person::players[l]->DoDamage(20);
4682                                                                         camerashake += .3;
4683                                                                         Person::players[l]->skeleton.longdead = 0;
4684                                                                         Person::players[0]->lastcollide = 1;
4685                                                                     }
4686                                                                 }
4687
4688                                                                 if (     (Person::players[i]->skeleton.oldfree == 1 && findLengthfast(&Person::players[i]->velocity) > 1) ||
4689                                                                          (Person::players[k]->skeleton.oldfree == 1 && findLengthfast(&Person::players[k]->velocity) > 1) ||
4690                                                                          (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0)) {
4691                                                                     rotatetarget = Person::players[k]->velocity - Person::players[i]->velocity;
4692                                                                     if ((Person::players[i]->animTarget != getupfrombackanim && Person::players[i]->animTarget != getupfromfrontanim ||
4693                                                                             Person::players[i]->skeleton.free) &&
4694                                                                             (Person::players[k]->animTarget != getupfrombackanim && Person::players[k]->animTarget != getupfromfrontanim ||
4695                                                                              Person::players[k]->skeleton.free))
4696                                                                         if ((((k != 0 && findLengthfast(&rotatetarget) > 150 ||
4697                                                                                 k == 0 && findLengthfast(&rotatetarget) > 50 && Person::players[0]->rabbitkickragdoll) &&
4698                                                                                 normaldotproduct(rotatetarget, Person::players[k]->coords - Person::players[i]->coords) > 0) &&
4699                                                                                 (k == 0 ||
4700                                                                                  k != 0 && Person::players[i]->skeleton.oldfree == 1 && animation[Person::players[k]->animCurrent].attack == neutral ||
4701                                                                                  /*i!=0&&*/Person::players[k]->skeleton.oldfree == 1 && animation[Person::players[i]->animCurrent].attack == neutral)) ||
4702                                                                                 (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) &&
4703                                                                                 (Person::players[k]->animTarget == jumpupanim || Person::players[k]->animTarget == jumpdownanim || Person::players[k]->isFlip()) &&
4704                                                                                 k == 0 && !Person::players[i]->skeleton.oldfree && !Person::players[k]->skeleton.oldfree) {
4705                                                                             //If hit by body
4706                                                                             if (     (i != 0 || Person::players[i]->skeleton.free) &&
4707                                                                                      (k != 0 || Person::players[k]->skeleton.free) ||
4708                                                                                      (animation[Person::players[i]->animTarget].height == highheight &&
4709                                                                                       animation[Person::players[k]->animTarget].height == highheight)) {
4710                                                                                 if (tutoriallevel != 1) {
4711                                                                                     emit_sound_at(heavyimpactsound, Person::players[i]->coords);
4712                                                                                 }
4713
4714                                                                                 Person::players[i]->RagDoll(0);
4715                                                                                 if (Person::players[i]->damage > Person::players[i]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[i]->dead) {
4716                                                                                     award_bonus(0, aimbonus);
4717                                                                                 }
4718                                                                                 Person::players[i]->DoDamage(findLengthfast(&rotatetarget) / 4);
4719                                                                                 Person::players[k]->RagDoll(0);
4720                                                                                 if (Person::players[k]->damage > Person::players[k]->damagetolerance - findLengthfast(&rotatetarget) / 4 && !Person::players[k]->dead) {
4721                                                                                     award_bonus(0, aimbonus); // Huh, again?
4722                                                                                 }
4723                                                                                 Person::players[k]->DoDamage(findLengthfast(&rotatetarget) / 4);
4724
4725                                                                                 for (int j = 0; j < Person::players[i]->skeleton.num_joints; j++) {
4726                                                                                     Person::players[i]->skeleton.joints[j].velocity = Person::players[i]->skeleton.joints[j].velocity / 5 + Person::players[k]->velocity;
4727                                                                                 }
4728                                                                                 for (int j = 0; j < Person::players[k]->skeleton.num_joints; j++) {
4729                                                                                     Person::players[k]->skeleton.joints[j].velocity = Person::players[k]->skeleton.joints[j].velocity / 5 + Person::players[i]->velocity;
4730                                                                                 }
4731
4732                                                                             }
4733                                                                         }
4734                                                                     if (     (animation[Person::players[i]->animTarget].attack == neutral ||
4735                                                                               animation[Person::players[i]->animTarget].attack == normalattack) &&
4736                                                                              (animation[Person::players[k]->animTarget].attack == neutral ||
4737                                                                               animation[Person::players[k]->animTarget].attack == normalattack)) {
4738                                                                         //If bumped
4739                                                                         if (Person::players[i]->skeleton.oldfree == 0 && Person::players[k]->skeleton.oldfree == 0) {
4740                                                                             if (distsq(&Person::players[k]->coords, &Person::players[i]->coords) < .5 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5)) {
4741                                                                                 rotatetarget = Person::players[k]->coords - Person::players[i]->coords;
4742                                                                                 Normalise(&rotatetarget);
4743                                                                                 Person::players[k]->coords = (Person::players[k]->coords + Person::players[i]->coords) / 2;
4744                                                                                 Person::players[i]->coords = Person::players[k]->coords - rotatetarget * fast_sqrt(.6) / 2
4745                                                                                                    * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4746                                                                                 Person::players[k]->coords += rotatetarget * fast_sqrt(.6) / 2 * sq((Person::players[i]->scale + Person::players[k]->scale) * 2.5);
4747                                                                                 if (Person::players[k]->howactive == typeactive || hostile)
4748                                                                                     if (Person::players[k]->isIdle()) {
4749                                                                                         if (Person::players[k]->howactive < typesleeping)
4750                                                                                             Person::players[k]->setAnimation(Person::players[k]->getStop());
4751                                                                                         else if (Person::players[k]->howactive == typesleeping)
4752                                                                                             Person::players[k]->setAnimation(getupfromfrontanim);
4753                                                                                         if (!editorenabled)
4754                                                                                             Person::players[k]->howactive = typeactive;
4755                                                                                     }
4756                                                                                 if (Person::players[i]->howactive == typeactive || hostile)
4757                                                                                     if (Person::players[i]->isIdle()) {
4758                                                                                         if (Person::players[i]->howactive < typesleeping)
4759                                                                                             Person::players[i]->setAnimation(Person::players[k]->getStop());
4760                                                                                         else
4761                                                                                             Person::players[i]->setAnimation(getupfromfrontanim);
4762                                                                                         if (!editorenabled)
4763                                                                                             Person::players[i]->howactive = typeactive;
4764                                                                                     }
4765                                                                             }
4766                                                                             //jump down on player
4767                                                                             if (hostile) {
4768                                                                                 if (k == 0 && i != 0 && Person::players[k]->animTarget == jumpdownanim &&
4769                                                                                         !Person::players[i]->isCrouch() &&
4770                                                                                         Person::players[i]->animTarget != rollanim &&
4771                                                                                         !Person::players[k]->skeleton.oldfree && !
4772                                                                                         Person::players[k]->skeleton.free &&
4773                                                                                         Person::players[k]->lastcollide <= 0 &&
4774                                                                                         Person::players[k]->velocity.y < -10) {
4775                                                                                     Person::players[i]->velocity = Person::players[k]->velocity;
4776                                                                                     Person::players[k]->velocity = Person::players[k]->velocity * -.5;
4777                                                                                     Person::players[k]->velocity.y = Person::players[i]->velocity.y;
4778                                                                                     Person::players[i]->DoDamage(20);
4779                                                                                     Person::players[i]->RagDoll(0);
4780                                                                                     Person::players[k]->lastcollide = 1;
4781                                                                                     award_bonus(k, AboveBonus);
4782                                                                                 }
4783                                                                                 if (i == 0 && k != 0 && Person::players[i]->animTarget == jumpdownanim &&
4784                                                                                         !Person::players[k]->isCrouch() &&
4785                                                                                         Person::players[k]->animTarget != rollanim &&
4786                                                                                         !Person::players[i]->skeleton.oldfree &&
4787                                                                                         !Person::players[i]->skeleton.free &&
4788                                                                                         Person::players[i]->lastcollide <= 0 &&
4789                                                                                         Person::players[i]->velocity.y < -10) {
4790                                                                                     Person::players[k]->velocity = Person::players[i]->velocity;
4791                                                                                     Person::players[i]->velocity = Person::players[i]->velocity * -.3;
4792                                                                                     Person::players[i]->velocity.y = Person::players[k]->velocity.y;
4793                                                                                     Person::players[k]->DoDamage(20);
4794                                                                                     Person::players[k]->RagDoll(0);
4795                                                                                     Person::players[i]->lastcollide = 1;
4796                                                                                     award_bonus(i, AboveBonus);
4797                                                                                 }
4798                                                                             }
4799                                                                         }
4800                                                                     }
4801                                                                 }
4802                                                                 Person::players[i]->CheckKick();
4803                                                                 Person::players[k]->CheckKick();
4804                                                             }
4805                                                         }
4806             }
4807 }
4808
4809 void doAI(unsigned i)
4810 {
4811     static bool connected;
4812     if (Person::players[i]->aitype != playercontrolled && indialogue == -1) {
4813         Person::players[i]->jumpclimb = 0;
4814         //disable movement in editor
4815         if (editorenabled)
4816             Person::players[i]->stunned = 1;
4817
4818         Person::players[i]->pause = 0;
4819         if (distsqflat(&Person::players[0]->coords, &Person::players[i]->coords) < 30 &&
4820                 Person::players[0]->coords.y > Person::players[i]->coords.y + 2 &&
4821                 !Person::players[0]->onterrain)
4822             Person::players[i]->pause = 1;
4823
4824         //pathfinding
4825         if (Person::players[i]->aitype == pathfindtype) {
4826             if (Person::players[i]->finalpathfindpoint == -1) {
4827                 float closestdistance;
4828                 float tempdist;
4829                 int closest;
4830                 XYZ colpoint;
4831                 closest = -1;
4832                 closestdistance = -1;
4833                 for (int j = 0; j < numpathpoints; j++)
4834                     if (closest == -1 || distsq(&Person::players[i]->finalfinaltarget, &pathpoint[j]) < closestdistance) {
4835                         closestdistance = distsq(&Person::players[i]->finalfinaltarget, &pathpoint[j]);
4836                         closest = j;
4837                         Person::players[i]->finaltarget = pathpoint[j];
4838                     }
4839                 Person::players[i]->finalpathfindpoint = closest;
4840                 for (int j = 0; j < numpathpoints; j++)
4841                     for (int k = 0; k < numpathpointconnect[j]; k++) {
4842                         DistancePointLine(&Person::players[i]->finalfinaltarget, &pathpoint[j], &pathpoint[pathpointconnect[j][k]], &tempdist, &colpoint );
4843                         if (sq(tempdist) < closestdistance)
4844                             if (findDistance(&colpoint, &pathpoint[j]) + findDistance(&colpoint, &pathpoint[pathpointconnect[j][k]]) <
4845                                     findDistance(&pathpoint[j], &pathpoint[pathpointconnect[j][k]]) + .1) {
4846                                 closestdistance = sq(tempdist);
4847                                 closest = j;
4848                                 Person::players[i]->finaltarget = colpoint;
4849                             }
4850                     }
4851                 Person::players[i]->finalpathfindpoint = closest;
4852
4853             }
4854             if (Person::players[i]->targetpathfindpoint == -1) {
4855                 float closestdistance;
4856                 float tempdist;
4857                 int closest;
4858                 XYZ colpoint;
4859                 closest = -1;
4860                 closestdistance = -1;
4861                 if (Person::players[i]->lastpathfindpoint == -1) {
4862                     for (int j = 0; j < numpathpoints; j++) {
4863                         if (j != Person::players[i]->lastpathfindpoint)
4864                             if (closest == -1 || (distsq(&Person::players[i]->coords, &pathpoint[j]) < closestdistance)) {
4865                                 closestdistance = distsq(&Person::players[i]->coords, &pathpoint[j]);
4866                                 closest = j;
4867                             }
4868                     }
4869                     Person::players[i]->targetpathfindpoint = closest;
4870                     for (int j = 0; j < numpathpoints; j++)
4871                         if (j != Person::players[i]->lastpathfindpoint)
4872                             for (int k = 0; k < numpathpointconnect[j]; k++) {
4873                                 DistancePointLine(&Person::players[i]->coords, &pathpoint[j], &pathpoint[pathpointconnect[j][k]], &tempdist, &colpoint );
4874                                 if (sq(tempdist) < closestdistance) {
4875                                     if (findDistance(&colpoint, &pathpoint[j]) + findDistance(&colpoint, &pathpoint[pathpointconnect[j][k]]) <
4876                                             findDistance(&pathpoint[j], &pathpoint[pathpointconnect[j][k]]) + .1) {
4877                                         closestdistance = sq(tempdist);
4878                                         closest = j;
4879                                     }
4880                                 }
4881                             }
4882                     Person::players[i]->targetpathfindpoint = closest;
4883                 } else {
4884                     for (int j = 0; j < numpathpoints; j++)
4885                         if (j != Person::players[i]->lastpathfindpoint &&
4886                                 j != Person::players[i]->lastpathfindpoint2 &&
4887                                 j != Person::players[i]->lastpathfindpoint3 &&
4888                                 j != Person::players[i]->lastpathfindpoint4) {
4889                             connected = 0;
4890                             if (numpathpointconnect[j])
4891                                 for (int k = 0; k < numpathpointconnect[j]; k++)
4892                                     if (pathpointconnect[j][k] == Person::players[i]->lastpathfindpoint)
4893                                         connected = 1;
4894                             if (!connected)
4895                                 if (numpathpointconnect[Person::players[i]->lastpathfindpoint])
4896                                     for (int k = 0; k < numpathpointconnect[Person::players[i]->lastpathfindpoint]; k++)
4897                                         if (pathpointconnect[Person::players[i]->lastpathfindpoint][k] == j)
4898                                             connected = 1;
4899                             if (connected) {
4900                                 tempdist = findPathDist(j, Person::players[i]->finalpathfindpoint);
4901                                 if (closest == -1 || tempdist < closestdistance) {
4902                                     closestdistance = tempdist;
4903                                     closest = j;
4904                                 }
4905                             }
4906                         }
4907                     Person::players[i]->targetpathfindpoint = closest;
4908                 }
4909             }
4910             Person::players[i]->losupdatedelay -= multiplier;
4911
4912             Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, pathpoint[Person::players[i]->targetpathfindpoint]);
4913             Person::players[i]->lookyaw = Person::players[i]->targetyaw;
4914
4915             //reached target point
4916             if (distsqflat(&Person::players[i]->coords, &pathpoint[Person::players[i]->targetpathfindpoint]) < .6) {
4917                 Person::players[i]->lastpathfindpoint4 = Person::players[i]->lastpathfindpoint3;
4918                 Person::players[i]->lastpathfindpoint3 = Person::players[i]->lastpathfindpoint2;
4919                 Person::players[i]->lastpathfindpoint2 = Person::players[i]->lastpathfindpoint;
4920                 Person::players[i]->lastpathfindpoint = Person::players[i]->targetpathfindpoint;
4921                 if (Person::players[i]->lastpathfindpoint2 == -1)
4922                     Person::players[i]->lastpathfindpoint2 = Person::players[i]->lastpathfindpoint;
4923                 if (Person::players[i]->lastpathfindpoint3 == -1)
4924                     Person::players[i]->lastpathfindpoint3 = Person::players[i]->lastpathfindpoint2;
4925                 if (Person::players[i]->lastpathfindpoint4 == -1)
4926                     Person::players[i]->lastpathfindpoint4 = Person::players[i]->lastpathfindpoint3;
4927                 Person::players[i]->targetpathfindpoint = -1;
4928             }
4929             if (     distsqflat(&Person::players[i]->coords, &Person::players[i]->finalfinaltarget) <
4930                      distsqflat(&Person::players[i]->coords, &Person::players[i]->finaltarget) ||
4931                      distsqflat(&Person::players[i]->coords, &Person::players[i]->finaltarget) < .6 * sq(Person::players[i]->scale * 5) ||
4932                      Person::players[i]->lastpathfindpoint == Person::players[i]->finalpathfindpoint) {
4933                 Person::players[i]->aitype = passivetype;
4934             }
4935
4936             Person::players[i]->forwardkeydown = 1;
4937             Person::players[i]->leftkeydown = 0;
4938             Person::players[i]->backkeydown = 0;
4939             Person::players[i]->rightkeydown = 0;
4940             Person::players[i]->crouchkeydown = 0;
4941             Person::players[i]->attackkeydown = 0;
4942             Person::players[i]->throwkeydown = 0;
4943
4944             if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8)
4945                 Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
4946
4947             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
4948                 Person::players[i]->jumpkeydown = 0;
4949             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
4950                 Person::players[i]->jumpkeydown = 1;
4951
4952             if ((tutoriallevel != 1 || cananger) &&
4953                     hostile &&
4954                     !Person::players[0]->dead &&
4955                     distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400 &&
4956                     Person::players[i]->occluded < 25) {
4957                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 12 &&
4958                         animation[Person::players[0]->animTarget].height != lowheight &&
4959                         !editorenabled &&
4960                         (Person::players[0]->coords.y < Person::players[i]->coords.y + 5 || Person::players[0]->onterrain))
4961                     Person::players[i]->aitype = attacktypecutoff;
4962                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 30 &&
4963                         animation[Person::players[0]->animTarget].height == highheight &&
4964                         !editorenabled)
4965                     Person::players[i]->aitype = attacktypecutoff;
4966
4967                 if (Person::players[i]->losupdatedelay < 0 && !editorenabled && Person::players[i]->occluded < 2) {
4968                     Person::players[i]->losupdatedelay = .2;
4969                     for (unsigned j = 0; j < Person::players.size(); j++)
4970                         if (j == 0 || Person::players[j]->skeleton.free || Person::players[j]->aitype != passivetype)
4971                             if (abs(Random() % 2) || animation[Person::players[j]->animTarget].height != lowheight || j != 0)
4972                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
4973                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
4974                                         if (Person::players[j]->coords.y < Person::players[i]->coords.y + 5 || Person::players[j]->onterrain)
4975                                             if (!Person::players[j]->isWallJump() && -1 == checkcollide(
4976                                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)
4977                                                         *Person::players[i]->scale + Person::players[i]->coords,
4978                                                         DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)
4979                                                         *Person::players[j]->scale + Person::players[j]->coords) ||
4980                                                     (Person::players[j]->animTarget == hanganim &&
4981                                                      normaldotproduct(Person::players[j]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0)) {
4982                                                 Person::players[i]->aitype = searchtype;
4983                                                 Person::players[i]->lastchecktime = 12;
4984                                                 Person::players[i]->lastseen = Person::players[j]->coords;
4985                                                 Person::players[i]->lastseentime = 12;
4986                                             }
4987                 }
4988             }
4989             if (Person::players[i]->aitype == attacktypecutoff && musictype != 2)
4990                 if (Person::players[i]->creature != wolftype) {
4991                     Person::players[i]->stunned = .6;
4992                     Person::players[i]->surprised = .6;
4993                 }
4994         }
4995
4996         if (Person::players[i]->aitype != passivetype && leveltime > .5)
4997             Person::players[i]->howactive = typeactive;
4998
4999         if (Person::players[i]->aitype == passivetype) {
5000             Person::players[i]->aiupdatedelay -= multiplier;
5001             Person::players[i]->losupdatedelay -= multiplier;
5002             Person::players[i]->lastseentime += multiplier;
5003             Person::players[i]->pausetime -= multiplier;
5004             if (Person::players[i]->lastseentime > 1)
5005                 Person::players[i]->lastseentime = 1;
5006
5007             if (Person::players[i]->aiupdatedelay < 0) {
5008                 if (Person::players[i]->numwaypoints > 1 && Person::players[i]->howactive == typeactive && Person::players[i]->pausetime <= 0) {
5009                     Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[i]->waypoints[Person::players[i]->waypoint]);
5010                     Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5011                     Person::players[i]->aiupdatedelay = .05;
5012
5013                     if (distsqflat(&Person::players[i]->coords, &Person::players[i]->waypoints[Person::players[i]->waypoint]) < 1) {
5014                         if (Person::players[i]->waypointtype[Person::players[i]->waypoint] == wppause)
5015                             Person::players[i]->pausetime = 4;
5016                         Person::players[i]->waypoint++;
5017                         if (Person::players[i]->waypoint > Person::players[i]->numwaypoints - 1)
5018                             Person::players[i]->waypoint = 0;
5019
5020                     }
5021                 }
5022
5023                 if (Person::players[i]->numwaypoints > 1 && Person::players[i]->howactive == typeactive && Person::players[i]->pausetime <= 0)
5024                     Person::players[i]->forwardkeydown = 1;
5025                 else
5026                     Person::players[i]->forwardkeydown = 0;
5027                 Person::players[i]->leftkeydown = 0;
5028                 Person::players[i]->backkeydown = 0;
5029                 Person::players[i]->rightkeydown = 0;
5030                 Person::players[i]->crouchkeydown = 0;
5031                 Person::players[i]->attackkeydown = 0;
5032                 Person::players[i]->throwkeydown = 0;
5033
5034                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5035                     if (!Person::players[i]->avoidsomething)
5036                         Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5037                     else {
5038                         XYZ leftpos, rightpos;
5039                         float leftdist, rightdist;
5040                         leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5041                         rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5042                         leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5043                         rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5044                         if (leftdist < rightdist)
5045                             Person::players[i]->targetyaw += 90;
5046                         else
5047                             Person::players[i]->targetyaw -= 90;
5048                     }
5049                 }
5050             }
5051             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5052                 Person::players[i]->jumpkeydown = 0;
5053             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5054                 Person::players[i]->jumpkeydown = 1;
5055
5056
5057             //hearing sounds
5058             if (!editorenabled) {
5059                 if (Person::players[i]->howactive <= typesleeping)
5060                     if (numenvsounds > 0 && (tutoriallevel != 1 || cananger) && hostile)
5061                         for (int j = 0; j < numenvsounds; j++) {
5062                             float vol = Person::players[i]->howactive == typesleeping ? envsoundvol[j] - 14 : envsoundvol[j];
5063                             if (vol > 0 && distsq(&Person::players[i]->coords, &envsound[j]) <
5064                                     2 * (vol + vol * (Person::players[i]->creature == rabbittype) * 3))
5065                                 Person::players[i]->aitype = attacktypecutoff;
5066                         }
5067
5068                 if (Person::players[i]->aitype != passivetype) {
5069                     if (Person::players[i]->howactive == typesleeping)
5070                         Person::players[i]->setAnimation(getupfromfrontanim);
5071                     Person::players[i]->howactive = typeactive;
5072                 }
5073             }
5074
5075             if (Person::players[i]->howactive < typesleeping &&
5076                     ((tutoriallevel != 1 || cananger) && hostile) &&
5077                     !Person::players[0]->dead &&
5078                     distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400 &&
5079                     Person::players[i]->occluded < 25) {
5080                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 12 &&
5081                         animation[Person::players[0]->animTarget].height != lowheight && !editorenabled)
5082                     Person::players[i]->aitype = attacktypecutoff;
5083                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 30 &&
5084                         animation[Person::players[0]->animTarget].height == highheight && !editorenabled)
5085                     Person::players[i]->aitype = attacktypecutoff;
5086
5087                 //wolf smell
5088                 if (Person::players[i]->creature == wolftype) {
5089                     XYZ windsmell;
5090                     for (unsigned j = 0; j < Person::players.size(); j++) {
5091                         if (j == 0 || (Person::players[j]->dead && Person::players[j]->bloodloss > 0)) {
5092                             float smelldistance = 50;
5093                             if (j == 0 && Person::players[j]->num_weapons > 0) {
5094                                 if (weapons[Person::players[j]->weaponids[0]].bloody)
5095                                     smelldistance = 100;
5096                                 if (Person::players[j]->num_weapons == 2)
5097                                     if (weapons[Person::players[j]->weaponids[1]].bloody)
5098                                         smelldistance = 100;
5099                             }
5100                             if (j != 0)
5101                                 smelldistance = 100;
5102                             windsmell = windvector;
5103                             Normalise(&windsmell);
5104                             windsmell = windsmell * 2 + Person::players[j]->coords;
5105                             if (distsq(&Person::players[i]->coords, &windsmell) < smelldistance && !editorenabled)
5106                                 Person::players[i]->aitype = attacktypecutoff;
5107                         }
5108                     }
5109                 }
5110
5111                 if (Person::players[i]->howactive < typesleeping && Person::players[i]->losupdatedelay < 0 && !editorenabled && Person::players[i]->occluded < 2) {
5112                     Person::players[i]->losupdatedelay = .2;
5113                     for (unsigned j = 0; j < Person::players.size(); j++) {
5114                         if (j == 0 || Person::players[j]->skeleton.free || Person::players[j]->aitype != passivetype) {
5115                             if (abs(Random() % 2) || animation[Person::players[j]->animTarget].height != lowheight || j != 0)
5116                                 if (distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 400)
5117                                     if (normaldotproduct(Person::players[i]->facing, Person::players[j]->coords - Person::players[i]->coords) > 0)
5118                                         if ((-1 == checkcollide(
5119                                                     DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
5120                                                     Person::players[i]->scale + Person::players[i]->coords,
5121                                                     DoRotation(Person::players[j]->jointPos(head), 0, Person::players[j]->yaw, 0)*
5122                                                     Person::players[j]->scale + Person::players[j]->coords) &&
5123                                                 !Person::players[j]->isWallJump()) ||
5124                                                 (Person::players[j]->animTarget == hanganim &&
5125                                                  normaldotproduct(Person::players[j]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0)) {
5126                                             Person::players[i]->lastseentime -= .2;
5127                                             if (j == 0 && animation[Person::players[j]->animTarget].height == lowheight)
5128                                                 Person::players[i]->lastseentime -= .4;
5129                                             else
5130                                                 Person::players[i]->lastseentime -= .6;
5131                                         }
5132                             if (Person::players[i]->lastseentime <= 0) {
5133                                 Person::players[i]->aitype = searchtype;
5134                                 Person::players[i]->lastchecktime = 12;
5135                                 Person::players[i]->lastseen = Person::players[j]->coords;
5136                                 Person::players[i]->lastseentime = 12;
5137                             }
5138                         }
5139                     }
5140                 }
5141             }
5142             //alerted surprise
5143             if (Person::players[i]->aitype == attacktypecutoff && musictype != 2) {
5144                 if (Person::players[i]->creature != wolftype) {
5145                     Person::players[i]->stunned = .6;
5146                     Person::players[i]->surprised = .6;
5147                 }
5148                 if (Person::players[i]->creature == wolftype) {
5149                     Person::players[i]->stunned = .47;
5150                     Person::players[i]->surprised = .47;
5151                 }
5152                 numseen++;
5153             }
5154         }
5155
5156         //search for player
5157         int j;
5158         if (Person::players[i]->aitype == searchtype) {
5159             Person::players[i]->aiupdatedelay -= multiplier;
5160             Person::players[i]->losupdatedelay -= multiplier;
5161             if (!Person::players[i]->pause)
5162                 Person::players[i]->lastseentime -= multiplier;
5163             Person::players[i]->lastchecktime -= multiplier;
5164
5165             if (Person::players[i]->isRun() && !Person::players[i]->onground) {
5166                 if (Person::players[i]->coords.y > terrain.getHeight(Person::players[i]->coords.x, Person::players[i]->coords.z) + 10) {
5167                     XYZ test2 = Person::players[i]->coords + Person::players[i]->facing;
5168                     test2.y += 5;
5169                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
5170                     test.y -= 10;
5171                     j = checkcollide(test2, test, Person::players[i]->laststanding);
5172                     if (j == -1)
5173                         j = checkcollide(test2, test);
5174                     if (j == -1) {
5175                         Person::players[i]->velocity = 0;
5176                         Person::players[i]->setAnimation(Person::players[i]->getStop());
5177                         Person::players[i]->targetyaw += 180;
5178                         Person::players[i]->stunned = .5;
5179                         //Person::players[i]->aitype=passivetype;
5180                         Person::players[i]->aitype = pathfindtype;
5181                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5182                         Person::players[i]->finalpathfindpoint = -1;
5183                         Person::players[i]->targetpathfindpoint = -1;
5184                         Person::players[i]->lastpathfindpoint = -1;
5185                         Person::players[i]->lastpathfindpoint2 = -1;
5186                         Person::players[i]->lastpathfindpoint3 = -1;
5187                         Person::players[i]->lastpathfindpoint4 = -1;
5188                     } else
5189                         Person::players[i]->laststanding = j;
5190                 }
5191             }
5192             //check out last seen location
5193             if (Person::players[i]->aiupdatedelay < 0) {
5194                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[i]->lastseen);
5195                 Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5196                 Person::players[i]->aiupdatedelay = .05;
5197                 Person::players[i]->forwardkeydown = 1;
5198
5199                 if (distsqflat(&Person::players[i]->coords, &Person::players[i]->lastseen) < 1 * sq(Person::players[i]->scale * 5) || Person::players[i]->lastchecktime < 0) {
5200                     Person::players[i]->forwardkeydown = 0;
5201                     Person::players[i]->aiupdatedelay = 1;
5202                     Person::players[i]->lastseen.x += (float(Random() % 100) - 50) / 25;
5203                     Person::players[i]->lastseen.z += (float(Random() % 100) - 50) / 25;
5204                     Person::players[i]->lastchecktime = 3;
5205                 }
5206
5207                 Person::players[i]->leftkeydown = 0;
5208                 Person::players[i]->backkeydown = 0;
5209                 Person::players[i]->rightkeydown = 0;
5210                 Person::players[i]->crouchkeydown = 0;
5211                 Person::players[i]->attackkeydown = 0;
5212                 Person::players[i]->throwkeydown = 0;
5213
5214                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5215                     if (!Person::players[i]->avoidsomething)
5216                         Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5217                     else {
5218                         XYZ leftpos, rightpos;
5219                         float leftdist, rightdist;
5220                         leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5221                         rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5222                         leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5223                         rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5224                         if (leftdist < rightdist)
5225                             Person::players[i]->targetyaw += 90;
5226                         else
5227                             Person::players[i]->targetyaw -= 90;
5228                     }
5229                 }
5230             }
5231             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5232                 Person::players[i]->jumpkeydown = 0;
5233             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5234                 Person::players[i]->jumpkeydown = 1;
5235
5236             if (numenvsounds > 0 && ((tutoriallevel != 1 || cananger) && hostile))
5237                 for (int k = 0; k < numenvsounds; k++) {
5238                     if (distsq(&Person::players[i]->coords, &envsound[k]) < 2 * (envsoundvol[k] + envsoundvol[k] * (Person::players[i]->creature == rabbittype) * 3)) {
5239                         Person::players[i]->aitype = attacktypecutoff;
5240                     }
5241                 }
5242
5243             if (!Person::players[0]->dead &&
5244                     Person::players[i]->losupdatedelay < 0 &&
5245                     !editorenabled &&
5246                     Person::players[i]->occluded < 2 &&
5247                     ((tutoriallevel != 1 || cananger) && hostile)) {
5248                 Person::players[i]->losupdatedelay = .2;
5249                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 4 && animation[Person::players[i]->animTarget].height != lowheight) {
5250                     Person::players[i]->aitype = attacktypecutoff;
5251                     Person::players[i]->lastseentime = 1;
5252                 }
5253                 if (abs(Random() % 2) || animation[Person::players[i]->animTarget].height != lowheight)
5254                     //TODO: factor out canSeePlayer()
5255                     if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 400)
5256                         if (normaldotproduct(Person::players[i]->facing, Person::players[0]->coords - Person::players[i]->coords) > 0)
5257                             if ((checkcollide(
5258                                         DoRotation(Person::players[i]->jointPos(head), 0, Person::players[i]->yaw, 0)*
5259                                         Person::players[i]->scale + Person::players[i]->coords,
5260                                         DoRotation(Person::players[0]->jointPos(head), 0, Person::players[0]->yaw, 0)*
5261                                         Person::players[0]->scale + Person::players[0]->coords) == -1) ||
5262                                     (Person::players[0]->animTarget == hanganim && normaldotproduct(
5263                                          Person::players[0]->facing, Person::players[i]->coords - Person::players[0]->coords) < 0)) {
5264                                 /* //TODO: changed j to 0 on a whim, make sure this is correct
5265                                 (Person::players[j]->animTarget==hanganim&&normaldotproduct(
5266                                     Person::players[j]->facing,Person::players[i]->coords-Person::players[j]->coords)<0)
5267                                 */
5268                                 Person::players[i]->aitype = attacktypecutoff;
5269                                 Person::players[i]->lastseentime = 1;
5270                             }
5271             }
5272             //player escaped
5273             if (Person::players[i]->lastseentime < 0) {
5274                 //Person::players[i]->aitype=passivetype;
5275                 numescaped++;
5276                 Person::players[i]->aitype = pathfindtype;
5277                 Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5278                 Person::players[i]->finalpathfindpoint = -1;
5279                 Person::players[i]->targetpathfindpoint = -1;
5280                 Person::players[i]->lastpathfindpoint = -1;
5281                 Person::players[i]->lastpathfindpoint2 = -1;
5282                 Person::players[i]->lastpathfindpoint3 = -1;
5283                 Person::players[i]->lastpathfindpoint4 = -1;
5284             }
5285         }
5286
5287         if (Person::players[i]->aitype != gethelptype)
5288             Person::players[i]->runninghowlong = 0;
5289
5290         //get help from buddies
5291         if (Person::players[i]->aitype == gethelptype) {
5292             Person::players[i]->runninghowlong += multiplier;
5293             Person::players[i]->aiupdatedelay -= multiplier;
5294
5295             if (Person::players[i]->aiupdatedelay < 0 || Person::players[i]->ally == 0) {
5296                 Person::players[i]->aiupdatedelay = .2;
5297
5298                 //find closest ally
5299                 //TODO: factor out closest search somehow
5300                 if (!Person::players[i]->ally) {
5301                     int closest = -1;
5302                     float closestdist = -1;
5303                     for (unsigned k = 0; k < Person::players.size(); k++) {
5304                         if (k != i && k != 0 && !Person::players[k]->dead &&
5305                                 Person::players[k]->howactive < typedead1 &&
5306                                 !Person::players[k]->skeleton.free &&
5307                                 Person::players[k]->aitype == passivetype) {
5308                             float distance = distsq(&Person::players[i]->coords, &Person::players[k]->coords);
5309                             if (closestdist == -1 || distance < closestdist) {
5310                                 closestdist = distance;
5311                                 closest = k;
5312                             }
5313                             closest = k;
5314                         }
5315                     }
5316                     if (closest != -1)
5317                         Person::players[i]->ally = closest;
5318                     else
5319                         Person::players[i]->ally = 0;
5320                     Person::players[i]->lastseen = Person::players[0]->coords;
5321                     Person::players[i]->lastseentime = 12;
5322                 }
5323
5324
5325                 Person::players[i]->lastchecktime = 12;
5326
5327                 XYZ facing = Person::players[i]->coords;
5328                 XYZ flatfacing = Person::players[Person::players[i]->ally]->coords;
5329                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
5330                 flatfacing.y += Person::players[Person::players[i]->ally]->jointPos(head).y * Person::players[Person::players[i]->ally]->scale;
5331                 if (-1 != checkcollide(facing, flatfacing))
5332                     Person::players[i]->lastseentime -= .1;
5333
5334                 //no available ally, run back to player
5335                 if (Person::players[i]->ally <= 0 ||
5336                         Person::players[Person::players[i]->ally]->skeleton.free ||
5337                         Person::players[Person::players[i]->ally]->aitype != passivetype ||
5338                         Person::players[i]->lastseentime <= 0) {
5339                     Person::players[i]->aitype = searchtype;
5340                     Person::players[i]->lastseentime = 12;
5341                 }
5342
5343                 //seek out ally
5344                 if (Person::players[i]->ally > 0) {
5345                     Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[Person::players[i]->ally]->coords);
5346                     Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5347                     Person::players[i]->aiupdatedelay = .05;
5348                     Person::players[i]->forwardkeydown = 1;
5349
5350                     if (distsqflat(&Person::players[i]->coords, &Person::players[Person::players[i]->ally]->coords) < 3) {
5351                         Person::players[i]->aitype = searchtype;
5352                         Person::players[i]->lastseentime = 12;
5353                         Person::players[Person::players[i]->ally]->aitype = searchtype;
5354                         if (Person::players[Person::players[i]->ally]->lastseentime < Person::players[i]->lastseentime) {
5355                             Person::players[Person::players[i]->ally]->lastseen = Person::players[i]->lastseen;
5356                             Person::players[Person::players[i]->ally]->lastseentime = Person::players[i]->lastseentime;
5357                             Person::players[Person::players[i]->ally]->lastchecktime = Person::players[i]->lastchecktime;
5358                         }
5359                     }
5360
5361                     if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5362                         if (!Person::players[i]->avoidsomething)
5363                             Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5364                         else {
5365                             XYZ leftpos, rightpos;
5366                             float leftdist, rightdist;
5367                             leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5368                             rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5369                             leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5370                             rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5371                             if (leftdist < rightdist)
5372                                 Person::players[i]->targetyaw += 90;
5373                             else
5374                                 Person::players[i]->targetyaw -= 90;
5375                         }
5376                     }
5377                 }
5378
5379                 Person::players[i]->leftkeydown = 0;
5380                 Person::players[i]->backkeydown = 0;
5381                 Person::players[i]->rightkeydown = 0;
5382                 Person::players[i]->crouchkeydown = 0;
5383                 Person::players[i]->attackkeydown = 0;
5384             }
5385             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5386                 Person::players[i]->jumpkeydown = 0;
5387             if (Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5)
5388                 Person::players[i]->jumpkeydown = 1;
5389         }
5390
5391         //retreiving a weapon on the ground
5392         if (Person::players[i]->aitype == getweapontype) {
5393             Person::players[i]->aiupdatedelay -= multiplier;
5394             Person::players[i]->lastchecktime -= multiplier;
5395
5396             if (Person::players[i]->aiupdatedelay < 0) {
5397                 Person::players[i]->aiupdatedelay = .2;
5398
5399                 //ALLY IS WEPON
5400                 if (Person::players[i]->ally < 0) {
5401                     int closest = -1;
5402                     float closestdist = -1;
5403                     for (unsigned k = 0; k < weapons.size(); k++)
5404                         if (weapons[k].owner == -1) {
5405                             float distance = distsq(&Person::players[i]->coords, &weapons[k].position);
5406                             if (closestdist == -1 || distance < closestdist) {
5407                                 closestdist = distance;
5408                                 closest = k;
5409                             }
5410                             closest = k;
5411                         }
5412                     if (closest != -1)
5413                         Person::players[i]->ally = closest;
5414                     else
5415                         Person::players[i]->ally = -1;
5416                 }
5417
5418                 Person::players[i]->lastseentime = 12;
5419
5420                 if (!Person::players[0]->dead && ((tutoriallevel != 1 || cananger) && hostile))
5421                     if (Person::players[i]->ally < 0 || Person::players[i]->weaponactive != -1 || Person::players[i]->lastchecktime <= 0) {
5422                         Person::players[i]->aitype = attacktypecutoff;
5423                         Person::players[i]->lastseentime = 1;
5424                     }
5425                 if (!Person::players[0]->dead)
5426                     if (Person::players[i]->ally >= 0) {
5427                         if (weapons[Person::players[i]->ally].owner != -1 ||
5428                                 distsq(&Person::players[i]->coords, &weapons[Person::players[i]->ally].position) > 16) {
5429                             Person::players[i]->aitype = attacktypecutoff;
5430                             Person::players[i]->lastseentime = 1;
5431                         }
5432                         //TODO: factor these out as moveToward()
5433                         Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[Person::players[i]->ally].position);
5434                         Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5435                         Person::players[i]->aiupdatedelay = .05;
5436                         Person::players[i]->forwardkeydown = 1;
5437
5438
5439                         if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8) {
5440                             if (!Person::players[i]->avoidsomething)
5441                                 Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5442                             else {
5443                                 XYZ leftpos, rightpos;
5444                                 float leftdist, rightdist;
5445                                 leftpos = Person::players[i]->coords + DoRotation(Person::players[i]->facing, 0, 90, 0);
5446                                 rightpos = Person::players[i]->coords - DoRotation(Person::players[i]->facing, 0, 90, 0);
5447                                 leftdist = distsq(&leftpos, &Person::players[i]->avoidwhere);
5448                                 rightdist = distsq(&rightpos, &Person::players[i]->avoidwhere);
5449                                 if (leftdist < rightdist)
5450                                     Person::players[i]->targetyaw += 90;
5451                                 else
5452                                     Person::players[i]->targetyaw -= 90;
5453                             }
5454                         }
5455                     }
5456
5457                 Person::players[i]->leftkeydown = 0;
5458                 Person::players[i]->backkeydown = 0;
5459                 Person::players[i]->rightkeydown = 0;
5460                 Person::players[i]->attackkeydown = 0;
5461                 Person::players[i]->throwkeydown = 1;
5462                 Person::players[i]->crouchkeydown = 0;
5463                 if (Person::players[i]->animTarget != crouchremoveknifeanim &&
5464                         Person::players[i]->animTarget != removeknifeanim)
5465                     Person::players[i]->throwtogglekeydown = 0;
5466                 Person::players[i]->drawkeydown = 0;
5467             }
5468             if (Person::players[i]->collided < 1 || Person::players[i]->animTarget != jumpupanim)
5469                 Person::players[i]->jumpkeydown = 0;
5470             if ((Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5))
5471                 Person::players[i]->jumpkeydown = 1;
5472         }
5473
5474         if (Person::players[i]->aitype == attacktypecutoff) {
5475             Person::players[i]->aiupdatedelay -= multiplier;
5476             //dodge or reverse rabbit kicks, knife throws, flips
5477             if (Person::players[i]->damage < Person::players[i]->damagetolerance * 2 / 3)
5478                 if ((Person::players[0]->animTarget == rabbitkickanim ||
5479                         Person::players[0]->animTarget == knifethrowanim ||
5480                         (Person::players[0]->isFlip() &&
5481                          normaldotproduct(Person::players[0]->facing, Person::players[0]->coords - Person::players[i]->coords) < 0)) &&
5482                         !Person::players[0]->skeleton.free &&
5483                         (Person::players[i]->aiupdatedelay < .1)) {
5484                     Person::players[i]->attackkeydown = 0;
5485                     if (Person::players[i]->isIdle())
5486                         Person::players[i]->crouchkeydown = 1;
5487                     if (Person::players[0]->animTarget != rabbitkickanim && Person::players[0]->weaponactive != -1) {
5488                         if (weapons[Person::players[0]->weaponids[0]].getType() == knife) {
5489                             if (Person::players[i]->isIdle() || Person::players[i]->isCrouch() || Person::players[i]->isRun() || Person::players[i]->isFlip()) {
5490                                 if (abs(Random() % 2 == 0))
5491                                     Person::players[i]->setAnimation(backhandspringanim);
5492                                 else
5493                                     Person::players[i]->setAnimation(rollanim);
5494                                 Person::players[i]->targetyaw += 90 * (abs(Random() % 2) * 2 - 1);
5495                                 Person::players[i]->wentforweapon = 0;
5496                             }
5497                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim)
5498                                 Person::players[i]->setAnimation(flipanim);
5499                         }
5500                     }
5501                     Person::players[i]->forwardkeydown = 0;
5502                     Person::players[i]->aiupdatedelay = .02;
5503                 }
5504             //get confused by flips
5505             if (Person::players[0]->isFlip() &&
5506                     !Person::players[0]->skeleton.free &&
5507                     Person::players[0]->animTarget != walljumprightkickanim &&
5508                     Person::players[0]->animTarget != walljumpleftkickanim) {
5509                 if (distsq(&Person::players[0]->coords, &Person::players[i]->coords) < 25)
5510                     if ((1 - Person::players[i]->damage / Person::players[i]->damagetolerance) > .5)
5511                         Person::players[i]->stunned = 1;
5512             }
5513             //go for weapon on the ground
5514             if (Person::players[i]->wentforweapon < 3)
5515                 for (unsigned k = 0; k < weapons.size(); k++)
5516                     if (Person::players[i]->creature != wolftype)
5517                         if (Person::players[i]->num_weapons == 0 &&
5518                                 weapons[k].owner == -1 &&
5519                                 weapons[i].velocity.x == 0 &&
5520                                 weapons[i].velocity.z == 0 &&
5521                                 weapons[i].velocity.y == 0) {
5522                             if (distsq(&Person::players[i]->coords, &weapons[k].position) < 16) {
5523                                 Person::players[i]->wentforweapon++;
5524                                 Person::players[i]->lastchecktime = 6;
5525                                 Person::players[i]->aitype = getweapontype;
5526                                 Person::players[i]->ally = -1;
5527                             }
5528                         }
5529             //dodge/reverse walljump kicks
5530             if (Person::players[i]->damage < Person::players[i]->damagetolerance / 2)
5531                 if (animation[Person::players[i]->animTarget].height != highheight)
5532                     if (Person::players[i]->damage < Person::players[i]->damagetolerance * .5 &&
5533                             ((Person::players[0]->animTarget == walljumprightkickanim ||
5534                               Person::players[0]->animTarget == walljumpleftkickanim) &&
5535                              ((Person::players[i]->aiupdatedelay < .15 &&
5536                                difficulty == 2) ||
5537                               (Person::players[i]->aiupdatedelay < .08 &&
5538                                difficulty != 2)))) {
5539                         Person::players[i]->crouchkeydown = 1;
5540                     }
5541             //walked off a ledge (?)
5542             if (Person::players[i]->isRun() && !Person::players[i]->onground)
5543                 if (Person::players[i]->coords.y > terrain.getHeight(Person::players[i]->coords.x, Person::players[i]->coords.z) + 10) {
5544                     XYZ test2 = Person::players[i]->coords + Person::players[i]->facing;
5545                     test2.y += 5;
5546                     XYZ test = Person::players[i]->coords + Person::players[i]->facing;
5547                     test.y -= 10;
5548                     j = checkcollide(test2, test, Person::players[i]->laststanding);
5549                     if (j == -1)
5550                         j = checkcollide(test2, test);
5551                     if (j == -1) {
5552                         Person::players[i]->velocity = 0;
5553                         Person::players[i]->setAnimation(Person::players[i]->getStop());
5554                         Person::players[i]->targetyaw += 180;
5555                         Person::players[i]->stunned = .5;
5556                         Person::players[i]->aitype = pathfindtype;
5557                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5558                         Person::players[i]->finalpathfindpoint = -1;
5559                         Person::players[i]->targetpathfindpoint = -1;
5560                         Person::players[i]->lastpathfindpoint = -1;
5561                         Person::players[i]->lastpathfindpoint2 = -1;
5562                         Person::players[i]->lastpathfindpoint3 = -1;
5563                         Person::players[i]->lastpathfindpoint4 = -1;
5564                     } else
5565                         Person::players[i]->laststanding = j;
5566                 }
5567             //lose sight of player in the air (?)
5568             if (Person::players[0]->coords.y > Person::players[i]->coords.y + 5 &&
5569                     animation[Person::players[0]->animTarget].height != highheight &&
5570                     !Person::players[0]->onterrain) {
5571                 Person::players[i]->aitype = pathfindtype;
5572                 Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5573                 Person::players[i]->finalpathfindpoint = -1;
5574                 Person::players[i]->targetpathfindpoint = -1;
5575                 Person::players[i]->lastpathfindpoint = -1;
5576                 Person::players[i]->lastpathfindpoint2 = -1;
5577                 Person::players[i]->lastpathfindpoint3 = -1;
5578                 Person::players[i]->lastpathfindpoint4 = -1;
5579             }
5580             //it's time to think (?)
5581             if (Person::players[i]->aiupdatedelay < 0 &&
5582                     !animation[Person::players[i]->animTarget].attack &&
5583                     Person::players[i]->animTarget != staggerbackhighanim &&
5584                     Person::players[i]->animTarget != staggerbackhardanim &&
5585                     Person::players[i]->animTarget != backhandspringanim &&
5586                     Person::players[i]->animTarget != dodgebackanim) {
5587                 //draw weapon
5588                 if (Person::players[i]->weaponactive == -1 && Person::players[i]->num_weapons > 0)
5589                     Person::players[i]->drawkeydown = Random() % 2;
5590                 else
5591                     Person::players[i]->drawkeydown = 0;
5592                 Person::players[i]->rabbitkickenabled = Random() % 2;
5593                 //chase player
5594                 XYZ rotatetarget = Person::players[0]->coords + Person::players[0]->velocity;
5595                 XYZ targetpoint = Person::players[0]->coords;
5596                 if (distsq(&Person::players[0]->coords, &Person::players[i]->coords) <
5597                         distsq(&rotatetarget, &Person::players[i]->coords))
5598                     targetpoint += Person::players[0]->velocity *
5599                                    findDistance(&Person::players[0]->coords, &Person::players[i]->coords) / findLength(&Person::players[i]->velocity);
5600                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, targetpoint);
5601                 Person::players[i]->lookyaw = Person::players[i]->targetyaw;
5602                 Person::players[i]->aiupdatedelay = .2 + fabs((float)(Random() % 100) / 1000);
5603
5604                 if (distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 5 && (Person::players[0]->weaponactive == -1 || Person::players[i]->weaponactive != -1))
5605                     Person::players[i]->forwardkeydown = 1;
5606                 else if ((distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 16 ||
5607                           distsq(&Person::players[i]->coords, &Person::players[0]->coords) < 9) &&
5608                          Person::players[0]->weaponactive != -1)
5609                     Person::players[i]->forwardkeydown = 1;
5610                 else if (Random() % 6 == 0 || (Person::players[i]->creature == wolftype && Random() % 3 == 0))
5611                     Person::players[i]->forwardkeydown = 1;
5612                 else
5613                     Person::players[i]->forwardkeydown = 0;
5614                 //chill out around the corpse
5615                 if (Person::players[0]->dead) {
5616                     Person::players[i]->forwardkeydown = 0;
5617                     if (Random() % 10 == 0)
5618                         Person::players[i]->forwardkeydown = 1;
5619                     if (Random() % 100 == 0) {
5620                         Person::players[i]->aitype = pathfindtype;
5621                         Person::players[i]->finalfinaltarget = Person::players[i]->waypoints[Person::players[i]->waypoint];
5622                         Person::players[i]->finalpathfindpoint = -1;
5623                         Person::players[i]->targetpathfindpoint = -1;
5624                         Person::players[i]->lastpathfindpoint = -1;
5625                         Person::players[i]->lastpathfindpoint2 = -1;
5626                         Person::players[i]->lastpathfindpoint3 = -1;
5627                         Person::players[i]->lastpathfindpoint4 = -1;
5628                     }
5629                 }
5630                 Person::players[i]->leftkeydown = 0;
5631                 Person::players[i]->backkeydown = 0;
5632                 Person::players[i]->rightkeydown = 0;
5633                 Person::players[i]->crouchkeydown = 0;
5634                 Person::players[i]->throwkeydown = 0;
5635
5636                 if (Person::players[i]->avoidcollided > .8 && !Person::players[i]->jumpkeydown && Person::players[i]->collided < .8)
5637                     Person::players[i]->targetyaw += 90 * (Person::players[i]->whichdirection * 2 - 1);
5638                 //attack!!!
5639                 if (Random() % 2 == 0 || Person::players[i]->weaponactive != -1 || Person::players[i]->creature == wolftype)
5640                     Person::players[i]->attackkeydown = 1;
5641                 else
5642                     Person::players[i]->attackkeydown = 0;
5643                 if (Person::players[i]->isRun() && Random() % 6 && distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 7)
5644                     Person::players[i]->attackkeydown = 0;
5645
5646                 //TODO: wat
5647                 if (Person::players[i]->aitype != playercontrolled &&
5648                         (Person::players[i]->isIdle() ||
5649                          Person::players[i]->isCrouch() ||
5650                          Person::players[i]->isRun())) {
5651                     int target = -2;
5652                     for (unsigned j = 0; j < Person::players.size(); j++)
5653                         if (j != i && !Person::players[j]->skeleton.free &&
5654                                 Person::players[j]->hasvictim &&
5655                                 (tutoriallevel == 1 && reversaltrain ||
5656                                  Random() % 2 == 0 && difficulty == 2 ||
5657                                  Random() % 4 == 0 && difficulty == 1 ||
5658                                  Random() % 8 == 0 && difficulty == 0 ||
5659                                  Person::players[j]->lastattack2 == Person::players[j]->animTarget &&
5660                                  Person::players[j]->lastattack3 == Person::players[j]->animTarget &&
5661                                  (Random() % 2 == 0 || difficulty == 2) ||
5662                                  (Person::players[i]->isIdle() || Person::players[i]->isRun()) &&
5663                                  Person::players[j]->weaponactive != -1 ||
5664                                  Person::players[j]->animTarget == swordslashanim &&
5665                                  Person::players[i]->weaponactive != -1 ||
5666                                  Person::players[j]->animTarget == staffhitanim ||
5667                                  Person::players[j]->animTarget == staffspinhitanim))
5668                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 4 &&
5669                                     Person::players[j]->victim == Person::players[i] &&
5670                                     (Person::players[j]->animTarget == sweepanim ||
5671                                      Person::players[j]->animTarget == spinkickanim ||
5672                                      Person::players[j]->animTarget == staffhitanim ||
5673                                      Person::players[j]->animTarget == staffspinhitanim ||
5674                                      Person::players[j]->animTarget == winduppunchanim ||
5675                                      Person::players[j]->animTarget == upunchanim ||
5676                                      Person::players[j]->animTarget == wolfslapanim ||
5677                                      Person::players[j]->animTarget == knifeslashstartanim ||
5678                                      Person::players[j]->animTarget == swordslashanim &&
5679                                      (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2 ||
5680                                       Person::players[i]->weaponactive != -1))) {
5681                                 if (target >= 0)
5682                                     target = -1;
5683                                 else
5684                                     target = j;
5685                             }
5686                     if (target >= 0)
5687                         Person::players[target]->Reverse();
5688                 }
5689
5690                 if (Person::players[i]->collided < 1)
5691                     Person::players[i]->jumpkeydown = 0;
5692                 if (Person::players[i]->collided > .8 && Person::players[i]->jumppower >= 5 ||
5693                         distsq(&Person::players[i]->coords, &Person::players[0]->coords) > 400 &&
5694                         Person::players[i]->onterrain &&
5695                         Person::players[i]->creature == rabbittype)
5696                     Person::players[i]->jumpkeydown = 1;
5697                 //TODO: why are we controlling the human?
5698                 if (normaldotproduct(Person::players[i]->facing, Person::players[0]->coords - Person::players[i]->coords) > 0)
5699                     Person::players[0]->jumpkeydown = 0;
5700                 if (Person::players[0]->animTarget == jumpdownanim &&
5701                         distsq(&Person::players[0]->coords, &Person::players[i]->coords) < 40)
5702                     Person::players[i]->crouchkeydown = 1;
5703                 if (Person::players[i]->jumpkeydown)
5704                     Person::players[i]->attackkeydown = 0;
5705
5706                 if (tutoriallevel == 1)
5707                     if (!canattack)
5708                         Person::players[i]->attackkeydown = 0;
5709
5710
5711                 XYZ facing = Person::players[i]->coords;
5712                 XYZ flatfacing = Person::players[0]->coords;
5713                 facing.y += Person::players[i]->jointPos(head).y * Person::players[i]->scale;
5714                 flatfacing.y += Person::players[0]->jointPos(head).y * Person::players[0]->scale;
5715                 if (Person::players[i]->occluded >= 2)
5716                     if (-1 != checkcollide(facing, flatfacing)) {
5717                         if (!Person::players[i]->pause)
5718                             Person::players[i]->lastseentime -= .2;
5719                         if (Person::players[i]->lastseentime <= 0 &&
5720                                 (Person::players[i]->creature != wolftype ||
5721                                  Person::players[i]->weaponstuck == -1)) {
5722                             Person::players[i]->aitype = searchtype;
5723                             Person::players[i]->lastchecktime = 12;
5724                             Person::players[i]->lastseen = Person::players[0]->coords;
5725                             Person::players[i]->lastseentime = 12;
5726                         }
5727                     } else
5728                         Person::players[i]->lastseentime = 1;
5729             }
5730         }
5731         if (animation[Person::players[0]->animTarget].height == highheight &&
5732                 (Person::players[i]->aitype == attacktypecutoff ||
5733                  Person::players[i]->aitype == searchtype))
5734             if (Person::players[0]->coords.y > terrain.getHeight(Person::players[0]->coords.x, Person::players[0]->coords.z) + 10) {
5735                 XYZ test = Person::players[0]->coords;
5736                 test.y -= 40;
5737                 if (-1 == checkcollide(Person::players[0]->coords, test))
5738                     Person::players[i]->stunned = 1;
5739             }
5740         //stunned
5741         if (Person::players[i]->aitype == passivetype && !(Person::players[i]->numwaypoints > 1) ||
5742                 Person::players[i]->stunned > 0 ||
5743                 Person::players[i]->pause && Person::players[i]->damage > Person::players[i]->superpermanentdamage) {
5744             if (Person::players[i]->pause)
5745                 Person::players[i]->lastseentime = 1;
5746             Person::players[i]->targetyaw = Person::players[i]->yaw;
5747             Person::players[i]->forwardkeydown = 0;
5748             Person::players[i]->leftkeydown = 0;
5749             Person::players[i]->backkeydown = 0;
5750             Person::players[i]->rightkeydown = 0;
5751             Person::players[i]->jumpkeydown = 0;
5752             Person::players[i]->attackkeydown = 0;
5753             Person::players[i]->crouchkeydown = 0;
5754             Person::players[i]->throwkeydown = 0;
5755         }
5756
5757
5758         XYZ facing;
5759         facing = 0;
5760         facing.z = -1;
5761
5762         XYZ flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
5763         facing = flatfacing;
5764
5765         if (Person::players[i]->aitype == attacktypecutoff) {
5766             Person::players[i]->targetheadyaw = 180 - roughDirectionTo(Person::players[i]->coords, Person::players[0]->coords);
5767             Person::players[i]->targetheadpitch = pitchTo(Person::players[i]->coords, Person::players[0]->coords);
5768         } else if (Person::players[i]->howactive >= typesleeping) {
5769             Person::players[i]->targetheadyaw = Person::players[i]->targetyaw;
5770             Person::players[i]->targetheadpitch = 0;
5771         } else {
5772             if (Person::players[i]->interestdelay <= 0) {
5773                 Person::players[i]->interestdelay = .7 + (float)(abs(Random() % 100)) / 100;
5774                 Person::players[i]->headtarget = Person::players[i]->coords;
5775                 Person::players[i]->headtarget.x += (float)(abs(Random() % 200) - 100) / 100;
5776                 Person::players[i]->headtarget.z += (float)(abs(Random() % 200) - 100) / 100;
5777                 Person::players[i]->headtarget.y += (float)(abs(Random() % 200) - 100) / 300;
5778                 Person::players[i]->headtarget += Person::players[i]->facing * 1.5;
5779             }
5780             Person::players[i]->targetheadyaw = 180 - roughDirectionTo(Person::players[i]->coords, Person::players[i]->headtarget);
5781             Person::players[i]->targetheadpitch = pitchTo(Person::players[i]->coords, Person::players[i]->headtarget);
5782         }
5783     }
5784 }
5785
5786
5787
5788 void updateSettingsMenu()
5789 {
5790     char sbuf[256];
5791     if ((float)newscreenwidth > (float)newscreenheight * 1.61 || (float)newscreenwidth < (float)newscreenheight * 1.59)
5792         sprintf (sbuf, "Resolution: %d*%d", (int)newscreenwidth, (int)newscreenheight);
5793     else
5794         sprintf (sbuf, "Resolution: %d*%d (widescreen)", (int)newscreenwidth, (int)newscreenheight);
5795     Menu::setText(0, sbuf);
5796     Menu::setText(14, fullscreen ? "Fullscreen: On" : "Fullscreen: Off");
5797     if (newdetail == 0) Menu::setText(1, "Detail: Low");
5798     if (newdetail == 1) Menu::setText(1, "Detail: Medium");
5799     if (newdetail == 2) Menu::setText(1, "Detail: High");
5800     if (bloodtoggle == 0) Menu::setText(2, "Blood: Off");
5801     if (bloodtoggle == 1) Menu::setText(2, "Blood: On, low detail");
5802     if (bloodtoggle == 2) Menu::setText(2, "Blood: On, high detail (slower)");
5803     if (difficulty == 0) Menu::setText(3, "Difficulty: Easier");
5804     if (difficulty == 1) Menu::setText(3, "Difficulty: Difficult");
5805     if (difficulty == 2) Menu::setText(3, "Difficulty: Insane");
5806     Menu::setText(4, ismotionblur ? "Blur Effects: Enabled (less compatible)" : "Blur Effects: Disabled (more compatible)");
5807     Menu::setText(5, decals ? "Decals: Enabled (slower)" : "Decals: Disabled");
5808     Menu::setText(6, musictoggle ? "Music: Enabled" : "Music: Disabled");
5809     Menu::setText(9, invertmouse ? "Invert mouse: Yes" : "Invert mouse: No");
5810     sprintf (sbuf, "Mouse Speed: %d", (int)(usermousesensitivity * 5));
5811     Menu::setText(10, sbuf);
5812     sprintf (sbuf, "Volume: %d%%", (int)(volume * 100));
5813     Menu::setText(11, sbuf);
5814     Menu::setText(13, showdamagebar ? "Damage Bar: On" : "Damage Bar: Off");
5815     if (newdetail == detail && newscreenheight == (int)screenheight && newscreenwidth == (int)screenwidth)
5816         sprintf (sbuf, "Back");
5817     else
5818         sprintf (sbuf, "Back (some changes take effect next time Lugaru is opened)");
5819     Menu::setText(8, sbuf);
5820 }
5821
5822 void updateStereoConfigMenu()
5823 {
5824     char sbuf[256];
5825     sprintf(sbuf, "Stereo mode: %s", StereoModeName(newstereomode));
5826     Menu::setText(0, sbuf);
5827     sprintf(sbuf, "Stereo separation: %.3f", stereoseparation);
5828     Menu::setText(1, sbuf);
5829     sprintf(sbuf, "Reverse stereo: %s", stereoreverse ? "Yes" : "No");
5830     Menu::setText(2, sbuf);
5831 }
5832
5833 void updateControlsMenu()
5834 {
5835     Menu::setText(0, (string)"Forwards: " + (keyselect == 0 ? "_" : Input::keyToChar(forwardkey)));
5836     Menu::setText(1, (string)"Back: "    + (keyselect == 1 ? "_" : Input::keyToChar(backkey)));
5837     Menu::setText(2, (string)"Left: "    + (keyselect == 2 ? "_" : Input::keyToChar(leftkey)));
5838     Menu::setText(3, (string)"Right: "   + (keyselect == 3 ? "_" : Input::keyToChar(rightkey)));
5839     Menu::setText(4, (string)"Crouch: "  + (keyselect == 4 ? "_" : Input::keyToChar(crouchkey)));
5840     Menu::setText(5, (string)"Jump: "    + (keyselect == 5 ? "_" : Input::keyToChar(jumpkey)));
5841     Menu::setText(6, (string)"Draw: "    + (keyselect == 6 ? "_" : Input::keyToChar(drawkey)));
5842     Menu::setText(7, (string)"Throw: "   + (keyselect == 7 ? "_" : Input::keyToChar(throwkey)));
5843     Menu::setText(8, (string)"Attack: "  + (keyselect == 8 ? "_" : Input::keyToChar(attackkey)));
5844     if (debugmode)
5845         Menu::setText(9, (string)"Console: " + (keyselect == 9 ? "_" : Input::keyToChar(consolekey)));
5846 }
5847
5848 /*
5849 Values of mainmenu :
5850 1 Main menu
5851 2 Menu pause (resume/end game)
5852 3 Option menu
5853 4 Controls configuration menu
5854 5 Main game menu (choose level or challenge)
5855 6 Deleting user menu
5856 7 User managment menu (select/add)
5857 8 Choose difficulty menu
5858 9 Challenge level selection menu
5859 10 End of the campaign congratulation (is that really a menu?)
5860 11 Same that 9 ??? => unused
5861 18 stereo configuration
5862 */
5863
5864 void Game::LoadMenu()
5865 {
5866     Menu::clearMenu();
5867     switch (mainmenu) {
5868     case 1:
5869     case 2:
5870         Menu::addImage(0, Mainmenuitems[0], 150, 480 - 128, 256, 128);
5871         Menu::addButtonImage(1, Mainmenuitems[mainmenu == 1 ? 1 : 5], 18, 480 - 152 - 32, 128, 32);
5872         Menu::addButtonImage(2, Mainmenuitems[2], 18, 480 - 228 - 32, 112, 32);
5873         Menu::addButtonImage(3, Mainmenuitems[mainmenu == 1 ? 3 : 6], 18, 480 - 306 - 32, mainmenu == 1 ? 68 : 132, 32);
5874         break;
5875     case 3:
5876         Menu::addButton( 0, "", 10 + 20, 440);
5877         Menu::addButton(14, "", 10 + 400, 440);
5878         Menu::addButton( 1, "", 10 + 60, 405);
5879         Menu::addButton( 2, "", 10 + 70, 370);
5880         Menu::addButton( 3, "", 10 + 20 - 1000, 335 - 1000);
5881         Menu::addButton( 4, "", 10   , 335);
5882         Menu::addButton( 5, "", 10 + 60, 300);
5883         Menu::addButton( 6, "", 10 + 70, 265);
5884         Menu::addButton( 9, "", 10   , 230);
5885         Menu::addButton(10, "", 20   , 195);
5886         Menu::addButton(11, "", 10 + 60, 160);
5887         Menu::addButton(13, "", 30   , 125);
5888         Menu::addButton( 7, "-Configure Controls-", 10 + 15, 90);
5889         Menu::addButton(12, "-Configure Stereo -", 10 + 15, 55);
5890         Menu::addButton(8, "Back", 10, 10);
5891         updateSettingsMenu();
5892         break;
5893     case 4:
5894         Menu::addButton(0, "", 10   , 400);
5895         Menu::addButton(1, "", 10 + 40, 360);
5896         Menu::addButton(2, "", 10 + 40, 320);
5897         Menu::addButton(3, "", 10 + 30, 280);
5898         Menu::addButton(4, "", 10 + 20, 240);
5899         Menu::addButton(5, "", 10 + 40, 200);
5900         Menu::addButton(6, "", 10 + 40, 160);
5901         Menu::addButton(7, "", 10 + 30, 120);
5902         Menu::addButton(8, "", 10 + 20, 80);
5903         if (debugmode)
5904             Menu::addButton(9, "", 10 + 10, 40);
5905         Menu::addButton(debugmode ? 10 : 9, "Back", 10, 10);
5906         updateControlsMenu();
5907         break;
5908     case 5: {
5909         LoadCampaign();
5910         Menu::addLabel(-1, accountactive->getName(), 5, 400);
5911         Menu::addButton(1, "Tutorial", 5, 300);
5912         Menu::addButton(2, "Challenge", 5, 240);
5913         Menu::addButton(3, "Delete User", 400, 10);
5914         Menu::addButton(4, "Main Menu", 5, 10);
5915         Menu::addButton(5, "Change User", 5, 180);
5916         Menu::addButton(6, "Campaign : " + accountactive->getCurrentCampaign(), 200, 420);
5917
5918         //show campaign map
5919         //with (2,-5) offset from old code
5920         Menu::addImage(-1, Mainmenuitems[7], 150 + 2, 60 - 5, 400, 400);
5921         //show levels
5922         int numlevels = accountactive->getCampaignChoicesMade();
5923         numlevels += numlevels > 0 ? campaignlevels[numlevels - 1].nextlevel.size() : 1;
5924         for (int i = 0; i < numlevels; i++) {
5925             XYZ midpoint = campaignlevels[i].getCenter();
5926             float itemsize = campaignlevels[i].getWidth();
5927             const bool active = i >= accountactive->getCampaignChoicesMade();
5928             if (!active)
5929                 itemsize /= 2;
5930
5931             if (i >= 1) {
5932                 XYZ start = campaignlevels[i - 1].getCenter();
5933                 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);
5934             }
5935             Menu::addMapMarker(NB_CAMPAIGN_MENU_ITEM + i, Mapcircletexture,
5936                                midpoint.x - itemsize / 2, midpoint.y - itemsize / 2, itemsize, itemsize, active ? 1 : 0.5, 0, 0);
5937
5938             if (active) {
5939                 Menu::addMapLabel(-2, campaignlevels[i].description,
5940                                   campaignlevels[i].getStartX() + 10,
5941                                   campaignlevels[i].getStartY() - 4);
5942             }
5943         }
5944     }
5945     break;
5946     case 6:
5947         Menu::addLabel(-1, "Are you sure you want to delete this user?", 10, 400);
5948         Menu::addButton(1, "Yes", 10, 360);
5949         Menu::addButton(2, "No", 10, 320);
5950         break;
5951     case 7:
5952         if (Account::getNbAccounts() < 8)
5953             Menu::addButton(0, "New User", 10, 400);
5954         else
5955             Menu::addLabel(0, "No More Users", 10, 400);
5956         Menu::addLabel(-2, "", 20, 400);
5957         Menu::addButton(Account::getNbAccounts() + 1, "Back", 10, 10);
5958         for (int i = 0; i < Account::getNbAccounts(); i++)
5959             Menu::addButton(i + 1, Account::get(i)->getName(), 10, 340 - 20 * (i + 1));
5960         break;
5961     case 8:
5962         Menu::addButton(0, "Easier", 10, 400);
5963         Menu::addButton(1, "Difficult", 10, 360);
5964         Menu::addButton(2, "Insane", 10, 320);
5965         break;
5966     case 9:
5967         for (int i = 0; i < numchallengelevels; i++) {
5968             char temp[255];
5969             string name = "";
5970             sprintf (temp, "Level %d", i + 1);
5971             for (int j = strlen(temp); j < 17; j++)
5972                 strcat(temp, " ");
5973             name += temp;
5974             sprintf (temp, "%d", (int)accountactive->getHighScore(i));
5975             for (int j = strlen(temp); j < (32 - 17); j++)
5976                 strcat(temp, " ");
5977             name += temp;
5978             sprintf (temp, "%d:", (int)(((int)accountactive->getFastTime(i) - (int)(accountactive->getFastTime(i)) % 60) / 60));
5979             if ((int)(accountactive->getFastTime(i)) % 60 < 10)
5980                 strcat(temp, "0");
5981             name += temp;
5982             sprintf (temp, "%d", (int)(accountactive->getFastTime(i)) % 60);
5983             name += temp;
5984
5985             Menu::addButton(i, name, 10, 400 - i * 25, i > accountactive->getProgress() ? 0.5 : 1, 0, 0);
5986         }
5987
5988         Menu::addButton(-1, "             High Score      Best Time", 10, 440);
5989         Menu::addButton(numchallengelevels, "Back", 10, 10);
5990         break;
5991     case 10: {
5992         Menu::addLabel(0, "Congratulations!", 220, 330);
5993         Menu::addLabel(1, "You have avenged your family and", 140, 300);
5994         Menu::addLabel(2, "restored peace to the island of Lugaru.", 110, 270);
5995         Menu::addButton(3, "Back", 10, 10);
5996         char sbuf[256];
5997         sprintf(sbuf, "Your score:         %d", (int)accountactive->getCampaignScore());
5998         Menu::addLabel(4, sbuf, 190, 200);
5999         sprintf(sbuf, "Highest score:      %d", (int)accountactive->getCampaignHighScore());
6000         Menu::addLabel(5, sbuf, 190, 180);
6001     }
6002     break;
6003     case 18:
6004         Menu::addButton(0, "", 70, 400);
6005         Menu::addButton(1, "", 10, 360);
6006         Menu::addButton(2, "", 40, 320);
6007         Menu::addButton(3, "Back", 10, 10);
6008         updateStereoConfigMenu();
6009         break;
6010     }
6011 }
6012
6013 extern set<pair<int,int>> resolutions;
6014
6015 void MenuTick()
6016 {
6017     //menu buttons
6018     selected = Menu::getSelected(mousecoordh * 640 / screenwidth, 480 - mousecoordv * 480 / screenheight);
6019
6020     // some specific case where we do something even if the left mouse button is not pressed.
6021     if ((mainmenu == 5) && (endgame == 2)) {
6022         accountactive->endGame();
6023         endgame = 0;
6024     }
6025     if (mainmenu == 10)
6026         endgame = 2;
6027     if (mainmenu == 18 && Input::isKeyPressed(MOUSEBUTTON2) && selected == 1) {
6028         stereoseparation -= 0.001;
6029         updateStereoConfigMenu();
6030     }
6031
6032     static int oldmainmenu = mainmenu;
6033
6034     if (Input::MouseClicked() && (selected >= 0)) { // handling of the left mouse clic in menus
6035         set<pair<int,int>>::iterator newscreenresolution;
6036         switch (mainmenu) {
6037         case 1:
6038         case 2:
6039             switch (selected) {
6040             case 1:
6041                 if (gameon) { //resume
6042                     mainmenu = 0;
6043                     pause_sound(stream_menutheme);
6044                     resume_stream(leveltheme);
6045                 } else { //new game
6046                     fireSound(firestartsound);
6047                     flash();
6048                     mainmenu = (accountactive ? 5 : 7);
6049                     selected = -1;
6050                 }
6051                 break;
6052             case 2: //options
6053                 fireSound();
6054                 flash();
6055                 mainmenu = 3;
6056                 if (newdetail > 2)
6057                     newdetail = detail;
6058                 if (newdetail < 0)
6059                     newdetail = detail;
6060                 if (newscreenwidth > 3000)
6061                     newscreenwidth = screenwidth;
6062                 if (newscreenwidth < 0)
6063                     newscreenwidth = screenwidth;
6064                 if (newscreenheight > 3000)
6065                     newscreenheight = screenheight;
6066                 if (newscreenheight < 0)
6067                     newscreenheight = screenheight;
6068                 break;
6069             case 3:
6070                 fireSound();
6071                 flash();
6072                 if (gameon) { //end game
6073                     gameon = 0;
6074                     mainmenu = 1;
6075                 } else { //quit
6076                     tryquit = 1;
6077                     pause_sound(stream_menutheme);
6078                 }
6079                 break;
6080             }
6081             break;
6082         case 3:
6083             fireSound();
6084             switch (selected) {
6085             case 0:
6086                 newscreenresolution = resolutions.find(make_pair(newscreenwidth, newscreenheight));
6087                 /* Next one (end() + 1 is also end() so the ++ is safe even if it was not found) */
6088                 newscreenresolution++;
6089                 if (newscreenresolution == resolutions.end()) {
6090                     /* It was the last one (or not found), go back to the beginning */
6091                     newscreenresolution = resolutions.begin();
6092                 }
6093                 newscreenwidth  = newscreenresolution->first;
6094                 newscreenheight = newscreenresolution->second;
6095                 break;
6096             case 1:
6097                 newdetail++;
6098                 if (newdetail > 2)
6099                     newdetail = 0;
6100                 break;
6101             case 2:
6102                 bloodtoggle++;
6103                 if (bloodtoggle > 2)
6104                     bloodtoggle = 0;
6105                 break;
6106             case 3:
6107                 difficulty++;
6108                 if (difficulty > 2)
6109                     difficulty = 0;
6110                 break;
6111             case 4:
6112                 ismotionblur = !ismotionblur;
6113                 break;
6114             case 5:
6115                 decals = !decals;
6116                 break;
6117             case 6:
6118                 musictoggle = !musictoggle;
6119                 if (musictoggle) {
6120                     emit_stream_np(stream_menutheme);
6121                 } else {
6122                     pause_sound(leveltheme);
6123                     pause_sound(stream_fighttheme);
6124                     pause_sound(stream_menutheme);
6125
6126                     for (int i = 0; i < 4; i++) {
6127                         oldmusicvolume[i] = 0;
6128                         musicvolume[i] = 0;
6129                     }
6130                 }
6131                 break;
6132             case 7: // controls
6133                 flash();
6134                 mainmenu = 4;
6135                 selected = -1;
6136                 keyselect = -1;
6137                 break;
6138             case 8:
6139                 flash();
6140                 SaveSettings();
6141                 mainmenu = gameon ? 2 : 1;
6142                 break;
6143             case 9:
6144                 invertmouse = !invertmouse;
6145                 break;
6146             case 10:
6147                 usermousesensitivity += .2;
6148                 if (usermousesensitivity > 2)
6149                     usermousesensitivity = .2;
6150                 break;
6151             case 11:
6152                 volume += .1f;
6153                 if (volume > 1.0001f)
6154                     volume = 0;
6155                 OPENAL_SetSFXMasterVolume((int)(volume * 255));
6156                 break;
6157             case 12:
6158                 flash();
6159                 newstereomode = stereomode;
6160                 mainmenu = 18;
6161                 keyselect = -1;
6162                 break;
6163             case 13:
6164                 showdamagebar = !showdamagebar;
6165                 break;
6166             case 14:
6167                 toggleFullscreen();
6168                 break;
6169             }
6170             updateSettingsMenu();
6171             break;
6172         case 4:
6173             if (!waiting) {
6174                 fireSound();
6175                 if (selected < (debugmode ? 10 : 9) && keyselect == -1)
6176                     keyselect = selected;
6177                 if (keyselect != -1)
6178                     setKeySelected();
6179                 if (selected == (debugmode ? 10 : 9)) {
6180                     flash();
6181                     mainmenu = 3;
6182                 }
6183             }
6184             updateControlsMenu();
6185             break;
6186         case 5:
6187             fireSound();
6188             flash();
6189             if ((selected - NB_CAMPAIGN_MENU_ITEM >= accountactive->getCampaignChoicesMade())) {
6190                 startbonustotal = 0;
6191
6192                 loading = 2;
6193                 loadtime = 0;
6194                 targetlevel = 7;
6195                 if (firstload)
6196                     TickOnceAfter();
6197                 else
6198                     LoadStuff();
6199                 whichchoice = selected - NB_CAMPAIGN_MENU_ITEM - accountactive->getCampaignChoicesMade();
6200                 actuallevel = (accountactive->getCampaignChoicesMade() > 0 ? campaignlevels[accountactive->getCampaignChoicesMade() - 1].nextlevel[whichchoice] : 0);
6201                 visibleloading = 1;
6202                 stillloading = 1;
6203                 Loadlevel(campaignlevels[actuallevel].mapname.c_str());
6204                 campaign = 1;
6205                 mainmenu = 0;
6206                 gameon = 1;
6207                 pause_sound(stream_menutheme);
6208             }
6209             switch (selected) {
6210             case 1:
6211                 startbonustotal = 0;
6212
6213                 loading = 2;
6214                 loadtime = 0;
6215                 targetlevel = -1;
6216                 if (firstload) {
6217                     TickOnceAfter();
6218                 } else
6219                     LoadStuff();
6220                 Loadlevel(-1);
6221
6222                 mainmenu = 0;
6223                 gameon = 1;
6224                 pause_sound(stream_menutheme);
6225                 break;
6226             case 2:
6227                 mainmenu = 9;
6228                 break;
6229             case 3:
6230                 mainmenu = 6;
6231                 break;
6232             case 4:
6233                 mainmenu = (gameon ? 2 : 1);
6234                 break;
6235             case 5:
6236                 mainmenu = 7;
6237                 break;
6238             case 6:
6239                 vector<string> campaigns = ListCampaigns();
6240                 vector<string>::iterator c;
6241                 if ((c = find(campaigns.begin(), campaigns.end(), accountactive->getCurrentCampaign())) == campaigns.end()) {
6242                     if (!campaigns.empty())
6243                         accountactive->setCurrentCampaign(campaigns.front());
6244                 } else {
6245                     c++;
6246                     if (c == campaigns.end())
6247                         c = campaigns.begin();
6248                     accountactive->setCurrentCampaign(*c);
6249                 }
6250                 LoadMenu();
6251                 break;
6252             }
6253             break;
6254         case 6:
6255             fireSound();
6256             if (selected == 1) {
6257                 flash();
6258                 accountactive = Account::destroy(accountactive);
6259                 mainmenu = 7;
6260             } else if (selected == 2) {
6261                 flash();
6262                 mainmenu = 5;
6263             }
6264             break;
6265         case 7:
6266             fireSound();
6267             if (selected == 0 && Account::getNbAccounts() < 8) {
6268                 entername = 1;
6269             } else if (selected < Account::getNbAccounts() + 1) {
6270                 flash();
6271                 mainmenu = 5;
6272                 accountactive = Account::get(selected - 1);
6273             } else if (selected == Account::getNbAccounts() + 1) {
6274                 flash();
6275                 if (accountactive)
6276                     mainmenu = 5;
6277                 else
6278                     mainmenu = 1;
6279                 displaytext[0].clear();
6280                 displayselected = 0;
6281                 entername = 0;
6282             }
6283             break;
6284         case 8:
6285             fireSound();
6286             flash();
6287             if (selected <= 2)
6288                 accountactive->setDifficulty(selected);
6289             mainmenu = 5;
6290             break;
6291         case 9:
6292             if (selected < numchallengelevels && selected <= accountactive->getProgress()) {
6293                 fireSound();
6294                 flash();
6295
6296                 startbonustotal = 0;
6297
6298                 loading = 2;
6299                 loadtime = 0;
6300                 targetlevel = selected;
6301                 if (firstload)
6302                     TickOnceAfter();
6303                 else
6304                     LoadStuff();
6305                 Loadlevel(selected);
6306                 campaign = 0;
6307
6308                 mainmenu = 0;
6309                 gameon = 1;
6310                 pause_sound(stream_menutheme);
6311             }
6312             if (selected == numchallengelevels) {
6313                 fireSound();
6314                 flash();
6315                 mainmenu = 5;
6316             }
6317             break;
6318         case 10:
6319             if (selected == 3) {
6320                 fireSound();
6321                 flash();
6322                 mainmenu = 5;
6323             }
6324             break;
6325         case 18:
6326             if (selected == 1)
6327                 stereoseparation += 0.001;
6328             else {
6329                 fireSound();
6330                 if (selected == 0) {
6331                     newstereomode = (StereoMode)(newstereomode + 1);
6332                     while (!CanInitStereo(newstereomode)) {
6333                         printf("Failed to initialize mode %s (%i)\n", StereoModeName(newstereomode), newstereomode);
6334                         newstereomode = (StereoMode)(newstereomode + 1);
6335                         if (newstereomode >= stereoCount)
6336                             newstereomode = stereoNone;
6337                     }
6338                 } else if (selected == 2) {
6339                     stereoreverse = !stereoreverse;
6340                 } else if (selected == 3) {
6341                     flash();
6342                     mainmenu = 3;
6343
6344                     stereomode = newstereomode;
6345                     InitStereo(stereomode);
6346                 }
6347             }
6348             updateStereoConfigMenu();
6349             break;
6350         }
6351     }
6352
6353     if (Input::isKeyDown(SDL_SCANCODE_Q) && Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6354         tryquit = 1;
6355         if (mainmenu == 3) {
6356             SaveSettings();
6357         }
6358     }
6359
6360     OPENAL_SetFrequency(channels[stream_menutheme], 22050);
6361
6362     if (entername) {
6363         inputText(displaytext[0], &displayselected);
6364         if (!waiting) { // the input as finished
6365             if (!displaytext[0].empty()) { // with enter
6366                 accountactive = Account::add(string(displaytext[0]));
6367
6368                 mainmenu = 8;
6369
6370                 flash();
6371
6372                 fireSound(firestartsound);
6373
6374                 displaytext[0].clear();
6375
6376                 displayselected = 0;
6377             }
6378             entername = 0;
6379             LoadMenu();
6380         }
6381
6382         displayblinkdelay -= multiplier;
6383         if (displayblinkdelay <= 0) {
6384             displayblinkdelay = .3;
6385             displayblink = 1 - displayblink;
6386         }
6387     }
6388
6389     if (entername) {
6390         Menu::setText(0, displaytext[0], 20, 400, -1, -1);
6391         Menu::setText(-2, displayblink ? "_" : "", 20 + displayselected * 10, 400, -1, -1);
6392     }
6393
6394     if (oldmainmenu != mainmenu)
6395         LoadMenu();
6396     oldmainmenu = mainmenu;
6397
6398 }
6399
6400 void Game::Tick()
6401 {
6402     static XYZ facing, flatfacing;
6403     static int target;
6404
6405     for (int i = 0; i < 15; i++) {
6406         displaytime[i] += multiplier;
6407     }
6408
6409     keyboardfrozen = false;
6410     Input::Tick();
6411
6412     if (Input::isKeyPressed(SDL_SCANCODE_F6)) {
6413         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6414             stereoreverse = true;
6415         else
6416             stereoreverse = false;
6417
6418         if (stereoreverse)
6419             printf("Stereo reversed\n");
6420         else
6421             printf("Stereo unreversed\n");
6422     }
6423
6424     if (Input::isKeyDown(SDL_SCANCODE_F7)) {
6425         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6426             stereoseparation -= 0.001;
6427         else
6428             stereoseparation -= 0.010;
6429         printf("Stereo decreased increased to %f\n", stereoseparation);
6430     }
6431
6432     if (Input::isKeyDown(SDL_SCANCODE_F8)) {
6433         if (Input::isKeyDown(SDL_SCANCODE_LSHIFT))
6434             stereoseparation += 0.001;
6435         else
6436             stereoseparation += 0.010;
6437         printf("Stereo separation increased to %f\n", stereoseparation);
6438     }
6439
6440
6441     if (Input::isKeyPressed(SDL_SCANCODE_TAB) && tutoriallevel) {
6442         if (tutorialstage != 51)
6443             tutorialstagetime = tutorialmaxtime;
6444         emit_sound_np(consolefailsound, 128.);
6445     }
6446
6447     /*
6448     Values of mainmenu :
6449     1 Main menu
6450     2 Menu pause (resume/end game)
6451     3 Option menu
6452     4 Controls configuration menu
6453     5 Main game menu (choose level or challenge)
6454     6 Deleting user menu
6455     7 User managment menu (select/add)
6456     8 Choose difficulty menu
6457     9 Challenge level selection menu
6458     10 End of the campaign congratulation (is that really a menu?)
6459     11 Same that 9 ??? => unused
6460     18 stereo configuration
6461     */
6462
6463     if (!console) {
6464         //campaign over?
6465         if (mainmenu && endgame == 1)
6466             mainmenu = 10;
6467         //go to level select after completing a campaign level
6468         if (campaign && winfreeze && mainmenu == 0 && campaignlevels[actuallevel].choosenext == 1) {
6469             mainmenu = 5;
6470             gameon = 0;
6471             winfreeze = 0;
6472             fireSound();
6473             flash();
6474             if (musictoggle) {
6475                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6476                 emit_stream_np(stream_menutheme);
6477                 pause_sound(leveltheme);
6478             }
6479             LoadMenu();
6480         }
6481         //escape key pressed
6482         if (Input::isKeyPressed(SDL_SCANCODE_ESCAPE) &&
6483                 (gameon || mainmenu == 0 || (mainmenu >= 3 && mainmenu != 8 && !(mainmenu == 7 && entername)))) {
6484             selected = -1;
6485             if (mainmenu == 0 && !winfreeze)
6486                 mainmenu = 2; //pause
6487             else if (mainmenu == 1 || mainmenu == 2) {
6488                 mainmenu = 0; //unpause
6489             }
6490             //play menu theme
6491             if (musictoggle && (mainmenu == 1 || mainmenu == 2)) {
6492                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6493                 emit_stream_np(stream_menutheme);
6494                 pause_sound(leveltheme);
6495             }
6496             //on resume, play level music
6497             if (!mainmenu) {
6498                 pause_sound(stream_menutheme);
6499                 resume_stream(leveltheme);
6500             }
6501             //finished with settings menu
6502             if (mainmenu == 3) {
6503                 SaveSettings();
6504             }
6505             //effects
6506             if (mainmenu >= 3 && mainmenu != 8) {
6507                 fireSound();
6508                 flash();
6509             }
6510             //go back
6511             switch (mainmenu) {
6512             case 3:
6513             case 5:
6514                 mainmenu = gameon ? 2 : 1;
6515                 break;
6516             case 4:
6517             case 18:
6518                 mainmenu = 3;
6519                 break;
6520             case 6:
6521             case 7:
6522             case 9:
6523             case 10:
6524                 mainmenu = 5;
6525                 break;
6526             }
6527         }
6528     }
6529
6530     if (mainmenu) {
6531         MenuTick();
6532     }
6533
6534     if (!mainmenu) {
6535         if (hostile == 1)
6536             hostiletime += multiplier;
6537         else
6538             hostiletime = 0;
6539         if (!winfreeze)
6540             leveltime += multiplier;
6541
6542         //keys
6543         if (Input::isKeyPressed(SDL_SCANCODE_V) && debugmode) {
6544             freeze = 1 - freeze;
6545             if (freeze) {
6546                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6547             }
6548         }
6549
6550         if (Input::isKeyPressed(consolekey) && debugmode) {
6551             console = !console;
6552             if (console) {
6553                 OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6554             } else {
6555                 freeze = 0;
6556                 waiting = false;
6557             }
6558         }
6559
6560         if (console)
6561             freeze = 1;
6562         if (console && !Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6563             inputText(consoletext[0], &consoleselected);
6564             if (!waiting) {
6565                 if (!consoletext[0].empty()) {
6566                     cmd_dispatch(consoletext[0]);
6567                     for (int k = 14; k >= 1; k--) {
6568                         consoletext[k] = consoletext[k - 1];
6569                     }
6570                     consoletext[0].clear();
6571                     consoleselected = 0;
6572                 }
6573             }
6574
6575             consoleblinkdelay -= multiplier;
6576             if (consoleblinkdelay <= 0) {
6577                 consoleblinkdelay = .3;
6578                 consoleblink = 1 - consoleblink;
6579             }
6580         }
6581
6582
6583
6584         if (Input::isKeyDown(SDL_SCANCODE_Q) && Input::isKeyDown(SDL_SCANCODE_LGUI)) {
6585             tryquit = 1;
6586             if (mainmenu == 3) {
6587                 SaveSettings();
6588             }
6589         }
6590
6591         static int oldwinfreeze;
6592         if (winfreeze && !oldwinfreeze) {
6593             OPENAL_SetFrequency(OPENAL_ALL, 0.001);
6594             emit_sound_np(consolesuccesssound);
6595         }
6596         if (winfreeze == 0)
6597             oldwinfreeze = winfreeze;
6598         else
6599             oldwinfreeze++;
6600
6601         if ((Input::isKeyPressed(jumpkey) || Input::isKeyPressed(SDL_SCANCODE_SPACE)) && !campaign)
6602             if (winfreeze)
6603                 winfreeze = 0;
6604         if ((Input::isKeyDown(SDL_SCANCODE_ESCAPE)) && !campaign && gameon) {
6605             if (console) {
6606                 console = false;
6607                 freeze = 0;
6608             } else if (winfreeze) {
6609                 mainmenu = 9;
6610                 gameon = 0;
6611             }
6612         }
6613
6614
6615
6616         if (!freeze && !winfreeze && !(mainmenu && gameon) && (gameon || !gamestarted)) {
6617
6618             //dialogues
6619             static float talkdelay = 0;
6620
6621             if (indialogue != -1)
6622                 talkdelay = 1;
6623             talkdelay -= multiplier;
6624
6625             if (talkdelay <= 0 && indialogue == -1 && animation[Person::players[0]->animTarget].height != highheight)
6626                 for (int i = 0; i < numdialogues; i++) {
6627                     unsigned realdialoguetype;
6628                     bool special;
6629                     /* FIXME - Seems like modulo done with ifs */
6630                     if (dialoguetype[i] > 49) {
6631                         realdialoguetype = dialoguetype[i] - 50;
6632                         special = 1;
6633                     } else if (dialoguetype[i] > 39) {
6634                         realdialoguetype = dialoguetype[i] - 40;
6635                         special = 1;
6636                     } else if (dialoguetype[i] > 29) {
6637                         realdialoguetype = dialoguetype[i] - 30;
6638                         special = 1;
6639                     } else if (dialoguetype[i] > 19) {
6640                         realdialoguetype = dialoguetype[i] - 20;
6641                         special = 1;
6642                     } else if (dialoguetype[i] > 9) {
6643                         realdialoguetype = dialoguetype[i] - 10;
6644                         special = 1;
6645                     } else {
6646                         realdialoguetype = dialoguetype[i];
6647                         special = 0;
6648                     }
6649                     if ((!hostile || dialoguetype[i] > 40 && dialoguetype[i] < 50) &&
6650                             realdialoguetype < Person::players.size() &&
6651                             realdialoguetype > 0 &&
6652                             (dialoguegonethrough[i] == 0 || !special) &&
6653                             (special || Input::isKeyPressed(attackkey))) {
6654                         if (distsq(&Person::players[0]->coords, &Person::players[realdialoguetype]->coords) < 6 ||
6655                                 Person::players[realdialoguetype]->howactive >= typedead1 ||
6656                                 dialoguetype[i] > 40 && dialoguetype[i] < 50) {
6657                             whichdialogue = i;
6658                             for (int j = 0; j < numdialogueboxes[whichdialogue]; j++) {
6659                                 Person::players[participantfocus[whichdialogue][j]]->coords = participantlocation[whichdialogue][participantfocus[whichdialogue][j]];
6660                                 Person::players[participantfocus[whichdialogue][j]]->yaw = participantyaw[whichdialogue][participantfocus[whichdialogue][j]];
6661                                 Person::players[participantfocus[whichdialogue][j]]->targetyaw = participantyaw[whichdialogue][participantfocus[whichdialogue][j]];
6662                                 Person::players[participantfocus[whichdialogue][j]]->velocity = 0;
6663                                 Person::players[participantfocus[whichdialogue][j]]->animTarget = Person::players[participantfocus[whichdialogue][j]]->getIdle();
6664                                 Person::players[participantfocus[whichdialogue][j]]->frameTarget = 0;
6665                             }
6666                             directing = 0;
6667                             indialogue = 0;
6668                             dialoguetime = 0;
6669                             dialoguegonethrough[i]++;
6670                             if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6671                                 playdialogueboxsound();
6672                             }
6673                         }
6674                     }
6675                 }
6676
6677             windvar += multiplier;
6678             smoketex += multiplier;
6679             tutorialstagetime += multiplier;
6680
6681             //hotspots
6682             static float hotspotvisual[40];
6683             if (numhotspots) {
6684                 XYZ hotspotsprite;
6685                 if (editorenabled)
6686                     for (int i = 0; i < numhotspots; i++)
6687                         hotspotvisual[i] -= multiplier / 320;
6688
6689                 for (int i = 0; i < numhotspots; i++) {
6690                     //if(hotspottype[i]<=10)
6691                     while (hotspotvisual[i] < 0) {
6692                         hotspotsprite = 0;
6693                         hotspotsprite.x = float(abs(Random() % 100000)) / 100000 * hotspotsize[i];
6694                         hotspotsprite = DoRotation(hotspotsprite, 0, 0, Random() % 360);
6695                         hotspotsprite = DoRotation(hotspotsprite, 0, Random() % 360, 0);
6696                         hotspotsprite += hotspot[i];
6697                         Sprite::MakeSprite(breathsprite, hotspotsprite, hotspotsprite * 0, 1, 0.5, 0, 7, 0.4);
6698                         hotspotvisual[i] += 0.1 / hotspotsize[i] / hotspotsize[i] / hotspotsize[i];
6699                     }
6700                 }
6701
6702                 for (int i = 0; i < numhotspots; i++) {
6703                     if (hotspottype[i] <= 10 && hotspottype[i] > 0) {
6704                         hotspot[i] = Person::players[hotspottype[i]]->coords;
6705                     }
6706                 }
6707             }
6708
6709             //Tutorial
6710             if (tutoriallevel) {
6711                 doTutorial();
6712             }
6713
6714             //bonuses
6715             if (tutoriallevel != 1) {
6716                 if (bonustime == 0 &&
6717                         bonus != solidhit &&
6718                         bonus != spinecrusher &&
6719                         bonus != tracheotomy &&
6720                         bonus != backstab &&
6721                         bonusvalue > 10) {
6722                     emit_sound_np(consolesuccesssound);
6723                 }
6724             } else if (bonustime == 0) {
6725                 emit_sound_np(fireendsound);
6726             }
6727             if (bonustime == 0) {
6728                 if (bonus != solidhit &&
6729                         bonus != twoxcombo &&
6730                         bonus != threexcombo &&
6731                         bonus != fourxcombo &&
6732                         bonus != megacombo)
6733                     bonusnum[bonus]++;
6734                 else
6735                     bonusnum[bonus] += 0.15;
6736                 if (tutoriallevel)
6737                     bonusvalue = 0;
6738                 bonusvalue /= bonusnum[bonus];
6739                 bonustotal += bonusvalue;
6740             }
6741             bonustime += multiplier;
6742
6743             //snow effects
6744             if (environment == snowyenvironment) {
6745                 precipdelay -= multiplier;
6746                 while (precipdelay < 0) {
6747                     precipdelay += .04;
6748                     if (!detail)
6749                         precipdelay += .04;
6750                     XYZ footvel, footpoint;
6751
6752                     footvel = 0;
6753                     footpoint = viewer + viewerfacing * 6;
6754                     footpoint.y += ((float)abs(Random() % 1200)) / 100 - 6;
6755                     footpoint.x += ((float)abs(Random() % 1200)) / 100 - 6;
6756                     footpoint.z += ((float)abs(Random() % 1200)) / 100 - 6;
6757                     Sprite::MakeSprite(snowsprite, footpoint, footvel, 1, 1, 1, .1, 1);
6758                 }
6759             }
6760
6761
6762             doAerialAcrobatics();
6763
6764
6765             static XYZ oldviewer;
6766
6767             //control keys
6768             if (indialogue == -1) {
6769                 Person::players[0]->forwardkeydown = Input::isKeyDown(forwardkey);
6770                 Person::players[0]->leftkeydown = Input::isKeyDown(leftkey);
6771                 Person::players[0]->backkeydown = Input::isKeyDown(backkey);
6772                 Person::players[0]->rightkeydown = Input::isKeyDown(rightkey);
6773                 Person::players[0]->jumpkeydown = Input::isKeyDown(jumpkey);
6774                 Person::players[0]->crouchkeydown = Input::isKeyDown(crouchkey);
6775                 Person::players[0]->drawkeydown = Input::isKeyDown(drawkey);
6776                 Person::players[0]->throwkeydown = Input::isKeyDown(throwkey);
6777             } else {
6778                 Person::players[0]->forwardkeydown = 0;
6779                 Person::players[0]->leftkeydown = 0;
6780                 Person::players[0]->backkeydown = 0;
6781                 Person::players[0]->rightkeydown = 0;
6782                 Person::players[0]->jumpkeydown = 0;
6783                 Person::players[0]->crouchkeydown = 0;
6784                 Person::players[0]->drawkeydown = 0;
6785                 Person::players[0]->throwkeydown = 0;
6786             }
6787
6788             if (!Person::players[0]->jumpkeydown)
6789                 Person::players[0]->jumpclimb = 0;
6790
6791
6792             if (indialogue != -1) {
6793                 cameramode = 1;
6794                 if (directing) {
6795                     facing = 0;
6796                     facing.z = -1;
6797
6798                     facing = DoRotation(facing, -pitch, 0, 0);
6799                     facing = DoRotation(facing, 0, 0 - yaw, 0);
6800
6801                     flatfacing = 0;
6802                     flatfacing.z = -1;
6803
6804                     flatfacing = DoRotation(flatfacing, 0, -yaw, 0);
6805
6806                     if (Input::isKeyDown(forwardkey))
6807                         viewer += facing * multiplier * 4;
6808                     if (Input::isKeyDown(backkey))
6809                         viewer -= facing * multiplier * 4;
6810                     if (Input::isKeyDown(leftkey))
6811                         viewer += DoRotation(flatfacing * multiplier, 0, 90, 0) * 4;
6812                     if (Input::isKeyDown(rightkey))
6813                         viewer += DoRotation(flatfacing * multiplier, 0, -90, 0) * 4;
6814                     if (Input::isKeyDown(jumpkey))
6815                         viewer.y += multiplier * 4;
6816                     if (Input::isKeyDown(crouchkey))
6817                         viewer.y -= multiplier * 4;
6818                     if (     Input::isKeyPressed(SDL_SCANCODE_1) ||
6819                              Input::isKeyPressed(SDL_SCANCODE_2) ||
6820                              Input::isKeyPressed(SDL_SCANCODE_3) ||
6821                              Input::isKeyPressed(SDL_SCANCODE_4) ||
6822                              Input::isKeyPressed(SDL_SCANCODE_5) ||
6823                              Input::isKeyPressed(SDL_SCANCODE_6) ||
6824                              Input::isKeyPressed(SDL_SCANCODE_7) ||
6825                              Input::isKeyPressed(SDL_SCANCODE_8) ||
6826                              Input::isKeyPressed(SDL_SCANCODE_9) ||
6827                              Input::isKeyPressed(SDL_SCANCODE_0) ||
6828                              Input::isKeyPressed(SDL_SCANCODE_MINUS)) {
6829                         int whichend;
6830                         if (Input::isKeyPressed(SDL_SCANCODE_1)) whichend = 1;
6831                         if (Input::isKeyPressed(SDL_SCANCODE_2)) whichend = 2;
6832                         if (Input::isKeyPressed(SDL_SCANCODE_3)) whichend = 3;
6833                         if (Input::isKeyPressed(SDL_SCANCODE_4)) whichend = 4;
6834                         if (Input::isKeyPressed(SDL_SCANCODE_5)) whichend = 5;
6835                         if (Input::isKeyPressed(SDL_SCANCODE_6)) whichend = 6;
6836                         if (Input::isKeyPressed(SDL_SCANCODE_7)) whichend = 7;
6837                         if (Input::isKeyPressed(SDL_SCANCODE_8)) whichend = 8;
6838                         if (Input::isKeyPressed(SDL_SCANCODE_9)) whichend = 9;
6839                         if (Input::isKeyPressed(SDL_SCANCODE_0)) whichend = 0;
6840                         if (Input::isKeyPressed(SDL_SCANCODE_MINUS))
6841                             whichend = -1;
6842                         if (whichend != -1) {
6843                             participantfocus[whichdialogue][indialogue] = whichend;
6844                             participantlocation[whichdialogue][whichend] = Person::players[whichend]->coords;
6845                             participantyaw[whichdialogue][whichend] = Person::players[whichend]->yaw;
6846                         }
6847                         if (whichend == -1) {
6848                             participantfocus[whichdialogue][indialogue] = -1;
6849                         }
6850                         if (Person::players[participantfocus[whichdialogue][indialogue]]->dead) {
6851                             indialogue = -1;
6852                             directing = 0;
6853                             cameramode = 0;
6854                         }
6855                         dialoguecamera[whichdialogue][indialogue] = viewer;
6856                         dialoguecamerayaw[whichdialogue][indialogue] = yaw;
6857                         dialoguecamerapitch[whichdialogue][indialogue] = pitch;
6858                         indialogue++;
6859                         if (indialogue < numdialogueboxes[whichdialogue]) {
6860                             if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6861                                 playdialogueboxsound();
6862                             }
6863                         }
6864
6865                         for (unsigned j = 0; j < Person::players.size(); j++) {
6866                             participantfacing[whichdialogue][indialogue][j] = participantfacing[whichdialogue][indialogue - 1][j];
6867                         }
6868                     }
6869                     //TODO: should these be KeyDown or KeyPressed?
6870                     if (     Input::isKeyDown(SDL_SCANCODE_KP_1) ||
6871                              Input::isKeyDown(SDL_SCANCODE_KP_2) ||
6872                              Input::isKeyDown(SDL_SCANCODE_KP_3) ||
6873                              Input::isKeyDown(SDL_SCANCODE_KP_4) ||
6874                              Input::isKeyDown(SDL_SCANCODE_KP_5) ||
6875                              Input::isKeyDown(SDL_SCANCODE_KP_6) ||
6876                              Input::isKeyDown(SDL_SCANCODE_KP_7) ||
6877                              Input::isKeyDown(SDL_SCANCODE_KP_8) ||
6878                              Input::isKeyDown(SDL_SCANCODE_KP_9) ||
6879                              Input::isKeyDown(SDL_SCANCODE_KP_0)) {
6880                         int whichend;
6881                         if (Input::isKeyDown(SDL_SCANCODE_KP_1)) whichend = 1;
6882                         if (Input::isKeyDown(SDL_SCANCODE_KP_2)) whichend = 2;
6883                         if (Input::isKeyDown(SDL_SCANCODE_KP_3)) whichend = 3;
6884                         if (Input::isKeyDown(SDL_SCANCODE_KP_4)) whichend = 4;
6885                         if (Input::isKeyDown(SDL_SCANCODE_KP_5)) whichend = 5;
6886                         if (Input::isKeyDown(SDL_SCANCODE_KP_6)) whichend = 6;
6887                         if (Input::isKeyDown(SDL_SCANCODE_KP_7)) whichend = 7;
6888                         if (Input::isKeyDown(SDL_SCANCODE_KP_8)) whichend = 8;
6889                         if (Input::isKeyDown(SDL_SCANCODE_KP_9)) whichend = 9;
6890                         if (Input::isKeyDown(SDL_SCANCODE_KP_0)) whichend = 0;
6891                         participantfacing[whichdialogue][indialogue][whichend] = facing;
6892                     }
6893                     if (indialogue >= numdialogueboxes[whichdialogue]) {
6894                         indialogue = -1;
6895                         directing = 0;
6896                         cameramode = 0;
6897                     }
6898                 }
6899                 if (!directing) {
6900                     pause_sound(whooshsound);
6901                     viewer = dialoguecamera[whichdialogue][indialogue];
6902                     viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .1);
6903                     yaw = dialoguecamerayaw[whichdialogue][indialogue];
6904                     pitch = dialoguecamerapitch[whichdialogue][indialogue];
6905                     if (dialoguetime > 0.5)
6906                         if (     Input::isKeyPressed(SDL_SCANCODE_1) ||
6907                                  Input::isKeyPressed(SDL_SCANCODE_2) ||
6908                                  Input::isKeyPressed(SDL_SCANCODE_3) ||
6909                                  Input::isKeyPressed(SDL_SCANCODE_4) ||
6910                                  Input::isKeyPressed(SDL_SCANCODE_5) ||
6911                                  Input::isKeyPressed(SDL_SCANCODE_6) ||
6912                                  Input::isKeyPressed(SDL_SCANCODE_7) ||
6913                                  Input::isKeyPressed(SDL_SCANCODE_8) ||
6914                                  Input::isKeyPressed(SDL_SCANCODE_9) ||
6915                                  Input::isKeyPressed(SDL_SCANCODE_0) ||
6916                                  Input::isKeyPressed(SDL_SCANCODE_MINUS) ||
6917                                  Input::isKeyPressed(attackkey)) {
6918                             indialogue++;
6919                             if (indialogue < numdialogueboxes[whichdialogue]) {
6920                                 if (dialogueboxsound[whichdialogue][indialogue] != 0) {
6921                                     playdialogueboxsound();
6922                                     if (dialogueboxsound[whichdialogue][indialogue] == -5) {
6923                                         hotspot[numhotspots] = Person::players[0]->coords;
6924                                         hotspotsize[numhotspots] = 10;
6925                                         hotspottype[numhotspots] = -1;
6926
6927                                         numhotspots++;
6928                                     }
6929                                     if (dialogueboxsound[whichdialogue][indialogue] == -6) {
6930                                         hostile = 1;
6931                                     }
6932
6933                                     if (Person::players[participantfocus[whichdialogue][indialogue]]->dead) {
6934                                         indialogue = -1;
6935                                         directing = 0;
6936                                         cameramode = 0;
6937                                     }
6938                                 }
6939                             }
6940                         }
6941                     if (indialogue >= numdialogueboxes[whichdialogue]) {
6942                         indialogue = -1;
6943                         directing = 0;
6944                         cameramode = 0;
6945                         if (dialoguetype[whichdialogue] > 19 && dialoguetype[whichdialogue] < 30) {
6946                             hostile = 1;
6947                         }
6948                         if (dialoguetype[whichdialogue] > 29 && dialoguetype[whichdialogue] < 40) {
6949                             windialogue = true;
6950                         }
6951                         if (dialoguetype[whichdialogue] > 49 && dialoguetype[whichdialogue] < 60) {
6952                             hostile = 1;
6953                             for (unsigned i = 1; i < Person::players.size(); i++) {
6954                                 Person::players[i]->aitype = attacktypecutoff;
6955                             }
6956                         }
6957                     }
6958                 }
6959             }
6960
6961             if (!Person::players[0]->jumpkeydown) {
6962                 Person::players[0]->jumptogglekeydown = 0;
6963             }
6964             if (Person::players[0]->jumpkeydown &&
6965                     Person::players[0]->animTarget != jumpupanim &&
6966                     Person::players[0]->animTarget != jumpdownanim &&
6967                     !Person::players[0]->isFlip())
6968                 Person::players[0]->jumptogglekeydown = 1;
6969
6970
6971             dialoguetime += multiplier;
6972             hawkyaw += multiplier * 25;
6973             realhawkcoords = 0;
6974             realhawkcoords.x = 25;
6975             realhawkcoords = DoRotation(realhawkcoords, 0, hawkyaw, 0) + hawkcoords;
6976             hawkcalldelay -= multiplier / 2;
6977
6978             if (hawkcalldelay <= 0) {
6979                 emit_sound_at(hawksound, realhawkcoords);
6980
6981                 hawkcalldelay = 16 + abs(Random() % 8);
6982             }
6983
6984             doDebugKeys();
6985
6986             doAttacks();
6987
6988             doPlayerCollisions();
6989
6990             doJumpReversals();
6991
6992             for (unsigned k = 0; k < Person::players.size(); k++)
6993                 if (k != 0 && Person::players[k]->immobile)
6994                     Person::players[k]->coords = Person::players[k]->realoldcoords;
6995
6996             for (unsigned k = 0; k < Person::players.size(); k++) {
6997                 if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
6998                     if (!isnormal(Person::players[k]->coords.x) || !isnormal(Person::players[k]->coords.y) || !isnormal(Person::players[k]->coords.z)) {
6999                         Person::players[k]->DoDamage(1000);
7000                     }
7001                 }
7002             }
7003
7004             //respawn
7005             static bool respawnkeydown;
7006             if (!editorenabled &&
7007                     (whichlevel != -2 &&
7008                      (Input::isKeyDown(SDL_SCANCODE_Z) &&
7009                       Input::isKeyDown(SDL_SCANCODE_LGUI) &&
7010                       debugmode) ||
7011                      (Input::isKeyDown(jumpkey) &&
7012                       !respawnkeydown &&
7013                       !oldattackkey &&
7014                       Person::players[0]->dead))) {
7015                 targetlevel = whichlevel;
7016                 loading = 1;
7017                 leveltime = 5;
7018             }
7019             if (!Input::isKeyDown(jumpkey))
7020                 respawnkeydown = 0;
7021             if (Input::isKeyDown(jumpkey))
7022                 respawnkeydown = 1;
7023
7024
7025
7026
7027             static bool movekey;
7028
7029             //?
7030             for (unsigned i = 0; i < Person::players.size(); i++) {
7031                 static float oldtargetyaw;
7032                 if (!Person::players[i]->skeleton.free) {
7033                     oldtargetyaw = Person::players[i]->targetyaw;
7034                     if (i == 0 && indialogue == -1) {
7035                         //TODO: refactor repetitive code
7036                         if (!animation[Person::players[0]->animTarget].attack &&
7037                                 Person::players[0]->animTarget != staggerbackhighanim &&
7038                                 Person::players[0]->animTarget != staggerbackhardanim &&
7039                                 Person::players[0]->animTarget != crouchremoveknifeanim &&
7040                                 Person::players[0]->animTarget != removeknifeanim &&
7041                                 Person::players[0]->animTarget != backhandspringanim &&
7042                                 Person::players[0]->animTarget != dodgebackanim &&
7043                                 Person::players[0]->animTarget != walljumprightkickanim &&
7044                                 Person::players[0]->animTarget != walljumpleftkickanim) {
7045                             if (cameramode)
7046                                 Person::players[0]->targetyaw = 0;
7047                             else
7048                                 Person::players[0]->targetyaw = -yaw + 180;
7049                         }
7050
7051                         facing = 0;
7052                         facing.z = -1;
7053
7054                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
7055                         if (cameramode) {
7056                             facing = flatfacing;
7057                         } else {
7058                             facing = DoRotation(facing, -pitch, 0, 0);
7059                             facing = DoRotation(facing, 0, 0 - yaw, 0);
7060                         }
7061
7062                         Person::players[0]->lookyaw = -yaw;
7063
7064                         Person::players[i]->targetheadyaw = yaw;
7065                         Person::players[i]->targetheadpitch = pitch;
7066                     }
7067                     if (i != 0 && Person::players[i]->aitype == playercontrolled && indialogue == -1) {
7068                         if (!animation[Person::players[i]->animTarget].attack &&
7069                                 Person::players[i]->animTarget != staggerbackhighanim &&
7070                                 Person::players[i]->animTarget != staggerbackhardanim &&
7071                                 Person::players[i]->animTarget != crouchremoveknifeanim &&
7072                                 Person::players[i]->animTarget != removeknifeanim &&
7073                                 Person::players[i]->animTarget != backhandspringanim &&
7074                                 Person::players[i]->animTarget != dodgebackanim &&
7075                                 Person::players[i]->animTarget != walljumprightkickanim &&
7076                                 Person::players[i]->animTarget != walljumpleftkickanim) {
7077                             Person::players[i]->targetyaw = -Person::players[i]->lookyaw + 180;
7078                         }
7079
7080                         facing = 0;
7081                         facing.z = -1;
7082
7083                         flatfacing = DoRotation(facing, 0, Person::players[i]->yaw + 180, 0);
7084
7085                         facing = DoRotation(facing, -Person::players[i]->lookpitch, 0, 0);
7086                         facing = DoRotation(facing, 0, 0 - Person::players[i]->lookyaw, 0);
7087
7088                         Person::players[i]->targetheadyaw = Person::players[i]->lookyaw;
7089                         Person::players[i]->targetheadpitch = Person::players[i]->lookpitch;
7090                     }
7091                     if (indialogue != -1) {
7092                         Person::players[i]->targetheadyaw = 180 - roughDirection(participantfacing[whichdialogue][indialogue][i]);
7093                         Person::players[i]->targetheadpitch = pitchOf(participantfacing[whichdialogue][indialogue][i]);
7094                     }
7095
7096                     if (leveltime < .5)
7097                         numenvsounds = 0;
7098
7099                     Person::players[i]->avoidsomething = 0;
7100
7101                     //avoid flaming things
7102                     for (int j = 0; j < objects.numobjects; j++)
7103                         if (objects.onfire[j])
7104                             if (distsq(&Person::players[i]->coords, &objects.position[j]) < sq(objects.scale[j]) * 200)
7105                                 if (     distsq(&Person::players[i]->coords, &objects.position[j]) <
7106                                          distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
7107                                     Person::players[i]->collided = 0;
7108                                     Person::players[i]->avoidcollided = 1;
7109                                     if (Person::players[i]->avoidsomething == 0 ||
7110                                             distsq(&Person::players[i]->coords, &objects.position[j]) <
7111                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
7112                                         Person::players[i]->avoidwhere = objects.position[j];
7113                                         Person::players[i]->avoidsomething = 1;
7114                                     }
7115                                 }
7116
7117                     //avoid flaming players
7118                     for (unsigned j = 0; j < Person::players.size(); j++)
7119                         if (Person::players[j]->onfire)
7120                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < sq(0.3) * 200)
7121                                 if (     distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
7122                                          distsq(&Person::players[i]->coords, &Person::players[0]->coords)) {
7123                                     Person::players[i]->collided = 0;
7124                                     Person::players[i]->avoidcollided = 1;
7125                                     if (Person::players[i]->avoidsomething == 0 ||
7126                                             distsq(&Person::players[i]->coords, &Person::players[j]->coords) <
7127                                             distsq(&Person::players[i]->coords, &Person::players[i]->avoidwhere)) {
7128                                         Person::players[i]->avoidwhere = Person::players[j]->coords;
7129                                         Person::players[i]->avoidsomething = 1;
7130                                     }
7131                                 }
7132
7133                     if (Person::players[i]->collided > .8)
7134                         Person::players[i]->avoidcollided = 0;
7135
7136                     doAI(i);
7137
7138                     if (animation[Person::players[i]->animTarget].attack == reversed) {
7139                         //Person::players[i]->targetyaw=Person::players[i]->yaw;
7140                         Person::players[i]->forwardkeydown = 0;
7141                         Person::players[i]->leftkeydown = 0;
7142                         Person::players[i]->backkeydown = 0;
7143                         Person::players[i]->rightkeydown = 0;
7144                         Person::players[i]->jumpkeydown = 0;
7145                         Person::players[i]->attackkeydown = 0;
7146                         //Person::players[i]->crouchkeydown=0;
7147                         Person::players[i]->throwkeydown = 0;
7148                     }
7149
7150                     if (indialogue != -1) {
7151                         Person::players[i]->forwardkeydown = 0;
7152                         Person::players[i]->leftkeydown = 0;
7153                         Person::players[i]->backkeydown = 0;
7154                         Person::players[i]->rightkeydown = 0;
7155                         Person::players[i]->jumpkeydown = 0;
7156                         Person::players[i]->crouchkeydown = 0;
7157                         Person::players[i]->drawkeydown = 0;
7158                         Person::players[i]->throwkeydown = 0;
7159                     }
7160
7161                     if (Person::players[i]->collided < -.3)
7162                         Person::players[i]->collided = -.3;
7163                     if (Person::players[i]->collided > 1)
7164                         Person::players[i]->collided = 1;
7165                     Person::players[i]->collided -= multiplier * 4;
7166                     Person::players[i]->whichdirectiondelay -= multiplier;
7167                     if (Person::players[i]->avoidcollided < -.3 || Person::players[i]->whichdirectiondelay <= 0) {
7168                         Person::players[i]->avoidcollided = -.3;
7169                         Person::players[i]->whichdirection = abs(Random() % 2);
7170                         Person::players[i]->whichdirectiondelay = .4;
7171                     }
7172                     if (Person::players[i]->avoidcollided > 1)
7173                         Person::players[i]->avoidcollided = 1;
7174                     Person::players[i]->avoidcollided -= multiplier / 4;
7175                     if (!Person::players[i]->skeleton.free) {
7176                         Person::players[i]->stunned -= multiplier;
7177                         Person::players[i]->surprised -= multiplier;
7178                     }
7179                     if (i != 0 && Person::players[i]->surprised <= 0 &&
7180                             Person::players[i]->aitype == attacktypecutoff &&
7181                             !Person::players[i]->dead &&
7182                             !Person::players[i]->skeleton.free &&
7183                             animation[Person::players[i]->animTarget].attack == neutral)
7184                         numresponded = 1;
7185
7186                     if (!Person::players[i]->throwkeydown)
7187                         Person::players[i]->throwtogglekeydown = 0;
7188
7189                     //pick up weapon
7190                     if (Person::players[i]->throwkeydown && !Person::players[i]->throwtogglekeydown) {
7191                         if (Person::players[i]->weaponactive == -1 &&
7192                                 Person::players[i]->num_weapons < 2 &&
7193                                 (Person::players[i]->isIdle() ||
7194                                  Person::players[i]->isCrouch() ||
7195                                  Person::players[i]->animTarget == sneakanim ||
7196                                  Person::players[i]->animTarget == rollanim ||
7197                                  Person::players[i]->animTarget == backhandspringanim ||
7198                                  Person::players[i]->isFlip() ||
7199                                  Person::players[i]->isFlip() ||
7200                                  Person::players[i]->aitype != playercontrolled)) {
7201                             for (unsigned j = 0; j < weapons.size(); j++) {
7202                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
7203                                         Person::players[i]->aitype == playercontrolled) &&
7204                                         weapons[j].owner == -1 &&
7205                                         Person::players[i]->weaponactive == -1)
7206                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2) {
7207                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 2) {
7208                                             if (Person::players[i]->isCrouch() ||
7209                                                     Person::players[i]->animTarget == sneakanim ||
7210                                                     Person::players[i]->isRun() ||
7211                                                     Person::players[i]->isIdle() ||
7212                                                     Person::players[i]->aitype != playercontrolled) {
7213                                                 Person::players[i]->throwtogglekeydown = 1;
7214                                                 Person::players[i]->setAnimation(crouchremoveknifeanim);
7215                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
7216                                                 Person::players[i]->hasvictim = 0;
7217                                             }
7218                                             if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
7219                                                 Person::players[i]->throwtogglekeydown = 1;
7220                                                 Person::players[i]->hasvictim = 0;
7221
7222                                                 if ((weapons[j].velocity.x == 0 && weapons[j].velocity.y == 0 && weapons[j].velocity.z == 0 ||
7223                                                         Person::players[i]->aitype == playercontrolled) &&
7224                                                         weapons[j].owner == -1 ||
7225                                                         Person::players[i]->victim &&
7226                                                         weapons[j].owner == int(Person::players[i]->victim->id))
7227                                                     if (distsqflat(&Person::players[i]->coords, &weapons[j].position) < 2 && Person::players[i]->weaponactive == -1)
7228                                                         if (distsq(&Person::players[i]->coords, &weapons[j].position) < 1 || Person::players[i]->victim) {
7229                                                             if (weapons[j].getType() != staff)
7230                                                                 emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7231
7232                                                             Person::players[i]->weaponactive = 0;
7233                                                             weapons[j].owner = Person::players[i]->id;
7234                                                             if (Person::players[i]->num_weapons > 0)
7235                                                                 Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7236                                                             Person::players[i]->num_weapons++;
7237                                                             Person::players[i]->weaponids[0] = j;
7238                                                         }
7239                                             }
7240                                         } else if ((Person::players[i]->isIdle() ||
7241                                                     Person::players[i]->isFlip() ||
7242                                                     Person::players[i]->aitype != playercontrolled) &&
7243                                                    distsq(&Person::players[i]->coords, &weapons[j].position) < 5 &&
7244                                                    Person::players[i]->coords.y < weapons[j].position.y) {
7245                                             if (!Person::players[i]->isFlip()) {
7246                                                 Person::players[i]->throwtogglekeydown = 1;
7247                                                 Person::players[i]->setAnimation(removeknifeanim);
7248                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, weapons[j].position);
7249                                             }
7250                                             if (Person::players[i]->isFlip()) {
7251                                                 Person::players[i]->throwtogglekeydown = 1;
7252                                                 Person::players[i]->hasvictim = 0;
7253
7254                                                 for (unsigned k = 0; k < weapons.size(); k++) {
7255                                                     if (Person::players[i]->weaponactive == -1)
7256                                                         if ((weapons[k].velocity.x == 0 && weapons[k].velocity.y == 0 && weapons[k].velocity.z == 0 ||
7257                                                                 Person::players[i]->aitype == playercontrolled) &&
7258                                                                 weapons[k].owner == -1 ||
7259                                                                 Person::players[i]->victim &&
7260                                                                 weapons[k].owner == int(Person::players[i]->victim->id))
7261                                                             if (distsqflat(&Person::players[i]->coords, &weapons[k].position) < 3 &&
7262                                                                     Person::players[i]->weaponactive == -1) {
7263                                                                 if (weapons[k].getType() != staff)
7264                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7265
7266                                                                 Person::players[i]->weaponactive = 0;
7267                                                                 weapons[k].owner = Person::players[i]->id;
7268                                                                 if (Person::players[i]->num_weapons > 0)
7269                                                                     Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7270                                                                 Person::players[i]->num_weapons++;
7271                                                                 Person::players[i]->weaponids[0] = k;
7272                                                             }
7273                                                 }
7274                                             }
7275                                         }
7276                                     }
7277                             }
7278                             if (Person::players[i]->isCrouch() ||
7279                                     Person::players[i]->animTarget == sneakanim ||
7280                                     Person::players[i]->isRun() ||
7281                                     Person::players[i]->isIdle() || Person::players[i]->animTarget == rollanim ||
7282                                     Person::players[i]->animTarget == backhandspringanim) {
7283                                 if (Person::players.size() > 1)
7284                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7285                                         if (Person::players[i]->weaponactive == -1)
7286                                             if (j != i)
7287                                                 if (Person::players[j]->num_weapons &&
7288                                                         Person::players[j]->skeleton.free &&
7289                                                         distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 2/*&&Person::players[j]->dead*/ &&
7290                                                         (((Person::players[j]->skeleton.forward.y < 0 &&
7291                                                            Person::players[j]->weaponstuckwhere == 0) ||
7292                                                           (Person::players[j]->skeleton.forward.y > 0 &&
7293                                                            Person::players[j]->weaponstuckwhere == 1)) ||
7294                                                          Person::players[j]->weaponstuck == -1 ||
7295                                                          Person::players[j]->num_weapons > 1)) {
7296                                                     if (Person::players[i]->animTarget != rollanim && Person::players[i]->animTarget != backhandspringanim) {
7297                                                         Person::players[i]->throwtogglekeydown = 1;
7298                                                         Person::players[i]->victim = Person::players[j];
7299                                                         Person::players[i]->hasvictim = 1;
7300                                                         Person::players[i]->setAnimation(crouchremoveknifeanim);
7301                                                         Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
7302                                                     }
7303                                                     if (Person::players[i]->animTarget == rollanim || Person::players[i]->animTarget == backhandspringanim) {
7304                                                         Person::players[i]->throwtogglekeydown = 1;
7305                                                         Person::players[i]->victim = Person::players[j];
7306                                                         Person::players[i]->hasvictim = 1;
7307                                                         int k = Person::players[j]->weaponids[0];
7308                                                         if (Person::players[i]->hasvictim) {
7309                                                             bool fleshstuck;
7310                                                             fleshstuck = 0;
7311                                                             if (Person::players[i]->victim->weaponstuck != -1) {
7312                                                                 if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
7313                                                                     fleshstuck = 1;
7314                                                                 }
7315                                                             }
7316                                                             if (!fleshstuck) {
7317                                                                 if (weapons[k].getType() != staff)
7318                                                                     emit_sound_at(knifedrawsound, Person::players[i]->coords, 128.);
7319                                                             }
7320                                                             if (fleshstuck)
7321                                                                 emit_sound_at(fleshstabremovesound, Person::players[i]->coords, 128.);
7322
7323                                                             Person::players[i]->weaponactive = 0;
7324                                                             if (weapons[k].owner != -1) {
7325                                                                 if (Person::players[i]->victim->num_weapons == 1)
7326                                                                     Person::players[i]->victim->num_weapons = 0;
7327                                                                 else
7328                                                                     Person::players[i]->victim->num_weapons = 1;
7329
7330                                                                 Person::players[i]->victim->skeleton.longdead = 0;
7331                                                                 Person::players[i]->victim->skeleton.free = 1;
7332                                                                 Person::players[i]->victim->skeleton.broken = 0;
7333
7334                                                                 for (int l = 0; l < Person::players[i]->victim->skeleton.num_joints; l++) {
7335                                                                     Person::players[i]->victim->skeleton.joints[l].velchange = 0;
7336                                                                     Person::players[i]->victim->skeleton.joints[l].locked = 0;
7337                                                                 }
7338
7339                                                                 XYZ relative;
7340                                                                 relative = 0;
7341                                                                 relative.y = 10;
7342                                                                 Normalise(&relative);
7343                                                                 XYZ footvel, footpoint;
7344                                                                 footvel = 0;
7345                                                                 footpoint = weapons[k].position;
7346                                                                 if (Person::players[i]->victim->weaponstuck != -1) {
7347                                                                     if (Person::players[i]->victim->weaponids[Person::players[i]->victim->weaponstuck] == k) {
7348                                                                         if (bloodtoggle)
7349                                                                             Sprite::MakeSprite(cloudimpactsprite, footpoint, footvel, 1, 0, 0, .8, .3);
7350                                                                         weapons[k].bloody = 2;
7351                                                                         weapons[k].blooddrip = 5;
7352                                                                         Person::players[i]->victim->weaponstuck = -1;
7353                                                                         Person::players[i]->victim->bloodloss += 2000;
7354                                                                         Person::players[i]->victim->DoDamage(2000);
7355                                                                     }
7356                                                                 }
7357                                                                 if (Person::players[i]->victim->num_weapons > 0) {
7358                                                                     if (Person::players[i]->victim->weaponstuck != 0 && Person::players[i]->victim->weaponstuck != -1)
7359                                                                         Person::players[i]->victim->weaponstuck = 0;
7360                                                                     if (Person::players[i]->victim->weaponids[0] == k)
7361                                                                         Person::players[i]->victim->weaponids[0] = Person::players[i]->victim->weaponids[Person::players[i]->victim->num_weapons];
7362                                                                 }
7363
7364                                                                 Person::players[i]->victim->weaponactive = -1;
7365
7366                                                                 Person::players[i]->victim->jointVel(abdomen) += relative * 6;
7367                                                                 Person::players[i]->victim->jointVel(neck) += relative * 6;
7368                                                                 Person::players[i]->victim->jointVel(rightshoulder) += relative * 6;
7369                                                                 Person::players[i]->victim->jointVel(leftshoulder) += relative * 6;
7370                                                             }
7371                                                             weapons[k].owner = i;
7372                                                             if (Person::players[i]->num_weapons > 0) {
7373                                                                 Person::players[i]->weaponids[Person::players[i]->num_weapons] = Person::players[i]->weaponids[0];
7374                                                             }
7375                                                             Person::players[i]->num_weapons++;
7376                                                             Person::players[i]->weaponids[0] = k;
7377                                                         }
7378                                                     }
7379                                                 }
7380                                     }
7381                             }
7382                         }
7383                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
7384                             if (weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7385                                 if (Person::players[i]->isIdle() ||
7386                                         Person::players[i]->isRun() ||
7387                                         Person::players[i]->isCrouch() ||
7388                                         Person::players[i]->animTarget == sneakanim ||
7389                                         Person::players[i]->isFlip())
7390                                     if (Person::players.size() > 1)
7391                                         for (unsigned j = 0; j < Person::players.size(); j++) {
7392                                             if (i != j)
7393                                                 if (tutoriallevel != 1 || tutorialstage == 49)
7394                                                     if (hostile)
7395                                                         if (normaldotproduct(Person::players[i]->facing, Person::players[i]->coords - Person::players[j]->coords) < 0 &&
7396                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) < 100 &&
7397                                                                 distsq(&Person::players[i]->coords, &Person::players[j]->coords) > 1.5 &&
7398                                                                 !Person::players[j]->skeleton.free &&
7399                                                                 -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)) {
7400                                                             if (!Person::players[i]->isFlip()) {
7401                                                                 Person::players[i]->throwtogglekeydown = 1;
7402                                                                 Person::players[i]->victim = Person::players[j];
7403                                                                 Person::players[i]->setAnimation(knifethrowanim);
7404                                                                 Person::players[i]->targetyaw = roughDirectionTo(Person::players[i]->coords, Person::players[j]->coords);
7405                                                                 Person::players[i]->targettilt2 = pitchTo(Person::players[i]->coords, Person::players[j]->coords);
7406                                                             }
7407                                                             if (Person::players[i]->isFlip()) {
7408                                                                 if (Person::players[i]->weaponactive != -1) {
7409                                                                     Person::players[i]->throwtogglekeydown = 1;
7410                                                                     Person::players[i]->victim = Person::players[j];
7411                                                                     XYZ aim;
7412                                                                     weapons[Person::players[i]->weaponids[0]].owner = -1;
7413                                                                     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);
7414                                                                     Normalise(&aim);
7415
7416                                                                     aim = DoRotation(aim, (float)abs(Random() % 30) - 15, (float)abs(Random() % 30) - 15, 0);
7417
7418                                                                     weapons[Person::players[i]->weaponids[0]].velocity = aim * 50;
7419                                                                     weapons[Person::players[i]->weaponids[0]].tipvelocity = aim * 50;
7420                                                                     weapons[Person::players[i]->weaponids[0]].missed = 0;
7421                                                                     weapons[Person::players[i]->weaponids[0]].freetime = 0;
7422                                                                     weapons[Person::players[i]->weaponids[0]].firstfree = 1;
7423                                                                     weapons[Person::players[i]->weaponids[0]].physics = 0;
7424                                                                     Person::players[i]->num_weapons--;
7425                                                                     if (Person::players[i]->num_weapons) {
7426                                                                         Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
7427                                                                     }
7428                                                                     Person::players[i]->weaponactive = -1;
7429                                                                 }
7430                                                             }
7431                                                         }
7432                                         }
7433                             }
7434                         }
7435                         if (Person::players[i]->weaponactive != -1 && Person::players[i]->aitype == playercontrolled) {
7436                             if (Person::players[i]->isCrouch() || Person::players[i]->animTarget == sneakanim) {
7437                                 Person::players[i]->throwtogglekeydown = 1;
7438                                 weapons[Person::players[i]->weaponids[0]].owner = -1;
7439                                 weapons[Person::players[i]->weaponids[0]].velocity = Person::players[i]->velocity * .2;
7440                                 if (weapons[Person::players[i]->weaponids[0]].velocity.x == 0)
7441                                     weapons[Person::players[i]->weaponids[0]].velocity.x = .1;
7442                                 weapons[Person::players[i]->weaponids[0]].tipvelocity = weapons[Person::players[i]->weaponids[0]].velocity;
7443                                 weapons[Person::players[i]->weaponids[0]].missed = 1;
7444                                 weapons[Person::players[i]->weaponids[0]].freetime = 0;
7445                                 weapons[Person::players[i]->weaponids[0]].firstfree = 1;
7446                                 weapons[Person::players[i]->weaponids[0]].physics = 1;
7447                                 Person::players[i]->num_weapons--;
7448                                 if (Person::players[i]->num_weapons) {
7449                                     Person::players[i]->weaponids[0] = Person::players[i]->weaponids[Person::players[i]->num_weapons];
7450                                     if (Person::players[i]->weaponstuck == Person::players[i]->num_weapons)
7451                                         Person::players[i]->weaponstuck = 0;
7452                                 }
7453
7454                                 Person::players[i]->weaponactive = -1;
7455                                 for (unsigned j = 0; j < Person::players.size(); j++) {
7456                                     Person::players[j]->wentforweapon = 0;
7457                                 }
7458                             }
7459                         }
7460
7461                     }
7462
7463                     //draw weapon
7464                     if (i == 0 || !Person::players[0]->dead || (Person::players[i]->weaponactive != -1)) {
7465                         if (Person::players[i]->drawkeydown && !Person::players[i]->drawtogglekeydown ||
7466                                 (Person::players[i]->num_weapons == 2) &&
7467                                 (Person::players[i]->weaponactive == -1) &&
7468                                 Person::players[i]->isIdle() ||
7469                                 Person::players[0]->dead &&
7470                                 (Person::players[i]->weaponactive != -1) &&
7471                                 i != 0) {
7472                             bool isgood = true;
7473                             if (Person::players[i]->weaponactive != -1)
7474                                 if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == staff)
7475                                     isgood = false;
7476                             if (isgood && Person::players[i]->creature != wolftype) {
7477                                 if (Person::players[i]->isIdle() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7478                                     Person::players[i]->setAnimation(drawrightanim);
7479                                     Person::players[i]->drawtogglekeydown = 1;
7480                                 }
7481                                 if ((Person::players[i]->isIdle() ||
7482                                         (Person::players[i]->aitype != playercontrolled &&
7483                                          Person::players[0]->weaponactive != -1 &&
7484                                          Person::players[i]->isRun())) &&
7485                                         Person::players[i]->num_weapons &&
7486                                         weapons[Person::players[i]->weaponids[0]].getType() == sword) {
7487                                     Person::players[i]->setAnimation(drawleftanim);
7488                                     Person::players[i]->drawtogglekeydown = 1;
7489                                 }
7490                                 if (Person::players[i]->isCrouch() && Person::players[i]->num_weapons && weapons[Person::players[i]->weaponids[0]].getType() == knife) {
7491                                     Person::players[i]->setAnimation(crouchdrawrightanim);
7492                                     Person::players[i]->drawtogglekeydown = 1;
7493                                 }
7494                             }
7495                         }
7496                     }
7497
7498                     //clean weapon
7499                     if (Person::players[i]->weaponactive != -1) {
7500                         if (Person::players[i]->isCrouch() &&
7501                                 weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].bloody &&
7502                                 bloodtoggle &&
7503                                 Person::players[i]->onterrain &&
7504                                 Person::players[i]->num_weapons &&
7505                                 Person::players[i]->attackkeydown &&
7506                                 musictype != stream_fighttheme) {
7507                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == knife)
7508                                 Person::players[i]->setAnimation(crouchstabanim);
7509                             if (weapons[Person::players[i]->weaponids[Person::players[i]->weaponactive]].getType() == sword)
7510                                 Person::players[i]->setAnimation(swordgroundstabanim);
7511                             Person::players[i]->hasvictim = 0;
7512                         }
7513                     }
7514
7515                     if (!Person::players[i]->drawkeydown)
7516                         Person::players[i]->drawtogglekeydown = 0;
7517
7518                     XYZ absflatfacing;
7519                     if (i == 0) {
7520                         absflatfacing = 0;
7521                         absflatfacing.z = -1;
7522
7523                         absflatfacing = DoRotation(absflatfacing, 0, -yaw, 0);
7524                     } else
7525                         absflatfacing = flatfacing;
7526
7527                     if (indialogue != -1) {
7528                         Person::players[i]->forwardkeydown = 0;
7529                         Person::players[i]->leftkeydown = 0;
7530                         Person::players[i]->backkeydown = 0;
7531                         Person::players[i]->rightkeydown = 0;
7532                         Person::players[i]->jumpkeydown = 0;
7533                         Person::players[i]->crouchkeydown = 0;
7534                         Person::players[i]->drawkeydown = 0;
7535                         Person::players[i]->throwkeydown = 0;
7536                     }
7537                     movekey = 0;
7538                     //Do controls
7539                     if (!animation[Person::players[i]->animTarget].attack &&
7540                             Person::players[i]->animTarget != staggerbackhighanim &&
7541                             Person::players[i]->animTarget != staggerbackhardanim &&
7542                             Person::players[i]->animTarget != backhandspringanim &&
7543                             Person::players[i]->animTarget != dodgebackanim) {
7544                         if (!Person::players[i]->forwardkeydown)
7545                             Person::players[i]->forwardstogglekeydown = 0;
7546                         if (Person::players[i]->crouchkeydown) {
7547                             //Crouch
7548                             target = -2;
7549                             if (i == 0) {
7550                                 Person::players[i]->superruntoggle = 1;
7551                                 if (Person::players.size() > 1)
7552                                     for (unsigned j = 0; j < Person::players.size(); j++)
7553                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->aitype == passivetype)
7554                                             if (distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 16)
7555                                                 Person::players[i]->superruntoggle = 0;
7556                             }
7557
7558                             if (Person::players.size() > 1)
7559                                 for (unsigned j = 0; j < Person::players.size(); j++) {
7560                                     if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim && Person::players[i]->lowreversaldelay <= 0) {
7561                                         if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7562                                                 Person::players[j]->victim == Person::players[i] &&
7563                                                 (Person::players[j]->animTarget == sweepanim ||
7564                                                  Person::players[j]->animTarget == upunchanim ||
7565                                                  Person::players[j]->animTarget == wolfslapanim ||
7566                                                  ((Person::players[j]->animTarget == swordslashanim ||
7567                                                    Person::players[j]->animTarget == knifeslashstartanim ||
7568                                                    Person::players[j]->animTarget == staffhitanim ||
7569                                                    Person::players[j]->animTarget == staffspinhitanim) &&
7570                                                   distsq(&Person::players[j]->coords, &Person::players[i]->coords) < 2))) {
7571                                             if (target >= 0)
7572                                                 target = -1;
7573                                             else
7574                                                 target = j;
7575                                         }
7576                                     }
7577                                 }
7578                             if (target >= 0)
7579                                 Person::players[target]->Reverse();
7580                             Person::players[i]->lowreversaldelay = .5;
7581
7582                             if (Person::players[i]->isIdle()) {
7583                                 Person::players[i]->setAnimation(Person::players[i]->getCrouch());
7584                                 Person::players[i]->transspeed = 10;
7585                             }
7586                             if (Person::players[i]->isRun() ||
7587                                     (Person::players[i]->isStop() &&
7588                                      (Person::players[i]->leftkeydown ||
7589                                       Person::players[i]->rightkeydown ||
7590                                       Person::players[i]->forwardkeydown ||
7591                                       Person::players[i]->backkeydown))) {
7592                                 Person::players[i]->setAnimation(rollanim);
7593                                 Person::players[i]->transspeed = 20;
7594                             }
7595                         }
7596                         if (!Person::players[i]->crouchkeydown) {
7597                             //Uncrouch
7598                             if (!Person::players[i]->isRun() && Person::players[i]->animTarget != sneakanim && i == 0)
7599                                 Person::players[i]->superruntoggle = 0;
7600                             target = -2;
7601                             if (Person::players[i]->isCrouch()) {
7602                                 if (Person::players.size() > 1)
7603                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7604                                         if (j != i &&
7605                                                 !Person::players[j]->skeleton.free &&
7606                                                 Person::players[j]->victim &&
7607                                                 Person::players[i]->highreversaldelay <= 0) {
7608                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7609                                                     Person::players[j]->victim == Person::players[i] &&
7610                                                     (Person::players[j]->animTarget == spinkickanim) &&
7611                                                     Person::players[i]->isCrouch()) {
7612                                                 if (target >= 0)
7613                                                     target = -1;
7614                                                 else
7615                                                     target = j;
7616                                             }
7617                                         }
7618                                     }
7619                                 if (target >= 0)
7620                                     Person::players[target]->Reverse();
7621                                 Person::players[i]->highreversaldelay = .5;
7622
7623                                 if (Person::players[i]->isCrouch()) {
7624                                     if (!Person::players[i]->wasCrouch()) {
7625                                         Person::players[i]->animCurrent = Person::players[i]->getCrouch();
7626                                         Person::players[i]->frameCurrent = 0;
7627                                     }
7628                                     Person::players[i]->setAnimation(Person::players[i]->getIdle());
7629                                     Person::players[i]->transspeed = 10;
7630                                 }
7631                             }
7632                             if (Person::players[i]->animTarget == sneakanim) {
7633                                 Person::players[i]->setAnimation(Person::players[i]->getIdle());
7634                                 Person::players[i]->transspeed = 10;
7635                             }
7636                         }
7637                         if (Person::players[i]->forwardkeydown) {
7638                             if (Person::players[i]->isIdle() ||
7639                                     (Person::players[i]->isStop() &&
7640                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7641                                     (Person::players[i]->isLanding() &&
7642                                      Person::players[i]->frameTarget > 0 &&
7643                                      !Person::players[i]->jumpkeydown) ||
7644                                     (Person::players[i]->isLandhard() &&
7645                                      Person::players[i]->frameTarget > 0 &&
7646                                      !Person::players[i]->jumpkeydown &&
7647                                      Person::players[i]->crouchkeydown)) {
7648                                 if (Person::players[i]->aitype == passivetype)
7649                                     Person::players[i]->setAnimation(walkanim);
7650                                 else
7651                                     Person::players[i]->setAnimation(Person::players[i]->getRun());
7652                             }
7653                             if (Person::players[i]->isCrouch()) {
7654                                 Person::players[i]->animTarget = sneakanim;
7655                                 if (Person::players[i]->wasCrouch())
7656                                     Person::players[i]->target = 0;
7657                                 Person::players[i]->frameTarget = 0;
7658                             }
7659                             if (Person::players[i]->animTarget == hanganim/*&&(!Person::players[i]->forwardstogglekeydown||Person::players[i]->aitype!=playercontrolled)*/) {
7660                                 Person::players[i]->setAnimation(climbanim);
7661                                 Person::players[i]->frameTarget = 1;
7662                                 Person::players[i]->jumpclimb = 1;
7663                             }
7664                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7665                                 Person::players[i]->velocity += absflatfacing * 5 * multiplier;
7666                             }
7667                             Person::players[i]->forwardstogglekeydown = 1;
7668                             movekey = 1;
7669                         }
7670                         if (Person::players[i]->rightkeydown) {
7671                             if (Person::players[i]->isIdle() ||
7672                                     (Person::players[i]->isStop() &&
7673                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7674                                     (Person::players[i]->isLanding() &&
7675                                      Person::players[i]->frameTarget > 0 &&
7676                                      !Person::players[i]->jumpkeydown) ||
7677                                     (Person::players[i]->isLandhard() &&
7678                                      Person::players[i]->frameTarget > 0 &&
7679                                      !Person::players[i]->jumpkeydown &&
7680                                      Person::players[i]->crouchkeydown)) {
7681                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7682                             }
7683                             if (Person::players[i]->isCrouch()) {
7684                                 Person::players[i]->animTarget = sneakanim;
7685                                 if (Person::players[i]->wasCrouch())
7686                                     Person::players[i]->target = 0;
7687                                 Person::players[i]->frameTarget = 0;
7688                             }
7689                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7690                                 Person::players[i]->velocity += DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
7691                             }
7692                             Person::players[i]->targetyaw -= 90;
7693                             if (Person::players[i]->forwardkeydown)
7694                                 Person::players[i]->targetyaw += 45;
7695                             if (Person::players[i]->backkeydown)
7696                                 Person::players[i]->targetyaw -= 45;
7697                             movekey = 1;
7698                         }
7699                         if ( Person::players[i]->leftkeydown) {
7700                             if (Person::players[i]->isIdle() ||
7701                                     (Person::players[i]->isStop() &&
7702                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7703                                     (Person::players[i]->isLanding() &&
7704                                      Person::players[i]->frameTarget > 0 &&
7705                                      !Person::players[i]->jumpkeydown) ||
7706                                     (Person::players[i]->isLandhard() &&
7707                                      Person::players[i]->frameTarget > 0 &&
7708                                      !Person::players[i]->jumpkeydown &&
7709                                      Person::players[i]->crouchkeydown)) {
7710                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7711                             }
7712                             if (Person::players[i]->isCrouch()) {
7713                                 Person::players[i]->animTarget = sneakanim;
7714                                 if (Person::players[i]->wasCrouch())
7715                                     Person::players[i]->target = 0;
7716                                 Person::players[i]->frameTarget = 0;
7717                             }
7718                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7719                                 Person::players[i]->velocity -= DoRotation(absflatfacing * 5 * multiplier, 0, -90, 0);
7720                             }
7721                             Person::players[i]->targetyaw += 90;
7722                             if (Person::players[i]->forwardkeydown)
7723                                 Person::players[i]->targetyaw -= 45;
7724                             if (Person::players[i]->backkeydown)
7725                                 Person::players[i]->targetyaw += 45;
7726                             movekey = 1;
7727                         }
7728                         if (Person::players[i]->backkeydown) {
7729                             if (Person::players[i]->isIdle() ||
7730                                     (Person::players[i]->isStop() &&
7731                                      Person::players[i]->targetyaw == Person::players[i]->yaw) ||
7732                                     (Person::players[i]->isLanding() &&
7733                                      Person::players[i]->frameTarget > 0 &&
7734                                      !Person::players[i]->jumpkeydown) ||
7735                                     (Person::players[i]->isLandhard() &&
7736                                      Person::players[i]->frameTarget > 0 &&
7737                                      !Person::players[i]->jumpkeydown &&
7738                                      Person::players[i]->crouchkeydown)) {
7739                                 Person::players[i]->setAnimation(Person::players[i]->getRun());
7740                             }
7741                             if (Person::players[i]->isCrouch()) {
7742                                 Person::players[i]->animTarget = sneakanim;
7743                                 if (Person::players[i]->wasCrouch())
7744                                     Person::players[i]->target = 0;
7745                                 Person::players[i]->frameTarget = 0;
7746                             }
7747                             if (Person::players[i]->animTarget == jumpupanim || Person::players[i]->animTarget == jumpdownanim || Person::players[i]->isFlip()) {
7748                                 Person::players[i]->velocity -= absflatfacing * 5 * multiplier;
7749                             }
7750                             if (Person::players[i]->animTarget == hanganim) {
7751                                 Person::players[i]->animCurrent = jumpdownanim;
7752                                 Person::players[i]->animTarget = jumpdownanim;
7753                                 Person::players[i]->target = 0;
7754                                 Person::players[i]->frameCurrent = 0;
7755                                 Person::players[i]->frameTarget = 1;
7756                                 Person::players[i]->velocity = 0;
7757                                 Person::players[i]->velocity.y += gravity;
7758                                 Person::players[i]->coords.y -= 1.4;
7759                                 Person::players[i]->grabdelay = 1;
7760                             }
7761                             if ( !Person::players[i]->leftkeydown && !Person::players[i]->rightkeydown)
7762                                 Person::players[i]->targetyaw += 180;
7763                             movekey = 1;
7764                         }
7765                         if ((Person::players[i]->jumpkeydown && !Person::players[i]->jumpclimb) || Person::players[i]->jumpstart) {
7766                             if ((((Person::players[i]->isLanding() && Person::players[i]->frameTarget >= 3) ||
7767                                     Person::players[i]->isRun() ||
7768                                     Person::players[i]->animTarget == walkanim ||
7769                                     Person::players[i]->isCrouch() ||
7770                                     Person::players[i]->animTarget == sneakanim) &&
7771                                     Person::players[i]->jumppower > 1) &&
7772                                     ((Person::players[i]->animTarget != rabbitrunninganim &&
7773                                       Person::players[i]->animTarget != wolfrunninganim) || i != 0)) {
7774                                 Person::players[i]->jumpstart = 0;
7775                                 Person::players[i]->setAnimation(jumpupanim);
7776                                 Person::players[i]->yaw = Person::players[i]->targetyaw;
7777                                 Person::players[i]->transspeed = 20;
7778                                 Person::players[i]->FootLand(0, 1);
7779                                 Person::players[i]->FootLand(1, 1);
7780
7781                                 facing = 0;
7782                                 facing.z = -1;
7783                                 flatfacing = DoRotation(facing, 0, Person::players[i]->targetyaw + 180, 0);
7784
7785                                 if (movekey)
7786                                     Person::players[i]->velocity = flatfacing * Person::players[i]->speed * 45 * Person::players[i]->scale;
7787                                 if (!movekey)
7788                                     Person::players[i]->velocity = 0;
7789
7790                                 //Dodge sweep?
7791                                 target = -2;
7792                                 if (Person::players.size() > 1)
7793                                     for (unsigned j = 0; j < Person::players.size(); j++) {
7794                                         if (j != i && !Person::players[j]->skeleton.free && Person::players[j]->victim) {
7795                                             if (distsq(&Person::players[j]->coords, &Person::players[j]->victim->coords) < 3 &&
7796                                                     (Person::players[j]->victim == Person::players[i]) &&
7797                                                     (Person::players[j]->animTarget == sweepanim)) {
7798                                                 if (target >= 0)
7799                                                     target = -1;
7800                                                 else
7801                                                     target = j;
7802                                             }
7803                                         }
7804                                     }
7805                                 if (target >= 0)
7806                                     Person::players[i]->velocity.y = 1;
7807                                 else
7808                                     if (Person::players[i]->crouchkeydown || Person::players[i]->aitype != playercontrolled) {
7809                                     Person::players[i]->velocity.y = 7;
7810                                     Person::players[i]->crouchtogglekeydown = 1;
7811                                 } else Person::players[i]->velocity.y = 5;
7812
7813                                 if (mousejump && i == 0 && debugmode) {
7814                                     if (!Person::players[i]->isLanding())
7815                                         Person::players[i]->tempdeltav = deltav;
7816                                     if (Person::players[i]->tempdeltav < 0)
7817                                         Person::players[i]->velocity.y -= (float)(Person::players[i]->tempdeltav) / multiplier / 1000;
7818                                 }
7819
7820                                 Person::players[i]->coords.y += .2;
7821                                 Person::players[i]->jumppower -= 1;
7822
7823                                 if (!i)
7824                                     emit_sound_at(whooshsound, Person::players[i]->coords, 128.);
7825
7826                                 emit_sound_at(jumpsound, Person::players[i]->coords, 128.);
7827                             }
7828                             if ((Person::players[i]->isIdle()) && Person::players[i]->jumppower > 1) {
7829                                 Person::players[i]->setAnimation(Person::players[i]->getLanding());
7830                                 Person::players[i]->frameTarget = 2;
7831                                 Person::players[i]->landhard = 0;
7832                                 Person::players[i]->jumpstart = 1;
7833                                 Person::players[i]->tempdeltav = deltav;
7834                             }
7835                             if (Person::players[i]->animTarget == jumpupanim &&
7836                                     (((!floatjump &&
7837                                        !editorenabled) ||
7838                                       !debugmode) ||
7839                                      Person::players[i]->aitype != playercontrolled)) {
7840                                 if (Person::players[i]->jumppower > multiplier * 6) {
7841                                     Person::players[i]->velocity.y += multiplier * 6;
7842                                     Person::players[i]->jumppower -= multiplier * 6;
7843                                 }
7844                                 if (Person::players[i]->jumppower <= multiplier * 6) {
7845                                     Person::players[i]->velocity.y += Person::players[i]->jumppower;
7846                                     Person::players[i]->jumppower = 0;
7847                                 }
7848                             }
7849                             if (((floatjump || editorenabled) && debugmode) && i == 0)
7850                                 Person::players[i]->velocity.y += multiplier * 30;
7851                         }
7852
7853                         if (!movekey) {
7854                             if (Person::players[i]->isRun() || Person::players[i]->animTarget == walkanim)
7855                                 Person::players[i]->setAnimation(Person::players[i]->getStop());
7856                             if (Person::players[i]->animTarget == sneakanim) {
7857                                 Person::players[i]->animTarget = Person::players[i]->getCrouch();
7858                                 if (Person::players[i]->animCurrent == sneakanim)
7859                                     Person::players[i]->target = 0;
7860                                 Person::players[i]->frameTarget = 0;
7861                             }
7862                         }
7863                         if (Person::players[i]->animTarget == walkanim &&
7864                                 (Person::players[i]->aitype == attacktypecutoff ||
7865                                  Person::players[i]->aitype == searchtype ||
7866                                  (Person::players[i]->aitype == passivetype &&
7867                                   Person::players[i]->numwaypoints <= 1)))
7868                             Person::players[i]->setAnimation(Person::players[i]->getStop());
7869                         if (Person::players[i]->isRun() && (Person::players[i]->aitype == passivetype))
7870                             Person::players[i]->setAnimation(Person::players[i]->getStop());
7871                     }
7872                 }
7873                 if (Person::players[i]->animTarget == rollanim)
7874                     Person::players[i]->targetyaw = oldtargetyaw;
7875             }
7876
7877             //Rotation
7878             for (unsigned k = 0; k < Person::players.size(); k++) {
7879                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 180) {
7880                     if (Person::players[k]->yaw > Person::players[k]->targetyaw)
7881                         Person::players[k]->yaw -= 360;
7882                     else
7883                         Person::players[k]->yaw += 360;
7884                 }
7885
7886                 //stop to turn in right direction
7887                 if (fabs(Person::players[k]->yaw - Person::players[k]->targetyaw) > 90 && (Person::players[k]->isRun() || Person::players[k]->animTarget == walkanim))
7888                     Person::players[k]->setAnimation(Person::players[k]->getStop());
7889
7890                 if (Person::players[k]->animTarget == backhandspringanim || Person::players[k]->animTarget == dodgebackanim)
7891                     Person::players[k]->targettilt = 0;
7892
7893                 if (Person::players[k]->animTarget != jumpupanim &&
7894                         Person::players[k]->animTarget != backhandspringanim &&
7895                         Person::players[k]->animTarget != jumpdownanim &&
7896                         !Person::players[k]->isFlip()) {
7897                     Person::players[k]->targettilt = 0;
7898                     if (Person::players[k]->jumppower < 0 && !Person::players[k]->jumpkeydown)
7899                         Person::players[k]->jumppower = 0;
7900                     Person::players[k]->jumppower += multiplier * 7;
7901                     if (Person::players[k]->isCrouch())
7902                         Person::players[k]->jumppower += multiplier * 7;
7903                     if (Person::players[k]->jumppower > 5)
7904                         Person::players[k]->jumppower = 5;
7905                 }
7906
7907                 if (Person::players[k]->isRun())
7908                     Person::players[k]->targettilt = (Person::players[k]->yaw - Person::players[k]->targetyaw) / 4;
7909
7910                 Person::players[k]->tilt = stepTowardf(Person::players[k]->tilt, Person::players[k]->targettilt, multiplier * 150);
7911                 Person::players[k]->grabdelay -= multiplier;
7912             }
7913
7914             //do animations
7915             for (unsigned k = 0; k < Person::players.size(); k++) {
7916                 Person::players[k]->DoAnimations();
7917                 Person::players[k]->whichpatchx = Person::players[k]->coords.x / (terrain.size / subdivision * terrain.scale);
7918                 Person::players[k]->whichpatchz = Person::players[k]->coords.z / (terrain.size / subdivision * terrain.scale);
7919             }
7920
7921             //do stuff
7922             objects.DoStuff();
7923
7924             for (int j = numenvsounds - 1; j >= 0; j--) {
7925                 envsoundlife[j] -= multiplier;
7926                 if (envsoundlife[j] < 0) {
7927                     numenvsounds--;
7928                     envsoundlife[j] = envsoundlife[numenvsounds];
7929                     envsound[j] = envsound[numenvsounds];
7930                 }
7931             }
7932             if (slomo)
7933                 OPENAL_SetFrequency(OPENAL_ALL, slomofreq);
7934             else
7935                 OPENAL_SetFrequency(OPENAL_ALL, 22050);
7936
7937             if (tutoriallevel == 1) {
7938                 XYZ temp;
7939                 XYZ temp2;
7940                 XYZ temp3;
7941                 XYZ oldtemp;
7942                 XYZ oldtemp2;
7943                 temp.x = 1011;
7944                 temp.y = 84;
7945                 temp.z = 491;
7946                 temp2.x = 1025;
7947                 temp2.y = 75;
7948                 temp2.z = 447;
7949                 temp3.x = 1038;
7950                 temp3.y = 76;
7951                 temp3.z = 453;
7952                 oldtemp = temp;
7953                 oldtemp2 = temp2;
7954                 if (tutorialstage >= 51)
7955                     if (distsq(&temp, &Person::players[0]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[0]->coords) < 4) {
7956                         OPENAL_StopSound(OPENAL_ALL);  // hack...OpenAL renderer isn't stopping music after tutorial goes to level menu...
7957                         OPENAL_SetFrequency(OPENAL_ALL, 0.001);
7958
7959                         emit_stream_np(stream_menutheme);
7960
7961                         gameon = 0;
7962                         mainmenu = 5;
7963
7964                         fireSound();
7965
7966                         flash();
7967                     }
7968                 if (tutorialstage < 51)
7969                     if (distsq(&temp, &Person::players[0]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[0]->coords) < 4) {
7970                         emit_sound_at(fireendsound, Person::players[0]->coords);
7971
7972                         Person::players[0]->coords = (oldtemp + oldtemp2) / 2;
7973
7974                         flash();
7975                     }
7976                 if (tutorialstage >= 14 && tutorialstage < 50)
7977                     if (distsq(&temp, &Person::players[1]->coords) >= distsq(&temp, &temp2) - 1 || distsq(&temp3, &Person::players[1]->coords) < 4) {
7978                         emit_sound_at(fireendsound, Person::players[1]->coords);
7979
7980                         for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
7981                             if (Random() % 2 == 0) {
7982                                 if (!Person::players[1]->skeleton.free)
7983                                     temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
7984                                 if (Person::players[1]->skeleton.free)
7985                                     temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
7986                                 if (!Person::players[1]->skeleton.free)
7987                                     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;
7988                                 if (Person::players[1]->skeleton.free)
7989                                     temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
7990                                 Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
7991                             }
7992                         }
7993
7994                         Person::players[1]->coords = (oldtemp + oldtemp2) / 2;
7995                         for (int i = 0; i < Person::players[1]->skeleton.num_joints; i++) {
7996                             Person::players[1]->skeleton.joints[i].velocity = 0;
7997                             if (Random() % 2 == 0) {
7998                                 if (!Person::players[1]->skeleton.free)
7999                                     temp2 = (Person::players[1]->coords - Person::players[1]->oldcoords) / multiplier / 2; //velocity/2;
8000                                 if (Person::players[1]->skeleton.free)
8001                                     temp2 = Person::players[1]->skeleton.joints[i].velocity * Person::players[1]->scale / 2;
8002                                 if (!Person::players[1]->skeleton.free)
8003                                     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;
8004                                 if (Person::players[1]->skeleton.free)
8005                                     temp = Person::players[1]->skeleton.joints[i].position * Person::players[1]->scale + Person::players[1]->coords;
8006                                 Sprite::MakeSprite(breathsprite, temp, temp2, 1, 1, 1, .6 + (float)abs(Random() % 100) / 200 - .25, 1);
8007                             }
8008                         }
8009                     }
8010             }
8011
8012
8013             //3d sound
8014             static float gLoc[3];
8015             gLoc[0] = viewer.x;
8016             gLoc[1] = viewer.y;
8017             gLoc[2] = viewer.z;
8018             static float vel[3];
8019             vel[0] = (viewer.x - oldviewer.x) / multiplier;
8020             vel[1] = (viewer.y - oldviewer.y) / multiplier;
8021             vel[2] = (viewer.z - oldviewer.z) / multiplier;
8022
8023             //Set orientation with forward and up vectors
8024             static XYZ upvector;
8025             upvector = 0;
8026             upvector.z = -1;
8027
8028             upvector = DoRotation(upvector, -pitch + 90, 0, 0);
8029             upvector = DoRotation(upvector, 0, 0 - yaw, 0);
8030
8031             facing = 0;
8032             facing.z = -1;
8033
8034             facing = DoRotation(facing, -pitch, 0, 0);
8035             facing = DoRotation(facing, 0, 0 - yaw, 0);
8036
8037
8038             static float ori[6];
8039             ori[0] = -facing.x;
8040             ori[1] = facing.y;
8041             ori[2] = -facing.z;
8042             ori[3] = -upvector.x;
8043             ori[4] = upvector.y;
8044             ori[5] = -upvector.z;
8045
8046             OPENAL_3D_Listener_SetAttributes(&gLoc[0], &vel[0], ori[0], ori[1], ori[2], ori[3], ori[4], ori[5]);
8047             OPENAL_Update();
8048
8049             oldviewer = viewer;
8050         }
8051     }
8052
8053     if (Input::isKeyPressed(SDL_SCANCODE_F1))
8054         Screenshot();
8055 }
8056
8057 void Game::TickOnce()
8058 {
8059     if (mainmenu)
8060         yaw += multiplier * 5;
8061     else if (directing || indialogue == -1) {
8062         yaw += deltah * .7;
8063         if (!invertmouse)
8064             pitch += deltav * .7;
8065         if (invertmouse)
8066             pitch -= deltav * .7;
8067         if (pitch > 90)
8068             pitch = 90;
8069         if (pitch < -70)
8070             pitch = -70;
8071     }
8072 }
8073
8074 void Game::TickOnceAfter()
8075 {
8076     static XYZ colviewer;
8077     static XYZ coltarget;
8078     static XYZ target;
8079     static XYZ col;
8080     static XYZ facing;
8081     static float changedelay;
8082     static bool alldead;
8083     static float unseendelay;
8084     static float cameraspeed;
8085
8086     if (!mainmenu) {
8087         static int oldmusictype = musictype;
8088
8089         if (environment == snowyenvironment)
8090             leveltheme = stream_snowtheme;
8091         if (environment == grassyenvironment)
8092             leveltheme = stream_grasstheme;
8093         if (environment == desertenvironment)
8094             leveltheme = stream_deserttheme;
8095
8096         realthreat = 0;
8097
8098         musictype = leveltheme;
8099         for (unsigned i = 0; i < Person::players.size(); i++) {
8100             if ((Person::players[i]->aitype == attacktypecutoff ||
8101                     Person::players[i]->aitype == getweapontype ||
8102                     Person::players[i]->aitype == gethelptype ||
8103                     Person::players[i]->aitype == searchtype) &&
8104                     !Person::players[i]->dead/*&&Person::players[i]->surprised<=0*/ &&
8105                     (Person::players[i]->animTarget != sneakattackedanim &&
8106                      Person::players[i]->animTarget != knifesneakattackedanim &&
8107                      Person::players[i]->animTarget != swordsneakattackedanim)) {
8108                 musictype = stream_fighttheme;
8109                 realthreat = 1;
8110             }
8111         }
8112         if (Person::players[0]->dead)
8113             musictype = stream_menutheme;
8114
8115
8116         if (musictype == stream_fighttheme)
8117             unseendelay = 1;
8118
8119         if (oldmusictype == stream_fighttheme && musictype != stream_fighttheme) {
8120             unseendelay -= multiplier;
8121             if (unseendelay > 0)
8122                 musictype = stream_fighttheme;
8123         }
8124
8125
8126         if (loading == 2) {
8127             musictype = stream_menutheme;
8128             musicvolume[2] = 512;
8129             musicvolume[0] = 0;
8130             musicvolume[1] = 0;
8131             musicvolume[3] = 0;
8132         }
8133
8134         if (musictoggle)
8135             if (musictype != oldmusictype && musictype == stream_fighttheme)
8136                 emit_sound_np(alarmsound);
8137         musicselected = musictype;
8138
8139         if (musicselected == leveltheme)
8140             musicvolume[0] += multiplier * 450;
8141         else
8142             musicvolume[0] -= multiplier * 450;
8143         if (musicselected == stream_fighttheme)
8144             musicvolume[1] += multiplier * 450;
8145         else
8146             musicvolume[1] -= multiplier * 450;
8147         if (musicselected == stream_menutheme)
8148             musicvolume[2] += multiplier * 450;
8149         else
8150             musicvolume[2] -= multiplier * 450;
8151
8152         for (int i = 0; i < 3; i++) {
8153             if (musicvolume[i] < 0)
8154                 musicvolume[i] = 0;
8155             if (musicvolume[i] > 512)
8156                 musicvolume[i] = 512;
8157         }
8158
8159         if (musicvolume[2] > 128 && !loading && !mainmenu)
8160             musicvolume[2] = 128;
8161
8162         if (musictoggle) {
8163             if (musicvolume[0] > 0 && oldmusicvolume[0] <= 0)
8164                 emit_stream_np(leveltheme, musicvolume[0]);
8165             if (musicvolume[1] > 0 && oldmusicvolume[1] <= 0)
8166                 emit_stream_np(stream_fighttheme, musicvolume[1]);
8167             if (musicvolume[2] > 0 && oldmusicvolume[2] <= 0)
8168                 emit_stream_np(stream_menutheme, musicvolume[2]);
8169             if (musicvolume[0] <= 0 && oldmusicvolume[0] > 0)
8170                 pause_sound(leveltheme);
8171             if (musicvolume[1] <= 0 && oldmusicvolume[1] > 0)
8172                 pause_sound(stream_fighttheme);
8173             if (musicvolume[2] <= 0 && oldmusicvolume[2] > 0)
8174                 pause_sound(stream_menutheme);
8175
8176             if (musicvolume[0] != oldmusicvolume[0])
8177                 OPENAL_SetVolume(channels[leveltheme], musicvolume[0]);
8178             if (musicvolume[1] != oldmusicvolume[1])
8179                 OPENAL_SetVolume(channels[stream_fighttheme], musicvolume[1]);
8180             if (musicvolume[2] != oldmusicvolume[2])
8181                 OPENAL_SetVolume(channels[stream_menutheme], musicvolume[2]);
8182
8183             for (int i = 0; i < 3; i++)
8184                 oldmusicvolume[i] = musicvolume[i];
8185         } else {
8186             pause_sound(leveltheme);
8187             pause_sound(stream_fighttheme);
8188             pause_sound(stream_menutheme);
8189
8190             for (int i = 0; i < 4; i++) {
8191                 oldmusicvolume[i] = 0;
8192                 musicvolume[i] = 0;
8193             }
8194         }
8195
8196         killhotspot = 2;
8197         for (int i = 0; i < numhotspots; i++) {
8198             if (hotspottype[i] > 10 && hotspottype[i] < 20) {
8199                 if (Person::players[hotspottype[i] - 10]->dead == 0)
8200                     killhotspot = 0;
8201                 else if (killhotspot == 2)
8202                     killhotspot = 1;
8203             }
8204         }
8205         if (killhotspot == 2)
8206             killhotspot = 0;
8207
8208
8209         winhotspot = false;
8210         for (int i = 0; i < numhotspots; i++)
8211             if (hotspottype[i] == -1)
8212                 if (distsq(&Person::players[0]->coords, &hotspot[i]) < hotspotsize[i])
8213                     winhotspot = true;
8214
8215         int numalarmed = 0;
8216         for (unsigned i = 1; i < Person::players.size(); i++)
8217             if (!Person::players[i]->dead && Person::players[i]->aitype == attacktypecutoff && Person::players[i]->surprised <= 0)
8218                 numalarmed++;
8219         if (numalarmed > maxalarmed)
8220             maxalarmed = numalarmed;
8221
8222         if (changedelay <= 0 && !loading && !editorenabled && gameon && !tutoriallevel && changedelay != -999 && !won) {
8223             if (Person::players[0]->dead && changedelay <= 0) {
8224                 changedelay = 1;
8225                 targetlevel = whichlevel;
8226             }
8227             alldead = true;
8228             for (unsigned i = 1; i < Person::players.size(); i++) {
8229                 if (!Person::players[i]->dead && Person::players[i]->howactive < typedead1) {
8230                     alldead = false;
8231                     break;
8232                 }
8233             }
8234
8235
8236             if (alldead && !Person::players[0]->dead && maptype == mapkilleveryone) {
8237                 changedelay = 1;
8238                 targetlevel = whichlevel + 1;
8239                 if (targetlevel > numchallengelevels - 1)
8240                     targetlevel = 0;
8241             }
8242             if (winhotspot || windialogue) {
8243                 changedelay = 0.1;
8244                 targetlevel = whichlevel + 1;
8245                 if (targetlevel > numchallengelevels - 1)
8246                     targetlevel = 0;
8247             }
8248
8249
8250             if (killhotspot) {
8251                 changedelay = 1;
8252                 targetlevel = whichlevel + 1;
8253                 if (targetlevel > numchallengelevels - 1)
8254                     targetlevel = 0;
8255             }
8256
8257             if (changedelay > 0 && !Person::players[0]->dead && !won) {
8258                 //high scores, awards, win
8259                 if (campaign) {
8260                     accountactive->winCampaignLevel(whichchoice, bonustotal, leveltime);
8261                     scoreadded = 1;
8262                 } else {
8263                     accountactive->winLevel(whichlevel, bonustotal - startbonustotal, leveltime);
8264                 }
8265                 won = 1;
8266             }
8267         }
8268
8269         if (!winfreeze) {
8270
8271             if (leveltime < 1) {
8272                 loading = 0;
8273                 changedelay = .1;
8274                 alldead = false;
8275                 winhotspot = false;
8276                 killhotspot = 0;
8277             }
8278
8279             if (!editorenabled && gameon && !mainmenu) {
8280                 if (changedelay != -999)
8281                     changedelay -= multiplier / 7;
8282                 if (Person::players[0]->dead)
8283                     targetlevel = whichlevel;
8284                 if (loading == 2 && !campaign) {
8285                     flash();
8286
8287                     fireSound(firestartsound);
8288
8289                     if (!Person::players[0]->dead && targetlevel != whichlevel)
8290                         startbonustotal = bonustotal;
8291                     if (Person::players[0]->dead)
8292                         Loadlevel(whichlevel);
8293                     else
8294                         Loadlevel(targetlevel);
8295
8296                     fireSound();
8297
8298                     loading = 3;
8299                 }
8300                 if (loading == 2 && targetlevel == whichlevel) {
8301                     flash();
8302                     loadtime = 0;
8303
8304                     fireSound(firestartsound);
8305
8306                     Loadlevel(campaignlevels[accountactive->getCampaignChoicesMade()].mapname.c_str());
8307
8308                     fireSound();
8309
8310                     loading = 3;
8311                 }
8312                 if (changedelay <= -999 &&
8313                         whichlevel != -2 &&
8314                         !loading &&
8315                         (Person::players[0]->dead ||
8316                          (alldead && maptype == mapkilleveryone) ||
8317                          (winhotspot) ||
8318                          (killhotspot)))
8319                     loading = 1;
8320                 if ((Person::players[0]->dead ||
8321                         (alldead && maptype == mapkilleveryone) ||
8322                         (winhotspot) ||
8323                         (windialogue) ||
8324                         (killhotspot)) &&
8325                         changedelay <= 0) {
8326                     if (whichlevel != -2 && !loading && !Person::players[0]->dead) {
8327                         winfreeze = true;
8328                         changedelay = -999;
8329                     }
8330                     if (Person::players[0]->dead)
8331                         loading = 1;
8332                 }
8333             }
8334
8335             if (campaign) {
8336                 // campaignchoosenext determines what to do when the level is complete:
8337                 // 0 = load next level
8338                 // 1 = go back to level select screen
8339                 // 2 = stealthload next level
8340                 if (mainmenu == 0 && winfreeze && (campaignlevels[actuallevel].choosenext) == 1) {
8341                     if (campaignlevels[actuallevel].nextlevel.empty())
8342                         endgame = 1;
8343                 } else if (mainmenu == 0 && winfreeze) {
8344                     stealthloading = (campaignlevels[actuallevel].choosenext == 2);
8345
8346                     if (!stealthloading) {
8347                         fireSound(firestartsound);
8348
8349                         flash();
8350                     }
8351
8352                     startbonustotal = 0;
8353
8354                     LoadCampaign();
8355
8356                     loading = 2;
8357                     loadtime = 0;
8358                     targetlevel = 7;
8359                     if (!firstload)
8360                         LoadStuff();
8361                     whichchoice = 0;
8362                     actuallevel = campaignlevels[actuallevel].nextlevel.front();
8363                     visibleloading = 1;
8364                     stillloading = 1;
8365                     Loadlevel(campaignlevels[actuallevel].mapname.c_str());
8366                     campaign = 1;
8367                     mainmenu = 0;
8368                     gameon = 1;
8369                     pause_sound(stream_menutheme);
8370
8371                     stealthloading = 0;
8372                 }
8373             }
8374
8375             if (loading == 3)
8376                 loading = 0;
8377
8378         }
8379
8380         oldmusictype = musictype;
8381     }
8382
8383     facing = 0;
8384     facing.z = -1;
8385
8386     facing = DoRotation(facing, -pitch, 0, 0);
8387     facing = DoRotation(facing, 0, 0 - yaw, 0);
8388     viewerfacing = facing;
8389
8390     if (!cameramode) {
8391         if ((animation[Person::players[0]->animTarget].attack != 3 && animation[Person::players[0]->animCurrent].attack != 3) || Person::players[0]->skeleton.free)
8392             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;
8393         else
8394             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;
8395         target.y += .1;
8396         if (Person::players[0]->skeleton.free) {
8397             for (int i = 0; i < Person::players[0]->skeleton.num_joints; i++) {
8398                 if (Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y > target.y)
8399                     target.y = Person::players[0]->skeleton.joints[i].position.y * Person::players[0]->scale + Person::players[0]->coords.y;
8400             }
8401             target.y += .1;
8402         }
8403         if (Person::players[0]->skeleton.free != 2/*&&!autocam*/) {
8404             cameraspeed = 20;
8405             if (findLengthfast(&Person::players[0]->velocity) > 400) {
8406                 cameraspeed = 20 + (findLength(&Person::players[0]->velocity) - 20) * .96;
8407             }
8408             if (Person::players[0]->skeleton.free == 0 && Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim)
8409                 target.y += 1.4;
8410             coltarget = target - cameraloc;
8411             if (findLengthfast(&coltarget) < multiplier * multiplier * 400)
8412                 cameraloc = target;
8413             else {
8414                 Normalise(&coltarget);
8415                 if (Person::players[0]->animTarget != hanganim && Person::players[0]->animTarget != climbanim && Person::players[0]->animCurrent != climbanim && Person::players[0]->currentoffset.x == 0)
8416                     cameraloc = cameraloc + coltarget * multiplier * cameraspeed;
8417                 else
8418                     cameraloc = cameraloc + coltarget * multiplier * 8;
8419             }
8420             if (editorenabled)
8421                 cameraloc = target;
8422             cameradist += multiplier * 5;
8423             if (cameradist > 2.3)
8424                 cameradist = 2.3;
8425             viewer = cameraloc - facing * cameradist;
8426             colviewer = viewer;
8427             coltarget = cameraloc;
8428             objects.SphereCheckPossible(&colviewer, findDistance(&colviewer, &coltarget));
8429             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8430                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
8431                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8432                     colviewer = viewer;
8433                     coltarget = cameraloc;
8434                     if (objects.model[i].LineCheckPossible(&colviewer, &coltarget, &col, &objects.position[i], &objects.yaw[i]) != -1)
8435                         viewer = col;
8436                 }
8437             if (terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8438                 for (int j = 0; j < terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz]; j++) {
8439                     int i = terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8440                     colviewer = viewer;
8441                     if (objects.model[i].SphereCheck(&colviewer, .15, &col, &objects.position[i], &objects.yaw[i]) != -1) {
8442                         viewer = colviewer;
8443                     }
8444                 }
8445             cameradist = findDistance(&viewer, &target);
8446             viewer.y = max((double)viewer.y, terrain.getHeight(viewer.x, viewer.z) + .6);
8447             if (cameraloc.y < terrain.getHeight(cameraloc.x, cameraloc.z)) {
8448                 cameraloc.y = terrain.getHeight(cameraloc.x, cameraloc.z);
8449             }
8450         }
8451         /*
8452         //what did autocam do?
8453         if(Person::players[0]->skeleton.free!=2&&autocam){
8454             cameraspeed=20;
8455             if(findLengthfast(&Person::players[0]->velocity)>400){
8456                 cameraspeed=20+(findLength(&Person::players[0]->velocity)-20)*.96;
8457             }
8458             if(Person::players[0]->skeleton.free==0&&Person::players[0]->animTarget!=hanganim&&Person::players[0]->animTarget!=climbanim)target.y+=1.4;
8459             cameradist+=multiplier*5;
8460             if(cameradist>3.3)cameradist=3.3;
8461             coltarget=target-cameraloc;
8462             if(findLengthfast(&coltarget)<multiplier*multiplier*400)cameraloc=target;
8463             else if(findLengthfast(&coltarget)>1)
8464             {
8465                 Normalise(&coltarget);
8466                 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;
8467                 else cameraloc=cameraloc+coltarget*multiplier*8;
8468             }
8469             if(editorenabled)cameraloc=target;
8470             viewer=cameraloc;
8471             colviewer=viewer;
8472             coltarget=cameraloc;
8473             objects.SphereCheckPossible(&colviewer, findDistance(&colviewer,&coltarget));
8474             if(terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8475                 for(int j=0;j<terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz];j++){
8476                     int i=terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8477                     colviewer=viewer;
8478                     coltarget=cameraloc;
8479                     if(objects.model[i].LineCheckPossible(&colviewer,&coltarget,&col,&objects.position[i],&objects.yaw[i])!=-1)viewer=col;
8480                 }
8481             if(terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz])
8482                 for(int j=0;j<terrain.patchobjectnum[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz];j++){
8483                     int i=terrain.patchobjects[Person::players[0]->whichpatchx][Person::players[0]->whichpatchz][j];
8484                     colviewer=viewer;
8485                     if(objects.model[i].SphereCheck(&colviewer,.15,&col,&objects.position[i],&objects.yaw[i])!=-1){
8486                         viewer=colviewer;
8487                     }
8488                 }
8489             cameradist=findDistance(&viewer,&target);
8490             viewer.y=max((double)viewer.y,terrain.getHeight(viewer.x,viewer.z)+.6);
8491             if(cameraloc.y<terrain.getHeight(cameraloc.x,cameraloc.z)){
8492                 cameraloc.y=terrain.getHeight(cameraloc.x,cameraloc.z);
8493             }
8494         }
8495         */
8496         if (camerashake > .8)
8497             camerashake = .8;
8498         //if(woozy>10)woozy=10;
8499         //woozy+=multiplier;
8500         woozy += multiplier;
8501         if (Person::players[0]->dead)
8502             camerashake = 0;
8503         if (Person::players[0]->dead)
8504             woozy = 0;
8505         camerashake -= multiplier * 2;
8506         blackout -= multiplier * 2;
8507         //if(Person::players[0]->isCrouch())woozy-=multiplier*8;
8508         if (camerashake < 0)
8509             camerashake = 0;
8510         if (blackout < 0)
8511             blackout = 0;
8512         //if(woozy<0)woozy=0;
8513         if (camerashake) {
8514             viewer.x += (float)(Random() % 100) * .0005 * camerashake;
8515             viewer.y += (float)(Random() % 100) * .0005 * camerashake;
8516             viewer.z += (float)(Random() % 100) * .0005 * camerashake;
8517         }
8518     }
8519 }
8520