]> git.jsancho.org Git - lugaru.git/blobdiff - Source/GameTick.cpp
merge
[lugaru.git] / Source / GameTick.cpp
index 2c357a5eb8f04fc0efbb9c3712bcbf9e83290f12..8010f4f265d014dec90a00ff7afec107f47f575c 100644 (file)
@@ -30,6 +30,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include <ctime>
 #include "Game.h"
 #include "openal_wrapper.h"
+#include "Settings.h"
 
 using namespace std;
 
@@ -222,18 +223,969 @@ extern float accountcampaigntime[10];
 
 extern int accountcampaignchoicesmade[10];
 extern int accountcampaignchoices[10][5000];
-/********************> Tick() <*****/
+
+static const char *rabbitskin[] = {
+":Data:Textures:Fur3.jpg",
+":Data:Textures:Fur.jpg",
+":Data:Textures:Fur2.jpg",
+":Data:Textures:Lynx.jpg",
+":Data:Textures:Otter.jpg",
+":Data:Textures:Opal.jpg",
+":Data:Textures:Sable.jpg",
+":Data:Textures:Chocolate.jpg",
+":Data:Textures:BW2.jpg",
+":Data:Textures:WB2.jpg"
+};
+
+static const char *wolfskin[] = {
+":Data:Textures:Wolf.jpg",
+":Data:Textures:Darkwolf.jpg",
+":Data:Textures:Snowwolf.jpg"
+};
+
+#define STATIC_ASSERT(x) extern int s_a_dummy[2 * (!!(x)) - 1];
+STATIC_ASSERT (rabbittype == 0 && wolftype == 1)
+
+static const char **creatureskin[] = {rabbitskin, wolfskin};
+
+/* Return true if PFX is a prefix of STR (case-insensitive).  */
+static bool stripfx(const char *str, const char *pfx)
+{
+  return !strncasecmp(str, pfx, strlen(pfx));
+}
+
 extern OPENAL_STREAM * strm[20];
 extern "C"     void PlaySoundEx(int channel, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused);
 extern "C" void PlayStreamEx(int chan, OPENAL_STREAM *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused);
 
+
+static const char *cmd_names[] = {
+#define DECLARE_COMMAND(cmd) #cmd " ",
+#include "ConsoleCmds.h"
+#undef  DECLARE_COMMAND
+};
+
+typedef void (*console_handler)(Game *game, const char *args);
+
+#define DECLARE_COMMAND(cmd) static void ch_##cmd(Game *game, const char *args);
+#include "ConsoleCmds.h"
+#undef  DECLARE_COMMAND
+
+static console_handler cmd_handlers[] = {
+#define DECLARE_COMMAND(cmd) ch_##cmd,
+#include "ConsoleCmds.h"
+#undef  DECLARE_COMMAND
+};
+
+static void ch_quit(Game *game, const char *args)
+{
+  game->tryquit = 1;
+}
+
+static void ch_map(Game *game, const char *args)
+{
+  char buf[64];
+  snprintf(buf, 63, ":Data:Maps:%s", args);
+  game->Loadlevel(buf);
+  game->whichlevel = -2;
+  campaign = 0;
+}
+
+static void ch_save(Game *game, const char *args)
+{
+  char buf[64];
+  int i, j, k, l, m, templength;
+  float headprop, bodyprop, armprop, legprop;
+  snprintf(buf, 63, ":Data:Maps:%s", args);
+
+
+  int mapvers = 12;;
+
+  FILE                 *tfile;
+  tfile=fopen( ConvertFileName(buf), "wb" );
+  fpackf(tfile, "Bi", mapvers);
+  fpackf(tfile, "Bi", maptype);
+  fpackf(tfile, "Bi", hostile);
+  fpackf(tfile, "Bf Bf", viewdistance, fadestart);
+  fpackf(tfile, "Bb Bf Bf Bf", skyboxtexture, skyboxr, skyboxg, skyboxb);
+  fpackf(tfile, "Bf Bf Bf", skyboxlightr, skyboxlightg, skyboxlightb);
+  fpackf(tfile, "Bf Bf Bf Bf Bf Bi", player[0].coords.x, player[0].coords.y, player[0].coords.z, player[0].rotation, player[0].targetrotation, player[0].num_weapons);
+  if(player[0].num_weapons>0&&player[0].num_weapons<5)
+    for(j=0;j<player[0].num_weapons;j++){
+      fpackf(tfile, "Bi", weapons.type[player[0].weaponids[j]]);
+    }
+
+  fpackf(tfile, "Bf Bf Bf", player[0].armorhead, player[0].armorhigh, player[0].armorlow);
+  fpackf(tfile, "Bf Bf Bf", player[0].protectionhead, player[0].protectionhigh, player[0].protectionlow);
+  fpackf(tfile, "Bf Bf Bf", player[0].metalhead, player[0].metalhigh, player[0].metallow);
+  fpackf(tfile, "Bf Bf", player[0].power, player[0].speedmult);
+
+  fpackf(tfile, "Bi", player[0].numclothes);
+
+  fpackf(tfile, "Bi Bi", player[0].whichskin, player[0].creature);
+
+  fpackf(tfile, "Bi", numdialogues);
+  if(numdialogues)
+    for(k=0;k<numdialogues;k++){
+      fpackf(tfile, "Bi", numdialogueboxes[k]);
+      fpackf(tfile, "Bi", dialoguetype[k]);
+      for(l=0;l<10;l++){
+       fpackf(tfile, "Bf Bf Bf", participantlocation[k][l].x, participantlocation[k][l].y, participantlocation[k][l].z);
+       fpackf(tfile, "Bf", participantrotation[k][l]);
+      }
+      if(numdialogueboxes)
+       for(l=0;l<numdialogueboxes[k];l++){
+         fpackf(tfile, "Bi", dialogueboxlocation[k][l]);
+         fpackf(tfile, "Bf", dialogueboxcolor[k][l][0]);
+         fpackf(tfile, "Bf", dialogueboxcolor[k][l][1]);
+         fpackf(tfile, "Bf", dialogueboxcolor[k][l][2]);
+         fpackf(tfile, "Bi", dialogueboxsound[k][l]);
+
+         templength=strlen(dialoguetext[k][l]);
+         fpackf(tfile, "Bi",(templength));
+         for(m=0;m<templength;m++){
+           fpackf(tfile, "Bb", dialoguetext[k][l][m]);
+           if(dialoguetext[k][l][m]=='\0')break;
+         }
+
+         templength=strlen(dialoguename[k][l]);
+         fpackf(tfile, "Bi",templength);
+         for(m=0;m<templength;m++){
+           fpackf(tfile, "Bb", dialoguename[k][l][m]);
+           if(dialoguename[k][l][m]=='\0')break;
+         }
+
+         fpackf(tfile, "Bf Bf Bf", dialoguecamera[k][l].x, dialoguecamera[k][l].y, dialoguecamera[k][l].z);
+         fpackf(tfile, "Bi", participantfocus[k][l]);
+         fpackf(tfile, "Bi", participantaction[k][l]);
+
+         for(m=0;m<10;m++)
+           fpackf(tfile, "Bf Bf Bf", participantfacing[k][l][m].x, participantfacing[k][l][m].y, participantfacing[k][l][m].z);
+
+         fpackf(tfile, "Bf Bf",dialoguecamerarotation[k][l],dialoguecamerarotation2[k][l]);
+       }
+    }
+
+  if(player[0].numclothes)
+    for(k=0;k<player[0].numclothes;k++){
+      templength=strlen(player[0].clothes[k]);
+      fpackf(tfile, "Bi", templength);
+      for(l=0;l<templength;l++)
+       fpackf(tfile, "Bb", player[0].clothes[k][l]);
+      fpackf(tfile, "Bf Bf Bf", player[0].clothestintr[k], player[0].clothestintg[k], player[0].clothestintb[k]);
+    }
+
+  fpackf(tfile, "Bi", environment);
+
+  fpackf(tfile, "Bi", objects.numobjects);
+
+  if(objects.numobjects)
+    for(k=0;k<objects.numobjects;k++){
+      fpackf(tfile, "Bi Bf Bf Bf Bf Bf Bf", objects.type[k], objects.rotation[k], objects.rotation2[k], objects.position[k].x, objects.position[k].y, objects.position[k].z, objects.scale[k]);
+    }
+
+  fpackf(tfile, "Bi", numhotspots);
+  if(numhotspots)
+    for(i=0;i<numhotspots;i++){
+      fpackf(tfile, "Bi Bf Bf Bf Bf", hotspottype[i],hotspotsize[i],hotspot[i].x,hotspot[i].y,hotspot[i].z);
+      templength=strlen(hotspottext[i]);
+      fpackf(tfile, "Bi",templength);
+      for(l=0;l<templength;l++)
+       fpackf(tfile, "Bb", hotspottext[i][l]);
+    }
+
+  fpackf(tfile, "Bi", numplayers);
+  if(numplayers>1&&numplayers<maxplayers)
+    for(j=1;j<numplayers;j++){
+      fpackf(tfile, "Bi Bi Bf Bf Bf Bi Bi Bf Bb Bf", player[j].whichskin, player[j].creature, player[j].coords.x, player[j].coords.y, player[j].coords.z, player[j].num_weapons, player[j].howactive, player[j].scale, player[j].immobile, player[j].rotation);
+      if(player[j].num_weapons>0&&player[j].num_weapons<5)
+       for(k=0;k<player[j].num_weapons;k++){
+         fpackf(tfile, "Bi", weapons.type[player[j].weaponids[k]]);
+       }
+      if(player[j].numwaypoints<30){
+       fpackf(tfile, "Bi", player[j].numwaypoints);
+       for(k=0;k<player[j].numwaypoints;k++){
+         fpackf(tfile, "Bf", player[j].waypoints[k].x);
+         fpackf(tfile, "Bf", player[j].waypoints[k].y);
+         fpackf(tfile, "Bf", player[j].waypoints[k].z);
+         fpackf(tfile, "Bi", player[j].waypointtype[k]);
+       }
+       fpackf(tfile, "Bi", player[j].waypoint);
+      }
+      else{
+       player[j].numwaypoints=0;
+       player[j].waypoint=0;
+       fpackf(tfile, "Bi Bi Bi", player[j].numwaypoints, player[j].waypoint, player[j].waypoint);
+      }
+
+      fpackf(tfile, "Bf Bf Bf", player[j].armorhead, player[j].armorhigh, player[j].armorlow);
+      fpackf(tfile, "Bf Bf Bf", player[j].protectionhead, player[j].protectionhigh, player[j].protectionlow);
+      fpackf(tfile, "Bf Bf Bf", player[j].metalhead, player[j].metalhigh, player[j].metallow);
+      fpackf(tfile, "Bf Bf", player[j].power, player[j].speedmult);
+
+      if(player[j].creature==wolftype){
+       headprop=player[j].proportionhead.x/1.1;
+       bodyprop=player[j].proportionbody.x/1.1;
+       armprop=player[j].proportionarms.x/1.1;
+       legprop=player[j].proportionlegs.x/1.1;
+      }
+
+      if(player[j].creature==rabbittype){
+       headprop=player[j].proportionhead.x/1.2;
+       bodyprop=player[j].proportionbody.x/1.05;
+       armprop=player[j].proportionarms.x/1.00;
+       legprop=player[j].proportionlegs.x/1.1;
+      }
+
+      fpackf(tfile, "Bf Bf Bf Bf", headprop, bodyprop, armprop, legprop);
+
+
+
+      fpackf(tfile, "Bi", player[j].numclothes);
+      if(player[j].numclothes)
+       for(k=0;k<player[j].numclothes;k++){
+         int templength;
+         templength=strlen(player[j].clothes[k]);
+         fpackf(tfile, "Bi", templength);
+         for(l=0;l<templength;l++)
+           fpackf(tfile, "Bb", player[j].clothes[k][l]);
+         fpackf(tfile, "Bf Bf Bf", player[j].clothestintr[k], player[j].clothestintg[k], player[j].clothestintb[k]);
+       }
+    }
+
+  fpackf(tfile, "Bi", game->numpathpoints);
+  if(game->numpathpoints)
+    for(j=0;j<game->numpathpoints;j++){
+      fpackf(tfile, "Bf Bf Bf Bi", game->pathpoint[j].x, game->pathpoint[j].y, game->pathpoint[j].z, game->numpathpointconnect[j]);
+      for(k=0;k<game->numpathpointconnect[j];k++){
+       fpackf(tfile, "Bi", game->pathpointconnect[j][k]);
+      }
+    }
+
+  fpackf(tfile, "Bf Bf Bf Bf", game->mapcenter.x, game->mapcenter.y, game->mapcenter.z, game->mapradius);
+
+  fclose(tfile);
+}
+
+static void ch_cellar(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:Furdarko.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_tint(Game *game, const char *args)
+{
+  sscanf(args, "%f%f%f", &tintr, &tintg, &tintb);
+}
+
+static void ch_tintr(Game *game, const char *args)
+{
+  tintr = atof(args);
+}
+
+static void ch_tintg(Game *game, const char *args)
+{
+  tintg = atof(args);
+}
+
+static void ch_tintb(Game *game, const char *args)
+{
+  tintb = atof(args);
+}
+
+static void ch_speed(Game *game, const char *args)
+{
+  player[0].speedmult = atof(args);
+}
+
+static void ch_strength(Game *game, const char *args)
+{
+  player[0].power = atof(args);
+}
+
+static void ch_power(Game *game, const char *args)
+{
+  player[0].power = atof(args);
+}
+
+static void ch_size(Game *game, const char *args)
+{
+  player[0].scale = atof(args) * .2;
+}
+
+static int find_closest()
+{
+  int closest = 0;
+  float closestdist = 1.0/0.0;
+
+  for (int i = 1; i < numplayers; i++) {
+    float distance;
+    distance = findDistancefast(&player[i].coords,&player[0].coords);
+    if (distance < closestdist) {
+      closestdist = distance;
+      closest = i;
+    }
+  }
+  return closest;
+}
+
+static void ch_sizenear(Game *game, const char *args)
+{
+  int closest = find_closest();
+
+  if (closest)
+    player[closest].scale = atof(args) * .2;
+}
+
+static void set_proportion(int pnum, const char *args)
+{
+  float headprop,bodyprop,armprop,legprop;
+
+  sscanf(args, "%f%f%f%f", &headprop, &bodyprop, &armprop, &legprop);
+
+  if(player[pnum].creature==wolftype){
+    player[pnum].proportionhead=1.1*headprop;
+    player[pnum].proportionbody=1.1*bodyprop;
+    player[pnum].proportionarms=1.1*armprop;
+    player[pnum].proportionlegs=1.1*legprop;
+  }
+
+  if(player[pnum].creature==rabbittype){
+    player[pnum].proportionhead=1.2*headprop;
+    player[pnum].proportionbody=1.05*bodyprop;
+    player[pnum].proportionarms=1.00*armprop;
+    player[pnum].proportionlegs=1.1*legprop;
+    player[pnum].proportionlegs.y=1.05*legprop;
+  }
+}
+
+static void ch_proportion(Game *game, const char *args)
+{
+  set_proportion(0, args);
+}
+
+static void ch_proportionnear(Game *game, const char *args)
+{
+  int closest = find_closest();
+  if (closest)
+    set_proportion(closest, args);
+}
+
+static void set_protection(int pnum, const char *args)
+{
+  float head, high, low;
+  sscanf(args, "%f%f%f", &head, &high, &low);
+
+  player[pnum].protectionhead = head;
+  player[pnum].protectionhigh = high;
+  player[pnum].protectionlow  = low;
+}
+
+static void ch_protection(Game *game, const char *args)
+{
+  set_protection(0, args);
+}
+
+static void ch_protectionnear(Game *game, const char *args)
+{
+  int closest = find_closest();
+  if (closest)
+    set_protection(closest, args);
+}
+
+static void set_armor(int pnum, const char *args)
+{
+  float head, high, low;
+  sscanf(args, "%f%f%f", &head, &high, &low);
+
+  player[pnum].armorhead = head;
+  player[pnum].armorhigh = high;
+  player[pnum].armorlow  = low;
+}
+
+static void ch_armor(Game *game, const char *args)
+{
+  set_armor(0, args);
+}
+
+static void ch_armornear(Game *game, const char *args)
+{
+  int closest = find_closest();
+  if (closest)
+    set_armor(closest, args);
+}
+
+static void ch_protectionreset(Game *game, const char *args)
+{
+  set_protection(0, "1 1 1");
+  set_armor(0, "1 1 1");
+}
+
+static void set_metal(int pnum, const char *args)
+{
+  float head, high, low;
+  sscanf(args, "%f%f%f", &head, &high, &low);
+
+  player[pnum].metalhead = head;
+  player[pnum].metalhigh = high;
+  player[pnum].metallow  = low;
+}
+
+static void ch_metal(Game *game, const char *args)
+{
+  set_metal(0, args);
+}
+
+static void set_noclothes(int pnum, Game *game, const char *args)
+{
+  player[pnum].numclothes = 0;
+  game->LoadTextureSave(creatureskin[player[pnum].creature][player[pnum].whichskin],
+                       &player[pnum].skeleton.drawmodel.textureptr,1,
+                       &player[pnum].skeleton.skinText[0],&player[pnum].skeleton.skinsize);
+}
+
+static void ch_noclothes(Game *game, const char *args)
+{
+  set_noclothes(0, game, args);
+}
+
+static void ch_noclothesnear(Game *game, const char *args)
+{
+  int closest = find_closest();
+  if (closest)
+    set_noclothes(closest, game, args);
+}
+
+
+static void set_clothes(int pnum, Game *game, const char *args)
+{
+  char buf[64];
+  snprintf(buf, 63, ":Data:Textures:%s.png", args);
+
+  if (!game->AddClothes(buf,0,1,&player[pnum].skeleton.skinText[pnum],&player[pnum].skeleton.skinsize))
+    return;
+
+  player[pnum].DoMipmaps(5,0,0,player[pnum].skeleton.skinsize,player[pnum].skeleton.skinsize);
+  strcpy(player[pnum].clothes[player[pnum].numclothes],buf);
+  player[pnum].clothestintr[player[pnum].numclothes]=tintr;
+  player[pnum].clothestintg[player[pnum].numclothes]=tintg;
+  player[pnum].clothestintb[player[pnum].numclothes]=tintb;
+  player[pnum].numclothes++;
+}
+
+static void ch_clothes(Game *game, const char *args)
+{
+  set_clothes(0, game, args);
+}
+
+static void ch_clothesnear(Game *game, const char *args)
+{
+  int closest = find_closest();
+  if (closest)
+    set_clothes(closest, game, args);
+}
+
+static void ch_belt(Game *game, const char *args)
+{
+  player[0].skeleton.clothes = !player[0].skeleton.clothes;
+}
+
+
+static void ch_cellophane(Game *game, const char *args)
+{
+  cellophane = !cellophane;
+  float mul = cellophane ? 0 : 1;
+
+  for (int i = 0; i < numplayers; i++) {
+    player[i].proportionhead.z = player[i].proportionhead.x * mul;
+    player[i].proportionbody.z = player[i].proportionbody.x * mul;
+    player[i].proportionarms.z = player[i].proportionarms.x * mul;
+    player[i].proportionlegs.z = player[i].proportionlegs.x * mul;
+  }
+}
+
+static void ch_funnybunny(Game *game, const char *args)
+{
+  player[0].skeleton.id=0;
+  player[0].skeleton.Load(":Data:Skeleton:Basic Figure",":Data:Skeleton:Basic Figurelow",
+                         ":Data:Skeleton:Rabbitbelt",":Data:Models:Body.solid",
+                         ":Data:Models:Body2.solid",":Data:Models:Body3.solid",
+                         ":Data:Models:Body4.solid",":Data:Models:Body5.solid",
+                         ":Data:Models:Body6.solid",":Data:Models:Body7.solid",
+                         ":Data:Models:Bodylow.solid",":Data:Models:Belt.solid",1);
+  game->LoadTextureSave(":Data:Textures:fur3.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+  player[0].creature=rabbittype;
+  player[0].scale=.2;
+  player[0].headless=0;
+  player[0].damagetolerance=200;
+  set_proportion(0, "1 1 1 1");
+}
+
+static void ch_wolfie(Game *game, const char *args)
+{
+  player[0].skeleton.id=0;
+  player[0].skeleton.Load(":Data:Skeleton:Basic Figure Wolf",":Data:Skeleton:Basic Figure Wolf Low",
+                         ":Data:Skeleton:Rabbitbelt",":Data:Models:Wolf.solid",
+                         ":Data:Models:Wolf2.solid",":Data:Models:Wolf3.solid",
+                         ":Data:Models:Wolf4.solid",":Data:Models:Wolf5.solid",
+                         ":Data:Models:Wolf6.solid",":Data:Models:Wolf7.solid",
+                         ":Data:Models:Wolflow.solid",":Data:Models:Belt.solid",0);
+  game->LoadTextureSave(":Data:Textures:Wolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+  player[0].creature=wolftype;
+  player[0].damagetolerance=300;
+  set_proportion(0, "1 1 1 1");
+}
+
+static void ch_wolf(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:Wolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_snowwolf(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:SnowWolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_darkwolf(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:DarkWolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_white(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:fur.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_brown(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:fur3.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_black(Game *game, const char *args)
+{
+  game->LoadTextureSave(":Data:Textures:fur2.jpg",&player[0].skeleton.drawmodel.textureptr,1,
+                       &player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
+}
+
+static void ch_sizemin(Game *game, const char *args)
+{
+  int i;
+  for (i = 1; i < numplayers; i++)
+    if (player[i].scale < 0.8 * 0.2)
+      player[i].scale = 0.8 * 0.2;
+}
+
+static void ch_tutorial(Game *game, const char *args)
+{
+  tutoriallevel = atoi(args);
+}
+
+static void ch_hostile(Game *game, const char *args)
+{
+  hostile = atoi(args);
+}
+
+static void ch_indemo(Game *game, const char *args)
+{
+  game->indemo=1;
+  hotspot[numhotspots]=player[0].coords;
+  hotspotsize[numhotspots]=0;
+  hotspottype[numhotspots]=-111;
+  strcpy(hotspottext[numhotspots],"mapname");
+  numhotspots++;
+}
+
+static void ch_notindemo(Game *game, const char *args)
+{
+  game->indemo=0;
+  numhotspots--;
+}
+
+static void ch_type(Game *game, const char *args)
+{
+  int i, n = sizeof(editortypenames) / sizeof(editortypenames[0]);
+  for (i = 0; i < n; i++)
+    if (stripfx(args, editortypenames[i]))
+      {
+       editoractive = i;
+       break;
+      }
+}
+
+static void ch_path(Game *game, const char *args)
+{
+  int i, n = sizeof(pathtypenames) / sizeof(pathtypenames[0]);
+  for (i = 0; i < n; i++)
+    if (stripfx(args, pathtypenames[i]))
+      {
+       editorpathtype = i;
+       break;
+      }
+}
+
+static void ch_hs(Game *game, const char *args)
+{
+  hotspot[numhotspots]=player[0].coords;
+
+  float size;
+  int type, shift;
+  sscanf(args, "%f%d %n", &size, &type, &shift);
+
+  hotspotsize[numhotspots] = size;
+  hotspottype[numhotspots] = type;
+
+  strcpy(hotspottext[numhotspots], args + shift);
+  strcat(hotspottext[numhotspots], "\n");
+
+  numhotspots++;
+}
+
+static void ch_dialogue(Game *game, const char *args)
+{
+  int dlg, i, j;
+  char buf1[32], buf2[64];
+
+  sscanf(args, "%d %31s", &dlg, buf1);
+  snprintf(buf2, 63, ":Data:Dialogues:%s.txt", buf1);
+
+  dialoguetype[numdialogues] = dlg;
+
+  memset(dialoguetext[numdialogues], 0, sizeof(dialoguetext[numdialogues]));
+  memset(dialoguename[numdialogues], 0, sizeof(dialoguename[numdialogues]));
+
+  ifstream ipstream(ConvertFileName(buf2));
+  ipstream.ignore(256,':');
+  ipstream >> numdialogueboxes[numdialogues];
+  for(i=0;i<numdialogueboxes[numdialogues];i++){
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,' ');
+    ipstream >> dialogueboxlocation[numdialogues][i];
+    ipstream.ignore(256,':');
+    ipstream >> dialogueboxcolor[numdialogues][i][0];
+    ipstream >> dialogueboxcolor[numdialogues][i][1];
+    ipstream >> dialogueboxcolor[numdialogues][i][2];
+    ipstream.ignore(256,':');
+    ipstream.getline(dialoguename[numdialogues][i],64);
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,' ');
+    ipstream.getline(dialoguetext[numdialogues][i],128);
+    for(j=0;j<128;j++){
+      if(dialoguetext[numdialogues][i][j]=='\\')dialoguetext[numdialogues][i][j]='\n';
+    }
+    ipstream.ignore(256,':');
+    ipstream >> dialogueboxsound[numdialogues][i];
+  }
+
+  for(i=0;i<numdialogueboxes[numdialogues];i++){
+    for(j=0;j<numplayers;j++){
+      participantfacing[numdialogues][i][j]=player[j].facing;
+    }
+  }
+  ipstream.close();
+
+  directing=1;
+  indialogue=0;
+  whichdialogue=numdialogues;
+
+  numdialogues++;
+}
+
+static void ch_fixdialogue(Game *game, const char *args)
+{
+  char buf1[32], buf2[64];
+  int whichdi, i, j;
+
+  sscanf(args, "%d %31s", &whichdi, buf1);
+  snprintf(buf2, 63, ":Data:Dialogues:%s.txt", buf1);
+
+  memset(dialoguetext[whichdi], 0, sizeof(dialoguetext[whichdi]));
+  memset(dialoguename[whichdi], 0, sizeof(dialoguename[whichdi]));
+
+  ifstream ipstream(ConvertFileName(buf2));
+  ipstream.ignore(256,':');
+  ipstream >> numdialogueboxes[whichdi];
+  for(i=0;i<numdialogueboxes[whichdi];i++){
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,' ');
+    ipstream >> dialogueboxlocation[whichdi][i];
+    ipstream.ignore(256,':');
+    ipstream >> dialogueboxcolor[whichdi][i][0];
+    ipstream >> dialogueboxcolor[whichdi][i][1];
+    ipstream >> dialogueboxcolor[whichdi][i][2];
+    ipstream.ignore(256,':');
+    ipstream.getline(dialoguename[whichdi][i],64);
+    ipstream.ignore(256,':');
+    ipstream.ignore(256,' ');
+    ipstream.getline(dialoguetext[whichdi][i],128);
+    for(j=0;j<128;j++){
+      if(dialoguetext[whichdi][i][j]=='\\')dialoguetext[whichdi][i][j]='\n';
+    }
+    ipstream.ignore(256,':');
+    ipstream >> dialogueboxsound[whichdi][i];
+  }
+
+  ipstream.close();
+}
+
+static void ch_fixtype(Game *game, const char *args)
+{
+  int dlg;
+  sscanf(args, "%d", &dlg);
+  dialoguetype[0] = dlg;
+}
+
+static void ch_fixrotation(Game *game, const char *args)
+{
+  participantrotation[whichdialogue][participantfocus[whichdialogue][indialogue]]=player[participantfocus[whichdialogue][indialogue]].rotation;
+}
+
+static void ch_ddialogue(Game *game, const char *args)
+{
+  if (numdialogues)
+    numdialogues--;
+}
+
+static void ch_dhs(Game *game, const char *args)
+{
+  if (numhotspots)
+    numhotspots--;
+}
+
+static void ch_immobile(Game *game, const char *args)
+{
+  player[0].immobile = 1;
+}
+
+static void ch_allimmobile(Game *game, const char *args)
+{
+  for (int i = 1; i < numplayers; i++)
+    player[i].immobile = 1;
+}
+
+static void ch_mobile(Game *game, const char *args)
+{
+  player[0].immobile = 0;
+}
+
+static void ch_default(Game *game, const char *args)
+{
+  player[0].armorhead=1;
+  player[0].armorhigh=1;
+  player[0].armorlow=1;
+  player[0].protectionhead=1;
+  player[0].protectionhigh=1;
+  player[0].protectionlow=1;
+  player[0].metalhead=1;
+  player[0].metalhigh=1;
+  player[0].metallow=1;
+  player[0].power=1;
+  player[0].speedmult=1;
+  player[0].scale=1;
+
+  if(player[0].creature==wolftype){
+    player[0].proportionhead=1.1;
+    player[0].proportionbody=1.1;
+    player[0].proportionarms=1.1;
+    player[0].proportionlegs=1.1;
+  }
+
+  if(player[0].creature==rabbittype){
+    player[0].proportionhead=1.2;
+    player[0].proportionbody=1.05;
+    player[0].proportionarms=1.00;
+    player[0].proportionlegs=1.1;
+    player[0].proportionlegs.y=1.05;
+  }
+
+  player[0].numclothes=0;
+  game->LoadTextureSave(creatureskin[player[0].creature][player[0].whichskin],
+                       &player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],
+                       &player[0].skeleton.skinsize);
+
+  editoractive=typeactive;
+  player[0].immobile=0;
+}
+
+static void ch_play(Game *game, const char *args)
+{
+  int dlg, i;
+  sscanf(args, "%d", &dlg);
+  whichdialogue = dlg;
+
+  if (whichdialogue >= numdialogues)
+    return;
+
+  for(i=0;i<numdialogueboxes[whichdialogue];i++){
+    player[participantfocus[whichdialogue][i]].coords=participantlocation[whichdialogue][participantfocus[whichdialogue][i]];
+    player[participantfocus[whichdialogue][i]].rotation=participantrotation[whichdialogue][participantfocus[whichdialogue][i]];
+    player[participantfocus[whichdialogue][i]].targetrotation=participantrotation[whichdialogue][participantfocus[whichdialogue][i]];
+    player[participantfocus[whichdialogue][i]].velocity=0;
+    player[participantfocus[whichdialogue][i]].targetanimation=player[participantfocus[whichdialogue][i]].getIdle();
+    player[participantfocus[whichdialogue][i]].targetframe=0;
+  }
+
+  directing=0;
+  indialogue=0;
+
+  float gLoc[3];
+  float vel[3];
+  XYZ temppos;
+  temppos=player[participantfocus[whichdialogue][indialogue]].coords;
+  temppos=temppos-viewer;
+  Normalise(&temppos);
+  temppos+=viewer;
+
+  gLoc[0]=temppos.x;
+  gLoc[1]=temppos.y;
+  gLoc[2]=temppos.z;
+  vel[0]=0;
+  vel[1]=0;
+  vel[2]=0;
+  int whichsoundplay;
+  whichsoundplay=rabbitchitter;
+  if(dialogueboxsound[whichdialogue][indialogue]==2)whichsoundplay=rabbitchitter2;
+  if(dialogueboxsound[whichdialogue][indialogue]==3)whichsoundplay=rabbitpainsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==4)whichsoundplay=rabbitpain1sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==5)whichsoundplay=rabbitattacksound;
+  if(dialogueboxsound[whichdialogue][indialogue]==6)whichsoundplay=rabbitattack2sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==7)whichsoundplay=rabbitattack3sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==8)whichsoundplay=rabbitattack4sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==9)whichsoundplay=growlsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==10)whichsoundplay=growl2sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==11)whichsoundplay=snarlsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==12)whichsoundplay=snarl2sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==13)whichsoundplay=barksound;
+  if(dialogueboxsound[whichdialogue][indialogue]==14)whichsoundplay=bark2sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==15)whichsoundplay=bark3sound;
+  if(dialogueboxsound[whichdialogue][indialogue]==16)whichsoundplay=barkgrowlsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==-1)whichsoundplay=fireendsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==-2)whichsoundplay=firestartsound;
+  if(dialogueboxsound[whichdialogue][indialogue]==-3)whichsoundplay=consolesuccesssound;
+  if(dialogueboxsound[whichdialogue][indialogue]==-4)whichsoundplay=consolefailsound;
+  PlaySoundEx( whichsoundplay, samp[whichsoundplay], NULL, true);
+  OPENAL_3D_SetAttributes(channels[whichsoundplay], gLoc, vel);
+  OPENAL_SetVolume(channels[whichsoundplay], 256);
+  OPENAL_SetPaused(channels[whichsoundplay], false);
+}
+
+static void ch_mapkilleveryone(Game *game, const char *args)
+{
+  maptype = mapkilleveryone;
+}
+
+static void ch_mapkillmost(Game *game, const char *args)
+{
+  maptype = mapkillmost;
+}
+
+static void ch_mapkillsomeone(Game *game, const char *args)
+{
+  maptype = mapkillsomeone;
+}
+
+static void ch_mapgosomewhere(Game *game, const char *args)
+{
+  maptype = mapgosomewhere;
+}
+
+static void ch_viewdistance(Game *game, const char *args)
+{
+  viewdistance = atof(args)*100;
+}
+
+static void ch_fadestart(Game *game, const char *args)
+{
+  fadestart = atof(args);
+}
+
+static void ch_slomo(Game *game, const char *args)
+{
+  slomospeed = atof(args);
+  slomo = !slomo;
+  slomodelay = 1000;
+}
+
+static void ch_slofreq(Game *game, const char *args)
+{
+  slomofreq = atof(args);
+}
+
+static void ch_skytint(Game *game, const char *args)
+{
+  sscanf(args, "%f%f%f", &skyboxr, &skyboxg, &skyboxb);
+
+  skyboxlightr=skyboxr;
+  skyboxlightg=skyboxg;
+  skyboxlightb=skyboxb;
+
+  game->SetUpLighting();
+
+  terrain.DoShadows();
+  objects.DoShadows();
+}
+
+static void ch_skylight(Game *game, const char *args)
+{
+  sscanf(args, "%f%f%f", &skyboxlightr, &skyboxlightg, &skyboxlightb);
+
+  game->SetUpLighting();
+
+  terrain.DoShadows();
+  objects.DoShadows();
+}
+
+static void ch_skybox(Game *game, const char *args)
+{
+  skyboxtexture = !skyboxtexture;
+
+  game->SetUpLighting();
+
+  terrain.DoShadows();
+  objects.DoShadows();
+}
+
+static void cmd_dispatch(Game *game, const char *cmd)
+{
+  int i, n_cmds = sizeof(cmd_names) / sizeof(cmd_names[0]);
+
+  for (i = 0; i < n_cmds; i++)
+    if (stripfx(cmd, cmd_names[i]))
+      {
+       cmd_handlers[i](game, cmd + strlen(cmd_names[i]));
+       break;
+      }
+  if (i < n_cmds)
+    {
+      PlaySoundEx(consolesuccesssound, samp[consolesuccesssound], NULL, true);
+      OPENAL_SetVolume(channels[consolesuccesssound], 256);
+      OPENAL_SetPaused(channels[consolesuccesssound], false);
+    }
+  else
+    {
+      PlaySoundEx(consolefailsound, samp[consolefailsound], NULL, true);
+      OPENAL_SetVolume(channels[consolefailsound], 256);
+      OPENAL_SetPaused(channels[consolefailsound], false);
+    }
+}
+
+
+
+/********************> Tick() <*****/
 extern void ScreenShot(const char * fname);
 void Screenshot        (void)
 {
        char temp[1024];
        time_t  t = time(NULL);
        struct  tm *tme = localtime(&t);
-       sprintf(temp, "Screenshots\\Screenshot_%04d_%02d_%02d--%02d_%02d_%02d.png", tme->tm_year + 1900, tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);
+       sprintf(temp, "Screenshots/Screenshot_%04d_%02d_%02d--%02d_%02d_%02d.png", tme->tm_year + 1900, tme->tm_mon + 1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);
 
        #if defined(_WIN32)
        mkdir("Screenshots");
@@ -647,10 +1599,10 @@ void     Game::Setenvironment(int which)
                        OPENAL_SetVolume(channels[stream_wind], 256);
                }
 
-               LoadTexture(ConvertFileName(":Data:Textures:snowtree.png"),&objects.treetextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:bushsnow.png"),&objects.bushtextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:bouldersnow.jpg"),&objects.rocktextureptr,1,0);
-               LoadTexture(ConvertFileName(":Data:Textures:snowbox.jpg"),&objects.boxtextureptr,1,0);
+               LoadTexture(":Data:Textures:snowtree.png",&objects.treetextureptr,0,1);
+               LoadTexture(":Data:Textures:bushsnow.png",&objects.bushtextureptr,0,1);
+               LoadTexture(":Data:Textures:bouldersnow.jpg",&objects.rocktextureptr,1,0);
+               LoadTexture(":Data:Textures:snowbox.jpg",&objects.boxtextureptr,1,0);
 
                OPENAL_Sample_Free(samp[footstepsound]);
                OPENAL_Sample_Free(samp[footstepsound2]);
@@ -665,25 +1617,25 @@ void     Game::Setenvironment(int which)
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound3], 4.0f, 1000.0f);
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound4], 4.0f, 1000.0f);
 
-               LoadTexture(ConvertFileName(":Data:Textures:snow.jpg"),&terraintexture,1,0);
+               LoadTexture(":Data:Textures:snow.jpg",&terraintexture,1,0);
 
-               LoadTexture(ConvertFileName(":Data:Textures:rock.jpg"),&terraintexture2,1,0);
+               LoadTexture(":Data:Textures:rock.jpg",&terraintexture2,1,0);
 
-               //LoadTexture(ConvertFileName(":Data:Textures:detailgrain.png"),&terraintexture3,1);
+               //LoadTexture(":Data:Textures:detailgrain.png",&terraintexture3,1);
 
 
 
 
                temptexdetail=texdetail;
                if(texdetail>1)texdetail=4;
-               skybox.load(    ConvertFileName(":Data:Textures:Skybox(snow):Front.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Left.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Back.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Right.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Up.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Down.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Cloud.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(snow):Reflect.jpg"));
+               skybox.load(    ":Data:Textures:Skybox(snow):Front.jpg",
+                       ":Data:Textures:Skybox(snow):Left.jpg",
+                       ":Data:Textures:Skybox(snow):Back.jpg",
+                       ":Data:Textures:Skybox(snow):Right.jpg",
+                       ":Data:Textures:Skybox(snow):Up.jpg",
+                       ":Data:Textures:Skybox(snow):Down.jpg",
+                       ":Data:Textures:Skybox(snow):Cloud.jpg",
+                       ":Data:Textures:Skybox(snow):Reflect.jpg");
 
 
 
@@ -693,10 +1645,10 @@ void     Game::Setenvironment(int which)
        if(environment==desertenvironment){
                windvector=0;
                windvector.z=2;
-               LoadTexture(ConvertFileName(":Data:Textures:deserttree.png"),&objects.treetextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:bushdesert.png"),&objects.bushtextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:boulderdesert.jpg"),&objects.rocktextureptr,1,0);
-               LoadTexture(ConvertFileName(":Data:Textures:desertbox.jpg"),&objects.boxtextureptr,1,0);
+               LoadTexture(":Data:Textures:deserttree.png",&objects.treetextureptr,0,1);
+               LoadTexture(":Data:Textures:bushdesert.png",&objects.bushtextureptr,0,1);
+               LoadTexture(":Data:Textures:boulderdesert.jpg",&objects.rocktextureptr,1,0);
+               LoadTexture(":Data:Textures:desertbox.jpg",&objects.boxtextureptr,1,0);
 
 
                if(ambientsound){
@@ -719,24 +1671,24 @@ void     Game::Setenvironment(int which)
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound3], 4.0f, 1000.0f);
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound4], 4.0f, 1000.0f);
 
-               LoadTexture(ConvertFileName(":Data:Textures:sand.jpg"),&terraintexture,1,0);
+               LoadTexture(":Data:Textures:sand.jpg",&terraintexture,1,0);
 
-               LoadTexture(ConvertFileName(":Data:Textures:sandslope.jpg"),&terraintexture2,1,0);
+               LoadTexture(":Data:Textures:sandslope.jpg",&terraintexture2,1,0);
 
-               //LoadTexture(ConvertFileName(":Data:Textures:detailgrain.png"),&terraintexture3,1);
+               //LoadTexture(":Data:Textures:detailgrain.png",&terraintexture3,1);
 
 
 
                temptexdetail=texdetail;
                if(texdetail>1)texdetail=4;
-               skybox.load(    ConvertFileName(":Data:Textures:Skybox(sand):Front.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Left.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Back.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Right.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Up.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Down.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Cloud.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(sand):Reflect.jpg"));
+               skybox.load(    ":Data:Textures:Skybox(sand):Front.jpg",
+                       ":Data:Textures:Skybox(sand):Left.jpg",
+                       ":Data:Textures:Skybox(sand):Back.jpg",
+                       ":Data:Textures:Skybox(sand):Right.jpg",
+                       ":Data:Textures:Skybox(sand):Up.jpg",
+                       ":Data:Textures:Skybox(sand):Down.jpg",
+                       ":Data:Textures:Skybox(sand):Cloud.jpg",
+                       ":Data:Textures:Skybox(sand):Reflect.jpg");
 
 
 
@@ -746,10 +1698,10 @@ void     Game::Setenvironment(int which)
        if(environment==grassyenvironment){
                windvector=0;
                windvector.z=2;
-               LoadTexture(ConvertFileName(":Data:Textures:tree.png"),&objects.treetextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:bush.png"),&objects.bushtextureptr,0,1);
-               LoadTexture(ConvertFileName(":Data:Textures:boulder.jpg"),&objects.rocktextureptr,1,0);
-               LoadTexture(ConvertFileName(":Data:Textures:grassbox.jpg"),&objects.boxtextureptr,1,0);
+               LoadTexture(":Data:Textures:tree.png",&objects.treetextureptr,0,1);
+               LoadTexture(":Data:Textures:bush.png",&objects.bushtextureptr,0,1);
+               LoadTexture(":Data:Textures:boulder.jpg",&objects.rocktextureptr,1,0);
+               LoadTexture(":Data:Textures:grassbox.jpg",&objects.boxtextureptr,1,0);
 
                if(ambientsound){
                        PlayStreamEx( stream_wind, strm[stream_wind], NULL, true);
@@ -770,24 +1722,24 @@ void     Game::Setenvironment(int which)
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound3], 4.0f, 1000.0f);
                OPENAL_Sample_SetMinMaxDistance(samp[footstepsound4], 4.0f, 1000.0f);
 
-               LoadTexture(ConvertFileName(":Data:Textures:grassdirt.jpg"),&terraintexture,1,0);
+               LoadTexture(":Data:Textures:grassdirt.jpg",&terraintexture,1,0);
 
-               LoadTexture(ConvertFileName(":Data:Textures:mossrock.jpg"),&terraintexture2,1,0);
+               LoadTexture(":Data:Textures:mossrock.jpg",&terraintexture2,1,0);
 
-               //LoadTexture(ConvertFileName(":Data:Textures:detail.png"),&terraintexture3,1);
+               //LoadTexture(":Data:Textures:detail.png",&terraintexture3,1);
 
 
 
                temptexdetail=texdetail;
                if(texdetail>1)texdetail=4;
-               skybox.load(    ConvertFileName(":Data:Textures:Skybox(grass):Front.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Left.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Back.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Right.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Up.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Down.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Cloud.jpg"),
-                       ConvertFileName(":Data:Textures:Skybox(grass):Reflect.jpg"));
+               skybox.load(    ":Data:Textures:Skybox(grass):Front.jpg",
+                       ":Data:Textures:Skybox(grass):Left.jpg",
+                       ":Data:Textures:Skybox(grass):Back.jpg",
+                       ":Data:Textures:Skybox(grass):Right.jpg",
+                       ":Data:Textures:Skybox(grass):Up.jpg",
+                       ":Data:Textures:Skybox(grass):Down.jpg",
+                       ":Data:Textures:Skybox(grass):Cloud.jpg",
+                       ":Data:Textures:Skybox(grass):Reflect.jpg");
 
 
 
@@ -795,7 +1747,7 @@ void       Game::Setenvironment(int which)
        }
        temptexdetail=texdetail;
        texdetail=1;
-       terrain.load(ConvertFileName(":Data:Textures:heightmap.png"));
+       terrain.load(":Data:Textures:heightmap.png");
 
        texdetail=temptexdetail;
 }
@@ -804,24 +1756,24 @@ void     Game::Setenvironment(int which)
 void   Game::Loadlevel(int which){
        stealthloading=0;
 
-       if(which==0)Loadlevel((char *)ConvertFileName(":Data:Maps:map1"));
-       else if(which==1)Loadlevel((char *)ConvertFileName(":Data:Maps:map2"));
-       else if(which==2)Loadlevel((char *)ConvertFileName(":Data:Maps:map3"));
-       else if(which==3)Loadlevel((char *)ConvertFileName(":Data:Maps:map4"));
-       else if(which==4)Loadlevel((char *)ConvertFileName(":Data:Maps:map5"));
-       else if(which==5)Loadlevel((char *)ConvertFileName(":Data:Maps:map6"));
-       else if(which==6)Loadlevel((char *)ConvertFileName(":Data:Maps:map7"));
-       else if(which==7)Loadlevel((char *)ConvertFileName(":Data:Maps:map8"));
-       else if(which==8)Loadlevel((char *)ConvertFileName(":Data:Maps:map9"));
-       else if(which==9)Loadlevel((char *)ConvertFileName(":Data:Maps:map10"));
-       else if(which==10)Loadlevel((char *)ConvertFileName(":Data:Maps:map11"));
-       else if(which==11)Loadlevel((char *)ConvertFileName(":Data:Maps:map12"));
-       else if(which==12)Loadlevel((char *)ConvertFileName(":Data:Maps:map13"));
-       else if(which==13)Loadlevel((char *)ConvertFileName(":Data:Maps:map14"));
-       else if(which==14)Loadlevel((char *)ConvertFileName(":Data:Maps:map15"));
-       else if(which==15)Loadlevel((char *)ConvertFileName(":Data:Maps:map16"));
-       else if(which==-1){tutoriallevel=-1;Loadlevel((char *)ConvertFileName(":Data:Maps:tutorial"));}
-       else Loadlevel((char *)ConvertFileName(":Data:Maps:mapsave"));
+       if(which==0)Loadlevel((char *)":Data:Maps:map1");
+       else if(which==1)Loadlevel((char *)":Data:Maps:map2");
+       else if(which==2)Loadlevel((char *)":Data:Maps:map3");
+       else if(which==3)Loadlevel((char *)":Data:Maps:map4");
+       else if(which==4)Loadlevel((char *)":Data:Maps:map5");
+       else if(which==5)Loadlevel((char *)":Data:Maps:map6");
+       else if(which==6)Loadlevel((char *)":Data:Maps:map7");
+       else if(which==7)Loadlevel((char *)":Data:Maps:map8");
+       else if(which==8)Loadlevel((char *)":Data:Maps:map9");
+       else if(which==9)Loadlevel((char *)":Data:Maps:map10");
+       else if(which==10)Loadlevel((char *)":Data:Maps:map11");
+       else if(which==11)Loadlevel((char *)":Data:Maps:map12");
+       else if(which==12)Loadlevel((char *)":Data:Maps:map13");
+       else if(which==13)Loadlevel((char *)":Data:Maps:map14");
+       else if(which==14)Loadlevel((char *)":Data:Maps:map15");
+       else if(which==15)Loadlevel((char *)":Data:Maps:map16");
+       else if(which==-1){tutoriallevel=-1;Loadlevel((char *)":Data:Maps:tutorial");}
+       else Loadlevel((char *)":Data:Maps:mapsave");
 
        whichlevel=which;
 }
@@ -902,7 +1854,7 @@ void       Game::Loadlevel(char *name){
                won=0;
 
                //campaign=0;
-               animation[bounceidleanim].Load((char *)ConvertFileName(":Data:Animations:Idle"),middleheight,neutral);
+               animation[bounceidleanim].Load((char *)":Data:Animations:Idle",middleheight,neutral);
 
                numdialogues=0;
 
@@ -1386,52 +2338,7 @@ void     Game::Loadlevel(char *name){
                        //if(!player[i].loaded)player[i].skeleton.skinText = new GLubyte[texsize];
                        //player[i].skeleton.skinText.resize(texsize);
 
-                       if(player[i].creature==rabbittype)
-                       {
-                               if(player[i].whichskin==0){
-                                       LoadTextureSave(":Data:Textures:Fur3.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==1){
-                                       LoadTextureSave(":Data:Textures:Fur.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==2){
-                                       LoadTextureSave(":Data:Textures:Fur2.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==3){
-                                       LoadTextureSave(":Data:Textures:Lynx.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==4){
-                                       LoadTextureSave(":Data:Textures:Otter.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==5){
-                                       LoadTextureSave(":Data:Textures:Opal.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==6){
-                                       LoadTextureSave(":Data:Textures:Sable.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==7){
-                                       LoadTextureSave(":Data:Textures:Chocolate.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==8){
-                                       LoadTextureSave(":Data:Textures:BW2.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==9){
-                                       LoadTextureSave(":Data:Textures:WB2.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                       }
-                       if(player[i].creature==wolftype)
-                       {
-                               //k=abs(Random()%3);
-                               if(player[i].whichskin==0){
-                                       LoadTextureSave(":Data:Textures:Wolf.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==1){
-                                       LoadTextureSave(":Data:Textures:Darkwolf.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                               else if(player[i].whichskin==2){
-                                       LoadTextureSave(":Data:Textures:Snowwolf.jpg",&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                               }
-                       }
+                       LoadTextureSave(creatureskin[player[i].creature][player[i].whichskin],&player[i].skeleton.drawmodel.textureptr,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
 
                        if(player[i].numclothes)
                        {
@@ -1513,7 +2420,7 @@ void      Game::Loadlevel(char *name){
                                player[i].proportionlegs.z=0;
                        }
 
-                       player[i].tempanimation.Load((char *)ConvertFileName(":Data:Animations:Tempanim"),0,0);
+                       player[i].tempanimation.Load((char *)":Data:Animations:Tempanim",0,0);
 
                        player[i].headmorphness=0;
                        player[i].targetheadmorphness=1;
@@ -1685,7 +2592,6 @@ void      Game::Tick()
        static XYZ test2;
        static XYZ lowpoint,lowpointtarget,lowpoint2,lowpointtarget2,lowpoint3,lowpointtarget3,lowpoint4,lowpointtarget4,lowpoint5,lowpointtarget5,lowpoint6,lowpointtarget6,lowpoint7,lowpointtarget7,colpoint,colpoint2;
        static int whichhit;
-       static bool donesomething;
        static bool oldjumpkeydown;
 
        int templength;
@@ -1703,6 +2609,43 @@ void     Game::Tick()
 
 
        static bool mainmenutogglekeydown;
+
+       if (IsKeyDown(theKeyMap, MAC_F6_KEY) && !freezetogglekeydown) {
+               if (IsKeyDown(theKeyMap, MAC_SHIFT_KEY)) {
+                       stereoreverse=true;
+               } else {
+                       stereoreverse=false;
+               }
+
+               if (stereoreverse) {
+                       printf("Stereo reversed\n");
+               } else {
+                       printf("Stereo unreversed\n");
+               }
+               freezetogglekeydown=1;
+       }
+
+       if (IsKeyDown(theKeyMap, MAC_F7_KEY)) {
+               if (IsKeyDown(theKeyMap, MAC_SHIFT_KEY)) {
+                       stereoseparation -= 0.001;
+               } else {
+                       stereoseparation -= 0.010;
+               }
+
+               printf("Stereo decreased increased to %f\n", stereoseparation);
+       }
+
+       if (IsKeyDown(theKeyMap, MAC_F8_KEY)) {
+               if (IsKeyDown(theKeyMap, MAC_SHIFT_KEY)) {
+                       stereoseparation += 0.001;
+               } else {
+                       stereoseparation += 0.010;
+               }
+
+               printf("Stereo separation increased to %f\n", stereoseparation);
+       }
+
+
        if(!console){
                if(mainmenu&&endgame==1)mainmenu=10;
                if(IsKeyDown(theKeyMap, MAC_ESCAPE_KEY)&&!mainmenutogglekeydown&&(mainmenu==7&&entername)){
@@ -1845,81 +2788,7 @@ void     Game::Tick()
                                if(newscreenwidth<0)newscreenwidth=screenwidth;
                                if(newscreenheight<0)newscreenheight=screenheight;
 
-                               ofstream opstream(ConvertFileName(":Data:config.txt", "w"));
-                               opstream << "Screenwidth:\n";
-                               opstream << newscreenwidth;
-                               opstream << "\nScreenheight:\n";
-                               opstream << newscreenheight;
-                               opstream << "\nMouse sensitivity:\n";
-                               opstream << usermousesensitivity;
-                               opstream << "\nBlur(0,1):\n";
-                               opstream << ismotionblur;
-                               opstream << "\nOverall Detail(0,1,2) higher=better:\n";
-                               opstream << newdetail;
-                               opstream << "\nFloating jump:\n";
-                               opstream << floatjump;
-                               opstream << "\nMouse jump:\n";
-                               opstream << mousejump;
-                               opstream << "\nAmbient sound:\n";
-                               opstream << ambientsound;
-                               opstream << "\nBlood (0,1,2):\n";
-                               opstream << bloodtoggle;
-                               opstream << "\nAuto slomo:\n";
-                               opstream << autoslomo;
-                               opstream << "\nFoliage:\n";
-                               opstream << foliage;
-                               opstream << "\nMusic:\n";
-                               opstream << musictoggle;
-                               opstream << "\nTrilinear:\n";
-                               opstream << trilinear;
-                               opstream << "\nDecals(shadows,blood puddles,etc):\n";
-                               opstream << decals;
-                               opstream << "\nInvert mouse:\n";
-                               opstream << invertmouse;
-                               opstream << "\nGamespeed:\n";
-                               if(oldgamespeed==0)oldgamespeed=1;
-                               opstream << oldgamespeed;
-                               opstream << "\nDifficulty(0,1,2) higher=harder:\n";
-                               opstream << difficulty;
-                               opstream << "\nDamage effects(blackout, doublevision):\n";
-                               opstream << damageeffects;
-                               opstream << "\nText:\n";
-                               opstream << texttoggle;
-                               opstream << "\nDebug:\n";
-                               opstream << debugmode;
-                               opstream << "\nVBL Sync:\n";
-                               opstream << vblsync;
-                               opstream << "\nShow Points:\n";
-                               opstream << showpoints;
-                               opstream << "\nAlways Blur:\n";
-                               opstream << alwaysblur;
-                               opstream << "\nImmediate mode (turn on on G5):\n";
-                               opstream << immediate;
-                               opstream << "\nVelocity blur:\n";
-                               opstream << velocityblur;
-                           opstream << "\nVolume:\n";
-                       opstream << volume;
-                               opstream << "\nForward key:\n";
-                               opstream << KeyToChar(forwardkey);
-                               opstream << "\nBack key:\n";
-                               opstream << KeyToChar(backkey);
-                               opstream << "\nLeft key:\n";
-                               opstream << KeyToChar(leftkey);
-                               opstream << "\nRight key:\n";
-                               opstream << KeyToChar(rightkey);
-                               opstream << "\nJump key:\n";
-                               opstream << KeyToChar(jumpkey);
-                               opstream << "\nCrouch key:\n";
-                               opstream << KeyToChar(crouchkey);
-                               opstream << "\nDraw key:\n";
-                               opstream << KeyToChar(drawkey);
-                               opstream << "\nThrow key:\n";
-                               opstream << KeyToChar(throwkey);
-                               opstream << "\nAttack key:\n";
-                               opstream << KeyToChar(attackkey);
-                               opstream << "\nChat key:\n";
-                               opstream << KeyToChar(chatkey);
-                               opstream.close();
+                               SaveSettings(*this);
                        }
                        if(mainmenu==4||mainmenu==5||mainmenu==6||mainmenu==7||mainmenu==9||mainmenu==13||mainmenu==10||mainmenu==11||mainmenu==100){
                                float gLoc[3]={0,0,0};
@@ -2240,82 +3109,7 @@ void     Game::Tick()
                                if(newscreenheight<0)newscreenheight=screenheight;
 
 
-                               ofstream opstream(ConvertFileName(":Data:config.txt", "w"));
-                               opstream << "Screenwidth:\n";
-                               opstream << newscreenwidth;
-                               opstream << "\nScreenheight:\n";
-                               opstream << newscreenheight;
-                               opstream << "\nMouse sensitivity:\n";
-                               opstream << usermousesensitivity;
-                               opstream << "\nBlur(0,1):\n";
-                               opstream << ismotionblur;
-                               opstream << "\nOverall Detail(0,1,2) higher=better:\n";
-                               opstream << newdetail;
-                               opstream << "\nFloating jump:\n";
-                               opstream << floatjump;
-                               opstream << "\nMouse jump:\n";
-                               opstream << mousejump;
-                               opstream << "\nAmbient sound:\n";
-                               opstream << ambientsound;
-                               opstream << "\nBlood (0,1,2):\n";
-                               opstream << bloodtoggle;
-                               opstream << "\nAuto slomo:\n";
-                               opstream << autoslomo;
-                               opstream << "\nFoliage:\n";
-                               opstream << foliage;
-                               opstream << "\nMusic:\n";
-                               opstream << musictoggle;
-                               opstream << "\nTrilinear:\n";
-                               opstream << trilinear;
-                               opstream << "\nDecals(shadows,blood puddles,etc):\n";
-                               opstream << decals;
-                               opstream << "\nInvert mouse:\n";
-                               opstream << invertmouse;
-                               opstream << "\nGamespeed:\n";
-                               if(oldgamespeed==0)oldgamespeed=1;
-                               opstream << oldgamespeed;
-                               opstream << "\nDifficulty(0,1,2) higher=harder:\n";
-                               opstream << difficulty;
-                               opstream << "\nDamage effects(blackout, doublevision):\n";
-                               opstream << damageeffects;
-                               opstream << "\nText:\n";
-                               opstream << texttoggle;
-                               opstream << "\nDebug:\n";
-                               opstream << debugmode;
-                               opstream << "\nVBL Sync:\n";
-                               opstream << vblsync;
-                               opstream << "\nShow Points:\n";
-                               opstream << showpoints;
-                               opstream << "\nAlways Blur:\n";
-                               opstream << alwaysblur;
-                               opstream << "\nImmediate mode (turn on on G5):\n";
-                               opstream << immediate;
-                               opstream << "\nVelocity blur:\n";
-                               opstream << velocityblur;
-                           opstream << "\nVolume:\n";
-                       opstream << volume;
-                               opstream << "\nForward key:\n";
-                               opstream << KeyToChar(forwardkey);
-                               opstream << "\nBack key:\n";
-                               opstream << KeyToChar(backkey);
-                               opstream << "\nLeft key:\n";
-                               opstream << KeyToChar(leftkey);
-                               opstream << "\nRight key:\n";
-                               opstream << KeyToChar(rightkey);
-                               opstream << "\nJump key:\n";
-                               opstream << KeyToChar(jumpkey);
-                               opstream << "\nCrouch key:\n";
-                               opstream << KeyToChar(crouchkey);
-                               opstream << "\nDraw key:\n";
-                               opstream << KeyToChar(drawkey);
-                               opstream << "\nThrow key:\n";
-                               opstream << KeyToChar(throwkey);
-                               opstream << "\nAttack key:\n";
-                               opstream << KeyToChar(attackkey);
-                               opstream << "\nChat key:\n";
-                               opstream << KeyToChar(chatkey);
-                               opstream.close();
-
+                               SaveSettings(*this);
                                if(mainmenu==3&&gameon)mainmenu=2;
                                if(mainmenu==3&&!gameon)mainmenu=1;
                        }
@@ -2868,81 +3662,7 @@ void     Game::Tick()
                                if(newscreenwidth<0)newscreenwidth=screenwidth;
                                if(newscreenheight<0)newscreenheight=screenheight;
 
-                               ofstream opstream(ConvertFileName(":Data:config.txt", "w"));
-                               opstream << "Screenwidth:\n";
-                               opstream << newscreenwidth;
-                               opstream << "\nScreenheight:\n";
-                               opstream << newscreenheight;
-                               opstream << "\nMouse sensitivity:\n";
-                               opstream << usermousesensitivity;
-                               opstream << "\nBlur(0,1):\n";
-                               opstream << ismotionblur;
-                               opstream << "\nOverall Detail(0,1,2) higher=better:\n";
-                               opstream << newdetail;
-                               opstream << "\nFloating jump:\n";
-                               opstream << floatjump;
-                               opstream << "\nMouse jump:\n";
-                               opstream << mousejump;
-                               opstream << "\nAmbient sound:\n";
-                               opstream << ambientsound;
-                               opstream << "\nBlood (0,1,2):\n";
-                               opstream << bloodtoggle;
-                               opstream << "\nAuto slomo:\n";
-                               opstream << autoslomo;
-                               opstream << "\nFoliage:\n";
-                               opstream << foliage;
-                               opstream << "\nMusic:\n";
-                               opstream << musictoggle;
-                               opstream << "\nTrilinear:\n";
-                               opstream << trilinear;
-                               opstream << "\nDecals(shadows,blood puddles,etc):\n";
-                               opstream << decals;
-                               opstream << "\nInvert mouse:\n";
-                               opstream << invertmouse;
-                               opstream << "\nGamespeed:\n";
-                               if(oldgamespeed==0)oldgamespeed=1;
-                               opstream << oldgamespeed;
-                               opstream << "\nDifficulty(0,1,2) higher=harder:\n";
-                               opstream << difficulty;
-                               opstream << "\nDamage effects(blackout, doublevision):\n";
-                               opstream << damageeffects;
-                               opstream << "\nText:\n";
-                               opstream << texttoggle;
-                               opstream << "\nDebug:\n";
-                               opstream << debugmode;
-                               opstream << "\nVBL Sync:\n";
-                               opstream << vblsync;
-                               opstream << "\nShow Points:\n";
-                               opstream << showpoints;
-                               opstream << "\nAlways Blur:\n";
-                               opstream << alwaysblur;
-                               opstream << "\nImmediate mode (turn on on G5):\n";
-                               opstream << immediate;
-                               opstream << "\nVelocity blur:\n";
-                               opstream << velocityblur;
-                           opstream << "\nVolume:\n";
-                       opstream << volume;
-                               opstream << "\nForward key:\n";
-                               opstream << KeyToChar(forwardkey);
-                               opstream << "\nBack key:\n";
-                               opstream << KeyToChar(backkey);
-                               opstream << "\nLeft key:\n";
-                               opstream << KeyToChar(leftkey);
-                               opstream << "\nRight key:\n";
-                               opstream << KeyToChar(rightkey);
-                               opstream << "\nJump key:\n";
-                               opstream << KeyToChar(jumpkey);
-                               opstream << "\nCrouch key:\n";
-                               opstream << KeyToChar(crouchkey);
-                               opstream << "\nDraw key:\n";
-                               opstream << KeyToChar(drawkey);
-                               opstream << "\nThrow key:\n";
-                               opstream << KeyToChar(throwkey);
-                               opstream << "\nAttack key:\n";
-                               opstream << KeyToChar(attackkey);
-                               opstream << "\nChat key:\n";
-                               opstream << KeyToChar(chatkey);
-                               opstream.close();
+                               SaveSettings(*this);
                        }
                }
 
@@ -3051,2306 +3771,220 @@ void Game::Tick()
                                                                mainmenu=5;
                         
                                                                flashr=1;
-                                                               flashg=0;
-                                                               flashb=0;
-                                                               flashamount=1;
-                                                               flashdelay=1;
-
-                                                               float gLoc[3]={0,0,0};
-                                                               float vel[3]={0,0,0};
-                                                               OPENAL_Sample_SetMinMaxDistance(samp[firestartsound], 9999.0f, 99999.0f);
-                                                               PlaySoundEx( firestartsound, samp[firestartsound], NULL, true);
-                                                               OPENAL_3D_SetAttributes(channels[firestartsound], gLoc, vel);
-                                                               OPENAL_SetVolume(channels[firestartsound], 256);
-                                                               OPENAL_SetPaused(channels[firestartsound], false);
-                                                               OPENAL_Sample_SetMinMaxDistance(samp[firestartsound], 8.0f, 2000.0f);
-
-                                                               for(j=0;j<255;j++){
-                                                                       displaytext[0][j]=' ';
-                                                               }
-                                                               displaychars[0]=0;
-                        
-                                                               displayselected=0;
-                                                       }}
-                                       }
-                                       togglekey[i]=1;
-                               }
-                               else {
-                                       togglekey[i]=0;
-                                       togglekeydelay[i]=0;
-                               }
-                       }
-
-                       displayblinkdelay-=multiplier;
-                       if(displayblinkdelay<=0){
-                               displayblinkdelay=.3;
-                               displayblink=1-displayblink;
-                       }
-               }
-       }
-
-       if(!mainmenu){
-               if(hostile==1)hostiletime+=multiplier;
-               else hostiletime=0;
-               if(!winfreeze)leveltime+=multiplier;
-               if(IsKeyDown(theKeyMap, MAC_ESCAPE_KEY)){
-                       chatting=0;
-                       console=0;
-                       freeze=0;
-                       displaychars[0]=0;
-               }
-
-               if(IsKeyDown(theKeyMap, chatkey)&&!chattogglekeydown&&!console&&!chatting&&debugmode){
-                       chatting=1;
-                       chattogglekeydown=1;
-                       togglekey[chatkey]=1;
-                       togglekeydelay[chatkey]=-20;
-               }
-
-               if(!IsKeyDown(theKeyMap, chatkey)){
-                       chattogglekeydown=0;
-               }
-
-               if(chatting){
-                       for(i=0;i<140;i++){
-                               if(IsKeyDown(theKeyMap, i)){
-                                       togglekeydelay[i]+=multiplier;
-                                       if(togglekeydelay[i]>.4){
-                                               togglekey[i]=0;
-                                               togglekeydelay[i]=.36;
-                                       }
-                                       if(!togglekey[i]){
-                                               if(KeyToSingleChar(i)!='\0'&&displaychars[0]<60){
-                                                       for(j=255;j>=displayselected+1;j--){
-                                                               displaytext[0][j]=displaytext[0][j-1];
-                                                       }
-                                                       displaytext[0][displayselected]=KeyToSingleChar(i);
-                                                       if(IsKeyDown(theKeyMap, MAC_SHIFT_KEY))displaytext[0][displayselected]=Shift(displaytext[0][displayselected]);
-                                                       displayselected++;
-                                                       displaychars[0]++;
-                                               }
-                                               if(i==MAC_DELETE_KEY&&displayselected!=0){
-                                                       for(j=displayselected-1;j<255;j++){
-                                                               displaytext[0][j]=displaytext[0][j+1];
-                                                       }
-                                                       displaytext[0][255]=' ';
-                                                       displayselected--;
-                                                       displaychars[0]--;
-                                               }
-                                               if(i==MAC_ARROW_LEFT_KEY&&displayselected!=0){
-                                                       displayselected--;
-                                               }
-                                               if(i==MAC_ARROW_RIGHT_KEY&&displayselected<displaychars[0]){
-                                                       displayselected++;
-                                               }
-                                               if(i==MAC_RETURN_KEY){
-                                                       if(displaychars[0]){
-                                                               /*for(j=0;j<displaychars[0];j++){
-                                                               talkname[j]=displaytext[0][j];
-                                                               }
-                                                               talkname[displaychars[0]]='\0';
-                                                               sprintf (chatname, "%s: %s",playerName,talkname);
-                                                               //NetworkSendInformation(chatname);
-                                                               */
-                                                               for(j=0;j<255;j++){
-                                                                       displaytext[0][j]=' ';
-                                                               }
-                                                               displaychars[0]=0;
-                                                               displayselected=0;
-                                                               chatting=0;
-                                                       }
-                                               }
-                                       }
-                                       togglekey[i]=1;
-                               }
-                               else {
-                                       togglekey[i]=0;
-                                       togglekeydelay[i]=0;
-                               }
-                       }
-
-                       displayblinkdelay-=multiplier;
-                       if(displayblinkdelay<=0){
-                               displayblinkdelay=.3;
-                               displayblink=1-displayblink;
-                       }
-               }
-
-               if(chatting)keyboardfrozen=1;
-
-               if(IsKeyDown(theKeyMap, MAC_V_KEY)&&!freezetogglekeydown&&debugmode){
-                       freeze=1-freeze;
-                       if(freeze){
-                               OPENAL_SetFrequency(OPENAL_ALL, 0.001);
-                       }
-                       freezetogglekeydown=1;
-               }
-
-               if(!IsKeyDown(theKeyMap, MAC_V_KEY)&&!IsKeyDown(theKeyMap, MAC_F1_KEY)){
-                       freezetogglekeydown=0;
-               }
-
-               if(IsKeyDown(theKeyMap, MAC_TILDE_KEY)&&!consoletogglekeydown&&debugmode){
-                       console=1-console;
-                       if(!console)freeze=0;
-                       if(console){
-                               OPENAL_SetFrequency(OPENAL_ALL, 0.001);
-                       }
-                       consoletogglekeydown=1;
-               }
-
-               if(!IsKeyDown(theKeyMap, MAC_TILDE_KEY)){
-                       consoletogglekeydown=0;
-               }
-
-               if(console)freeze=1;
-
-               if(console&&!IsKeyDown(theKeyMap,MAC_COMMAND_KEY)){
-                       for(i=0;i<140;i++){
-                               if(IsKeyDown(theKeyMap, i)){
-                                       togglekeydelay[i]+=multiplier;
-                                       if(togglekeydelay[i]>.4){
-                                               togglekey[i]=0;
-                                               togglekeydelay[i]=.36;
-                                       }
-                                       if(!togglekey[i]){
-                                               if(KeyToSingleChar(i)!='\0'&&consolechars[0]<255){
-                                                       for(j=255;j>=consoleselected+1;j--){
-                                                               consoletext[0][j]=consoletext[0][j-1];
-                                                       }
-                                                       consoletext[0][consoleselected]=KeyToSingleChar(i);
-                                                       if(IsKeyDown(theKeyMap, MAC_SHIFT_KEY))consoletext[0][consoleselected]=Shift(consoletext[0][consoleselected]);
-                                                       consoleselected++;
-                                                       consolechars[0]++;
-                                               }
-                                               else if(i==MAC_ENTER_KEY){
-                                                       for(j=255;j>=consoleselected+1;j--){
-                                                               consoletext[0][j]=consoletext[0][j-1];
-                                                       }
-                                                       consoletext[0][consoleselected]='\n';
-                                                       consoleselected++;
-                                                       consolechars[0]++;
-                                               }
-                                               if(i==MAC_DELETE_KEY&&consoleselected!=0){
-                                                       for(j=consoleselected-1;j<255;j++){
-                                                               consoletext[0][j]=consoletext[0][j+1];
-                                                       }
-                                                       consoletext[0][255]=' ';
-                                                       consoleselected--;
-                                                       consolechars[0]--;
-                                               }
-                                               if(i==MAC_ARROW_UP_KEY){
-                                                       if(archiveselected<14)archiveselected++;
-                                                       for(j=0;j<255;j++){
-                                                               consolechars[0]=consolechars[archiveselected];
-                                                               consoletext[0][j]=consoletext[archiveselected][j];
-                                                               consoleselected=consolechars[0];
-                                                       }
-                                               }
-                                               if(i==MAC_ARROW_DOWN_KEY){
-                                                       if(archiveselected>0)archiveselected--;
-                                                       for(j=0;j<255;j++){
-                                                               consolechars[0]=consolechars[archiveselected];
-                                                               consoletext[0][j]=consoletext[archiveselected][j];
-                                                               consoleselected=consolechars[0];
-                                                       }
-                                               }
-                                               if(i==MAC_ARROW_LEFT_KEY&&consoleselected!=0){
-                                                       consoleselected--;
-                                               }
-                                               if(i==MAC_ARROW_RIGHT_KEY&&consoleselected<consolechars[0]){
-                                                       consoleselected++;
-                                               }
-                                               if(i==MAC_RETURN_KEY){
-                                                       archiveselected=0;
-                                                       donesomething=0;
-                                                       if(Compare(consoletext[0],"quit ",0,4)||Compare(consoletext[0],"exit ",0,4)){
-                                                               PlaySoundEx( consolesuccesssound, samp[consolesuccesssound], NULL, true);
-                                                               OPENAL_SetVolume(channels[consolesuccesssound], 256);
-                                                               OPENAL_SetPaused(channels[consolesuccesssound], false);
-                                                               donesomething=1;
-                                                               tryquit=1;
-                                                       }
-                                                       /*if(Compare(consoletext[0],"send ",0,4)){
-                                                       for(j=5;j<consolechars[0];j++){
-                                                       talkname[j-5]=consoletext[0][j];
-                                                       }
-                                                       talkname[consolechars[0]-5]='\0';
-                                                       sprintf (chatname, "%s: %s",playerName,talkname);
-                                                       //NetworkSendInformation(chatname);
-                                                       donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"name ",0,4)){
-                                                       int numchars;
-                                                       numchars=consolechars[0]-5;
-                                                       if(numchars>32)numchars=32;
-                                                       for(j=5;j<numchars+5;j++){
-                                                       talkname[j-5]=consoletext[0][j];
-                                                       }
-                                                       talkname[numchars]='\0';
-                                                       sprintf (chatname, "Player %s is now known as %s.",playerName,talkname);
-                                                       //NetworkSendInformation(chatname);
-                                                       sprintf (playerName, "%s",talkname);
-                                                       //NetworkSendName(playerName);
-                                                       donesomething=1;
-                                                       }*/
-                                                       if(Compare(consoletext[0],"map ",0,3)){
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='M';
-                                                               mapname[7]='a';
-                                                               mapname[8]='p';
-                                                               mapname[9]='s';
-                                                               mapname[10]=':';
-                                                               for(j=4;j<consolechars[0];j++){
-                                                                       mapname[j-4+11]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-4+11]='\0';
-                                                               Loadlevel(mapname);
-                                                               whichlevel=-2;
-                                                               campaign=0;
-                                                               donesomething=1;
-                                                       }
-                                                       /*if(Compare(consoletext[0],"connect ",0,7)&&!ishost){
-                                                       int v;
-                                                       unsigned char playerNameStr[32];
-                                                       char theIPAddress[256];
-                                                       char thePort[32];
-                                                       NMUInt32 port = 25710;
-
-                                                       strcpy(playerName, "Client");
-                                                       GameC2PStr( playerName, playerNameStr );
-
-                                                       for(j=0;j<consolechars[0]-8;j++){
-                                                       theIPAddress[j]=consoletext[0][j+8];
-                                                       }
-                                                       theIPAddress[consolechars[0]-8]='\0';
-
-                                                       sprintf( thePort, "%li", port );
-                                                       v=NetworkStartClient( theIPAddress, thePort, playerNameStr );
-                                                       if(v)
-                                                       {
-                                                       if(consolechars[0]>0){
-                                                       for(k=14;k>=1;k--){
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[k][j]=consoletext[k-1][j];
-                                                       }
-                                                       consolechars[k]=consolechars[k-1];
-                                                       }
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[0][j]=' ';
-                                                       }
-                                                       if(v!=-4994)sprintf (consoletext[0], "Error #%d!!!",v);
-                                                       else sprintf (consoletext[0], "Could not open connection");
-
-                                                       consolechars[0]=255;
-                                                       consoleselected=0;
-                                                       }
-                                                       }
-                                                       else
-                                                       {
-                                                       donesomething=1;
-                                                       PlaySoundEx( consolesuccesssound, samp[consolesuccesssound], NULL, true);
-                                                       OPENAL_SetVolume(channels[consolesuccesssound], 256);
-                                                       OPENAL_SetPaused(channels[consolesuccesssound], false);
-
-                                                       if(consolechars[0]>0){
-                                                       for(k=14;k>=1;k--){
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[k][j]=consoletext[k-1][j];
-                                                       }
-                                                       consolechars[k]=consolechars[k-1];
-                                                       }
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[0][j]=' ';
-                                                       }
-                                                       sprintf (consoletext[0], "Connected to %s",theIPAddress);
-
-                                                       consolechars[0]=255;
-                                                       consoleselected=0;
-                                                       }
-                                                       }
-                                                       }
-
-                                                       if(Compare(consoletext[0],"host ",0,4)){
-                                                       unsigned char gameNameStr[32], playerNameStr[32];
-                                                       char gameName[32];//, playerName[32];
-                                                       NMUInt32 port;
-                                                       int players;
-                                                       int v;
-
-                                                       port = 25710;
-                                                       players =4;
-
-                                                       strcpy(gameName, "Host's game");
-                                                       strcpy(playerName, "Host");
-                                                       GameC2PStr( gameName, gameNameStr );
-                                                       GameC2PStr( playerName, playerNameStr );
-
-                                                       v=NetworkStartServer( (NMUInt16)port, players, gameNameStr, playerNameStr );
-                                                       if(v)
-                                                       {
-                                                       if(consolechars[0]>0){
-                                                       for(k=14;k>=1;k--){
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[k][j]=consoletext[k-1][j];
-                                                       }
-                                                       consolechars[k]=consolechars[k-1];
-                                                       }
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[0][j]=' ';
-                                                       }
-                                                       sprintf (consoletext[0], "Error #%d!!!",v);
-
-                                                       consolechars[0]=255;
-                                                       consoleselected=0;
-                                                       }
-                                                       }
-                                                       else
-                                                       {
-                                                       donesomething=1;
-                                                       PlaySoundEx( consolesuccesssound, samp[consolesuccesssound], NULL, true);
-                                                       OPENAL_SetVolume(channels[consolesuccesssound], 256);
-                                                       OPENAL_SetPaused(channels[consolesuccesssound], false);
-
-                                                       if(consolechars[0]>0){
-                                                       for(k=14;k>=1;k--){
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[k][j]=consoletext[k-1][j];
-                                                       }
-                                                       consolechars[k]=consolechars[k-1];
-                                                       }
-                                                       for(j=0;j<255;j++){
-                                                       consoletext[0][j]=' ';
-                                                       }
-                                                       sprintf (consoletext[0], "Game hosted");
-
-                                                       consolechars[0]=255;
-                                                       consoleselected=0;
-                                                       }
-                                                       }
-                                                       }
-                                                       */
-                                                       if(Compare(consoletext[0],"save ",0,4)){
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='M';
-                                                               mapname[7]='a';
-                                                               mapname[8]='p';
-                                                               mapname[9]='s';
-                                                               mapname[10]=':';
-                                                               for(j=5;j<consolechars[0];j++){
-                                                                       mapname[j-5+11]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-5+11]='\0';
-
-                                                               PlaySoundEx( consolesuccesssound, samp[consolesuccesssound], NULL, true);
-                                                               OPENAL_SetVolume(channels[consolesuccesssound], 256);
-                                                               OPENAL_SetPaused(channels[consolesuccesssound], false);
-
-                                                               int mapvers;
-                                                               mapvers=12;
-
-
-                                                               FILE                    *tfile;
-                                                               tfile=fopen( mapname, "wb" );
-                                                               fpackf(tfile, "Bi", mapvers);
-                                                               //fpackf(tfile, "Bi", indemo);
-                                                               fpackf(tfile, "Bi", maptype);
-                                                               fpackf(tfile, "Bi", hostile);
-                                                               fpackf(tfile, "Bf Bf", viewdistance, fadestart);
-                                                               fpackf(tfile, "Bb Bf Bf Bf", skyboxtexture, skyboxr, skyboxg, skyboxb);
-                                                               fpackf(tfile, "Bf Bf Bf", skyboxlightr, skyboxlightg, skyboxlightb);
-                                                               fpackf(tfile, "Bf Bf Bf Bf Bf Bi", player[0].coords.x, player[0].coords.y, player[0].coords.z, player[0].rotation, player[0].targetrotation, player[0].num_weapons);
-                                                               if(player[0].num_weapons>0&&player[0].num_weapons<5)
-                                                                       for(j=0;j<player[0].num_weapons;j++){
-                                                                               fpackf(tfile, "Bi", weapons.type[player[0].weaponids[j]]);
-                                                                       }
-
-                                                                       fpackf(tfile, "Bf Bf Bf", player[0].armorhead, player[0].armorhigh, player[0].armorlow);
-                                                                       fpackf(tfile, "Bf Bf Bf", player[0].protectionhead, player[0].protectionhigh, player[0].protectionlow);
-                                                                       fpackf(tfile, "Bf Bf Bf", player[0].metalhead, player[0].metalhigh, player[0].metallow);
-                                                                       fpackf(tfile, "Bf Bf", player[0].power, player[0].speedmult);
-
-                                                                       fpackf(tfile, "Bi", player[0].numclothes);
-
-                                                                       fpackf(tfile, "Bi Bi", player[0].whichskin, player[0].creature);
-
-                                                                       fpackf(tfile, "Bi", numdialogues);
-                                                                       if(numdialogues)
-                                                                               for(k=0;k<numdialogues;k++){
-                                                                                       fpackf(tfile, "Bi", numdialogueboxes[k]);
-                                                                                       fpackf(tfile, "Bi", dialoguetype[k]);
-                                                                                       for(l=0;l<10;l++){
-                                                                                               fpackf(tfile, "Bf Bf Bf", participantlocation[k][l].x, participantlocation[k][l].y, participantlocation[k][l].z);
-                                                                                               fpackf(tfile, "Bf", participantrotation[k][l]);
-                                                                                       }
-                                                                                       if(numdialogueboxes)
-                                                                                               for(l=0;l<numdialogueboxes[k];l++){
-                                                                                                       fpackf(tfile, "Bi", dialogueboxlocation[k][l]);
-                                                                                                       fpackf(tfile, "Bf", dialogueboxcolor[k][l][0]);
-                                                                                                       fpackf(tfile, "Bf", dialogueboxcolor[k][l][1]);
-                                                                                                       fpackf(tfile, "Bf", dialogueboxcolor[k][l][2]);
-                                                                                                       fpackf(tfile, "Bi", dialogueboxsound[k][l]);
-
-                                                                                                       templength=strlen(dialoguetext[k][l]);
-                                                                                                       fpackf(tfile, "Bi",(templength));
-                                                                                                       for(m=0;m<templength;m++){
-                                                                                                               fpackf(tfile, "Bb", dialoguetext[k][l][m]);
-                                                                                                               if(dialoguetext[k][l][m]=='\0')break;
-                                                                                                       }
-
-                                                                                                       templength=strlen(dialoguename[k][l]);
-                                                                                                       fpackf(tfile, "Bi",templength);
-                                                                                                       for(m=0;m<templength;m++){
-                                                                                                               fpackf(tfile, "Bb", dialoguename[k][l][m]);
-                                                                                                               if(dialoguename[k][l][m]=='\0')break;
-                                                                                                       }
-
-                                                                                                       fpackf(tfile, "Bf Bf Bf", dialoguecamera[k][l].x, dialoguecamera[k][l].y, dialoguecamera[k][l].z);
-                                                                                                       fpackf(tfile, "Bi", participantfocus[k][l]);
-                                                                                                       fpackf(tfile, "Bi", participantaction[k][l]);
-
-                                                                                                       for(m=0;m<10;m++)
-                                                                                                               fpackf(tfile, "Bf Bf Bf", participantfacing[k][l][m].x, participantfacing[k][l][m].y, participantfacing[k][l][m].z);
-
-                                                                                                       fpackf(tfile, "Bf Bf",dialoguecamerarotation[k][l],dialoguecamerarotation2[k][l]);
-                                                                                               }
-                                                                               }
-
-                                                                               if(player[0].numclothes)
-                                                                                       for(k=0;k<player[0].numclothes;k++){
-                                                                                               templength=strlen(player[0].clothes[k]);
-                                                                                               fpackf(tfile, "Bi", templength);
-                                                                                               for(l=0;l<templength;l++)
-                                                                                                       fpackf(tfile, "Bb", player[0].clothes[k][l]);
-                                                                                               fpackf(tfile, "Bf Bf Bf", player[0].clothestintr[k], player[0].clothestintg[k], player[0].clothestintb[k]);
-                                                                                       }
-
-                                                                                       fpackf(tfile, "Bi", environment);
-
-                                                                                       fpackf(tfile, "Bi", objects.numobjects);
-
-                                                                                       if(objects.numobjects)
-                                                                                               for(k=0;k<objects.numobjects;k++){
-                                                                                                       fpackf(tfile, "Bi Bf Bf Bf Bf Bf Bf", objects.type[k], objects.rotation[k], objects.rotation2[k], objects.position[k].x, objects.position[k].y, objects.position[k].z, objects.scale[k]);
-                                                                                               }
-
-                                                                                               fpackf(tfile, "Bi", numhotspots);
-                                                                                               if(numhotspots)
-                                                                                                       for(i=0;i<numhotspots;i++){
-                                                                                                               fpackf(tfile, "Bi Bf Bf Bf Bf", hotspottype[i],hotspotsize[i],hotspot[i].x,hotspot[i].y,hotspot[i].z);
-                                                                                                               templength=strlen(hotspottext[i]);
-                                                                                                               fpackf(tfile, "Bi",templength);
-                                                                                                               for(l=0;l<templength;l++)
-                                                                                                                       fpackf(tfile, "Bb", hotspottext[i][l]);
-                                                                                                       }
-
-                                                                                                       fpackf(tfile, "Bi", numplayers);
-                                                                                                       if(numplayers>1&&numplayers<maxplayers)
-                                                                                                               for(j=1;j<numplayers;j++){
-                                                                                                                       fpackf(tfile, "Bi Bi Bf Bf Bf Bi Bi Bf Bb Bf", player[j].whichskin, player[j].creature, player[j].coords.x, player[j].coords.y, player[j].coords.z, player[j].num_weapons, player[j].howactive, player[j].scale, player[j].immobile, player[j].rotation);
-                                                                                                                       if(player[j].num_weapons>0&&player[j].num_weapons<5)
-                                                                                                                               for(k=0;k<player[j].num_weapons;k++){
-                                                                                                                                       fpackf(tfile, "Bi", weapons.type[player[j].weaponids[k]]);
-                                                                                                                               }
-                                                                                                                               if(player[j].numwaypoints<30){
-                                                                                                                                       fpackf(tfile, "Bi", player[j].numwaypoints);
-                                                                                                                                       for(k=0;k<player[j].numwaypoints;k++){
-                                                                                                                                               fpackf(tfile, "Bf", player[j].waypoints[k].x);
-                                                                                                                                               fpackf(tfile, "Bf", player[j].waypoints[k].y);
-                                                                                                                                               fpackf(tfile, "Bf", player[j].waypoints[k].z);
-                                                                                                                                               fpackf(tfile, "Bi", player[j].waypointtype[k]);
-                                                                                                                                       }
-                                                                                                                                       fpackf(tfile, "Bi", player[j].waypoint);
-                                                                                                                               }
-                                                                                                                               else{
-                                                                                                                                       player[j].numwaypoints=0;
-                                                                                                                                       player[j].waypoint=0;
-                                                                                                                                       fpackf(tfile, "Bi Bi Bi", player[j].numwaypoints, player[j].waypoint, player[j].waypoint);
-                                                                                                                               }
-
-                                                                                                                               fpackf(tfile, "Bf Bf Bf", player[j].armorhead, player[j].armorhigh, player[j].armorlow);
-                                                                                                                               fpackf(tfile, "Bf Bf Bf", player[j].protectionhead, player[j].protectionhigh, player[j].protectionlow);
-                                                                                                                               fpackf(tfile, "Bf Bf Bf", player[j].metalhead, player[j].metalhigh, player[j].metallow);
-                                                                                                                               fpackf(tfile, "Bf Bf", player[j].power, player[j].speedmult);
-
-                                                                                                                               if(player[j].creature==wolftype){
-                                                                                                                                       headprop=player[j].proportionhead.x/1.1;
-                                                                                                                                       bodyprop=player[j].proportionbody.x/1.1;
-                                                                                                                                       armprop=player[j].proportionarms.x/1.1;
-                                                                                                                                       legprop=player[j].proportionlegs.x/1.1;
-                                                                                                                               }
-
-                                                                                                                               if(player[j].creature==rabbittype){
-                                                                                                                                       headprop=player[j].proportionhead.x/1.2;
-                                                                                                                                       bodyprop=player[j].proportionbody.x/1.05;
-                                                                                                                                       armprop=player[j].proportionarms.x/1.00;
-                                                                                                                                       legprop=player[j].proportionlegs.x/1.1;
-                                                                                                                               }
-
-                                                                                                                               fpackf(tfile, "Bf Bf Bf Bf", headprop, bodyprop, armprop, legprop);
-
-
-
-                                                                                                                               fpackf(tfile, "Bi", player[j].numclothes);
-                                                                                                                               if(player[j].numclothes)
-                                                                                                                                       for(k=0;k<player[j].numclothes;k++){
-                                                                                                                                               int templength;
-                                                                                                                                               templength=strlen(player[j].clothes[k]);
-                                                                                                                                               fpackf(tfile, "Bi", templength);
-                                                                                                                                               for(l=0;l<templength;l++)
-                                                                                                                                                       fpackf(tfile, "Bb", player[j].clothes[k][l]);
-                                                                                                                                               fpackf(tfile, "Bf Bf Bf", player[j].clothestintr[k], player[j].clothestintg[k], player[j].clothestintb[k]);
-                                                                                                                                       }
-                                                                                                               }
-
-                                                                                                               fpackf(tfile, "Bi", numpathpoints);
-                                                                                                               if(numpathpoints)
-                                                                                                                       for(j=0;j<numpathpoints;j++){
-                                                                                                                               fpackf(tfile, "Bf Bf Bf Bi", pathpoint[j].x, pathpoint[j].y, pathpoint[j].z, numpathpointconnect[j]);
-                                                                                                                               for(k=0;k<numpathpointconnect[j];k++){
-                                                                                                                                       fpackf(tfile, "Bi", pathpointconnect[j][k]);
-                                                                                                                               }
-                                                                                                                       }
-
-                                                                                                                       fpackf(tfile, "Bf Bf Bf Bf", mapcenter.x, mapcenter.y, mapcenter.z, mapradius);
-
-
-                                                                                                                       fclose(tfile);
-                                                                                                                       donesomething=1;
-
-                                                                                                                       /*
-                                                                                                                       FILE                    *tfile;
-                                                                                                                       tfile=fopen( mapname, "wb" );
-                                                                                                                       fwrite( &mapvers, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].coords.x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[0].coords.y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[0].coords.z, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[0].rotation, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[0].targetrotation, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[0].num_weapons, 1, sizeof(int), tfile );
-                                                                                                                       if(player[0].num_weapons>0&&player[0].num_weapons<5)
-                                                                                                                       for(j=0;j<player[0].num_weapons;j++){
-                                                                                                                       fwrite( &weapons.type[player[0].weaponids[j]], 1, sizeof(int), tfile );
-                                                                                                                       }
-
-                                                                                                                       fwrite( &player[0].armorhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].armorhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].armorlow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].protectionhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].protectionhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].protectionlow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].metalhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].metalhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].metallow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].power, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[0].speedmult, 1, sizeof(int), tfile );
-
-                                                                                                                       fwrite( &player[0].numclothes, 1, sizeof(int), tfile );
-                                                                                                                       if(player[0].numclothes)
-                                                                                                                       for(k=0;k<player[0].numclothes;k++){
-                                                                                                                       int templength;
-                                                                                                                       templength=strlen(player[0].clothes[k]);
-                                                                                                                       fwrite( &templength,1,sizeof(int),tfile);
-                                                                                                                       for(l=0;l<templength;l++)
-                                                                                                                       fwrite( &player[0].clothes[k][l],1,sizeof(char),tfile);
-                                                                                                                       fwrite( &player[0].clothestintr[k],1,sizeof(float),tfile);
-                                                                                                                       fwrite( &player[0].clothestintg[k],1,sizeof(float),tfile);
-                                                                                                                       fwrite( &player[0].clothestintb[k],1,sizeof(float),tfile);
-                                                                                                                       }
-
-                                                                                                                       fwrite( &environment, 1, sizeof(int), tfile );
-
-                                                                                                                       fwrite( &objects.numobjects, 1, sizeof(int), tfile );
-
-                                                                                                                       for(k=0;k<objects.numobjects;k++){
-                                                                                                                       fwrite( &objects.type[k], 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &objects.rotation[k], 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &objects.rotation2[k], 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &objects.position[k].x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &objects.position[k].y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &objects.position[k].z, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &objects.scale[k], 1, sizeof(float), tfile );
-                                                                                                                       }
-
-                                                                                                                       fwrite( &numplayers, 1, sizeof(int), tfile );
-                                                                                                                       if(numplayers>1&&numplayers<maxplayers)
-                                                                                                                       for(j=1;j<numplayers;j++){
-                                                                                                                       fwrite( &player[j].whichskin, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].creature, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].coords.x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[j].coords.y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[j].coords.z, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[j].num_weapons, 1, sizeof(int), tfile );
-                                                                                                                       if(player[j].num_weapons>0&&player[j].num_weapons<5)
-                                                                                                                       for(k=0;k<player[j].num_weapons;k++){
-                                                                                                                       fwrite( &weapons.type[player[j].weaponids[k]], 1, sizeof(int), tfile );
-                                                                                                                       }
-                                                                                                                       if(player[j].numwaypoints<30){
-                                                                                                                       fwrite( &player[j].numwaypoints, 1, sizeof(int), tfile );
-                                                                                                                       for(k=0;k<player[j].numwaypoints;k++){
-                                                                                                                       fwrite( &player[j].waypoints[k].x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[j].waypoints[k].y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &player[j].waypoints[k].z, 1, sizeof(float), tfile );
-                                                                                                                       }
-                                                                                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                                                                                       //fwrite( &player[j].jumppath, 1, sizeof(bool), tfile );
-                                                                                                                       }
-                                                                                                                       else{
-                                                                                                                       player[j].numwaypoints=0;
-                                                                                                                       player[j].waypoint=0;
-                                                                                                                       fwrite( &player[j].numwaypoints, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                                                                                       }
-                                                                                                                       fwrite( &player[j].armorhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].armorhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].armorlow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].protectionhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].protectionhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].protectionlow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].metalhead, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].metalhigh, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].metallow, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].power, 1, sizeof(int), tfile );
-                                                                                                                       fwrite( &player[j].speedmult, 1, sizeof(int), tfile );
-
-                                                                                                                       fwrite( &player[j].numclothes, 1, sizeof(int), tfile );
-                                                                                                                       if(player[j].numclothes)
-                                                                                                                       for(k=0;k<player[j].numclothes;k++){
-                                                                                                                       int templength;
-                                                                                                                       templength=strlen(player[j].clothes[k]);
-                                                                                                                       fwrite( &templength,1,sizeof(int),tfile);
-                                                                                                                       for(l=0;l<templength;l++)
-                                                                                                                       fwrite( &player[j].clothes[k][l],1,sizeof(char),tfile);
-                                                                                                                       fwrite( &player[j].clothestintr[k],1,sizeof(float),tfile);
-                                                                                                                       fwrite( &player[j].clothestintg[k],1,sizeof(float),tfile);
-                                                                                                                       fwrite( &player[j].clothestintb[k],1,sizeof(float),tfile);
-                                                                                                                       }
-                                                                                                                       }
-                                                                                                                       fwrite( &numpathpoints, 1, sizeof(int), tfile );
-                                                                                                                       if(numpathpoints)
-                                                                                                                       for(j=0;j<numpathpoints;j++){
-                                                                                                                       fwrite( &pathpoint[j].x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &pathpoint[j].y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &pathpoint[j].z, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &numpathpointconnect[j], 1, sizeof(int), tfile );
-                                                                                                                       for(k=0;k<numpathpointconnect[j];k++){
-                                                                                                                       fwrite( &pathpointconnect[j][k], 1, sizeof(int), tfile );
-                                                                                                                       }
-                                                                                                                       }
-
-                                                                                                                       fwrite( &mapcenter.x, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &mapcenter.y, 1, sizeof(float), tfile );
-                                                                                                                       fwrite( &mapcenter.z, 1, sizeof(float), tfile );
-
-                                                                                                                       fwrite( &mapradius, 1, sizeof(float), tfile );
-
-                                                                                                                       fclose(tfile);
-                                                                                                                       donesomething=1;*/
-                                                       }
-                                                       /*
-                                                       if(Compare(consoletext[0],"save ",0,4)){
-                                                       mapname[0]=':';
-                                                       mapname[1]='D';
-                                                       mapname[2]='a';
-                                                       mapname[3]='t';
-                                                       mapname[4]='a';
-                                                       mapname[5]=':';
-                                                       mapname[6]='M';
-                                                       mapname[7]='a';
-                                                       mapname[8]='p';
-                                                       mapname[9]='s';
-                                                       mapname[10]=':';
-                                                       for(j=5;j<consolechars[0];j++){
-                                                       mapname[j-5+11]=consoletext[0][j];
-                                                       }
-                                                       mapname[consolechars[0]-5+11]='\0';
-
-                                                       PlaySoundEx( consolesuccesssound, samp[consolesuccesssound], NULL, true);
-                                                       OPENAL_SetVolume(channels[consolesuccesssound], 256);
-                                                       OPENAL_SetPaused(channels[consolesuccesssound], false);
-
-                                                       FILE                    *tfile;
-                                                       tfile=fopen( mapname, "wb" );
-                                                       fwrite( &player[0].coords, 1, sizeof(XYZ), tfile );
-                                                       fwrite( &player[0].rotation, 1, sizeof(float), tfile );
-                                                       fwrite( &player[0].targetrotation, 1, sizeof(float), tfile );
-                                                       fwrite( &player[0].num_weapons, 1, sizeof(int), tfile );
-                                                       if(player[0].num_weapons>0&&player[0].num_weapons<5)
-                                                       for(j=0;j<player[0].num_weapons;j++){
-                                                       fwrite( &weapons.type[player[0].weaponids[j]], 1, sizeof(int), tfile );
-                                                       }
-                                                       fwrite( &environment, 1, sizeof(int), tfile );
-
-                                                       fwrite( &objects.numobjects, 1, sizeof(int), tfile );
-                                                       fwrite( &objects.type, 1, sizeof(int)*objects.numobjects, tfile );
-                                                       fwrite( &objects.rotation, 1, sizeof(float)*objects.numobjects, tfile );
-                                                       fwrite( &objects.position, 1, sizeof(XYZ)*objects.numobjects, tfile );
-                                                       fwrite( &objects.scale, 1, sizeof(float)*objects.numobjects, tfile );
-
-                                                       fwrite( &numplayers, 1, sizeof(int), tfile );
-                                                       if(numplayers>1&&numplayers<maxplayers)
-                                                       for(j=1;j<numplayers;j++){
-                                                       fwrite( &player[j].coords, 1, sizeof(XYZ), tfile );
-                                                       fwrite( &player[j].num_weapons, 1, sizeof(int), tfile );
-                                                       if(player[j].num_weapons>0&&player[j].num_weapons<5)
-                                                       for(k=0;k<player[j].num_weapons;k++){
-                                                       fwrite( &weapons.type[player[j].weaponids[k]], 1, sizeof(int), tfile );
-                                                       }
-                                                       if(player[j].numwaypoints<30){
-                                                       fwrite( &player[j].numwaypoints, 1, sizeof(int), tfile );
-                                                       fwrite( &player[j].waypoints, 1, sizeof(XYZ)*player[j].numwaypoints, tfile );
-                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                       //fwrite( &player[j].jumppath, 1, sizeof(bool), tfile );
-                                                       }
-                                                       else{
-                                                       player[j].numwaypoints=0;
-                                                       player[j].waypoint=0;
-                                                       fwrite( &player[j].numwaypoints, 1, sizeof(int), tfile );
-                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                       fwrite( &player[j].waypoint, 1, sizeof(int), tfile );
-                                                       }
-                                                       }
-                                                       fwrite( &numpathpoints, 1, sizeof(int), tfile );
-                                                       if(numpathpoints)
-                                                       for(j=0;j<numpathpoints;j++){
-                                                       fwrite( &pathpoint[j], 1, sizeof(XYZ), tfile );
-                                                       fwrite( &numpathpointconnect[j], 1, sizeof(int), tfile );
-                                                       for(k=0;k<numpathpointconnect[j];k++){
-                                                       fwrite( &pathpointconnect[j][k], 1, sizeof(int), tfile );
-                                                       }
-                                                       }
-                                                       fclose(tfile);
-                                                       donesomething=1;
-                                                       }*/
-                                                       if(Compare(consoletext[0],"cellar door ",0,11)||Compare(consoletext[0],"cellardoor ",0,10)){
-                                                               LoadTextureSave(":Data:Textures:Furdarko.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
-                                                       }
-                                                       /*if(Compare(consoletext[0],"Pants ",0,5)){
-                                                       AddClothes(":Data:Textures:Pants.png",0,1,&player[i].skeleton.skinText[0],&player[i].skeleton.skinsize);
-                                                       player[i].DoMipmaps(5,0,0,player[i].skeleton.skinsize,player[i].skeleton.skinsize);
-                                                       donesomething=1;
-                                                       }*/
-
-                                                       if(Compare(consoletext[0],"tintr ",0,5)||Compare(consoletext[0],"Tintr ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               tintr=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"speed ",0,5)||Compare(consoletext[0],"Speed ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               player[0].speedmult=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"strength ",0,8)||Compare(consoletext[0],"Strength ",0,8)){
-                                                               for(j=9;j<consolechars[0];j++){
-                                                                       mapname[j-9]=consoletext[0][j];
-                                                               }
-
-                                                               player[0].power=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"viewdistance ",0,12)||Compare(consoletext[0],"Viewdistance ",0,12)){
-                                                               for(j=13;j<consolechars[0];j++){
-                                                                       mapname[j-13]=consoletext[0][j];
-                                                               }
-
-                                                               viewdistance=atof(mapname)*100;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"fadestart ",0,9)||Compare(consoletext[0],"Fadestart ",0,9)){
-                                                               for(j=10;j<consolechars[0];j++){
-                                                                       mapname[j-10]=consoletext[0][j];
-                                                               }
-
-                                                               fadestart=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"power ",0,5)||Compare(consoletext[0],"Power ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               player[0].power=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"slomo ",0,5)||Compare(consoletext[0],"Slomo ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               slomospeed=atof(mapname);
-                                                               slomo=1-slomo;
-                                                               slomodelay=1000;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"slofreq ",0,7)||Compare(consoletext[0],"Slofreq ",0,7)){
-                                                               for(j=8;j<consolechars[0];j++){
-                                                                       mapname[j-8]=consoletext[0][j];
-                                                               }
-
-                                                               slomofreq=atoi(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"size ",0,4)||Compare(consoletext[0],"Size ",0,4)){
-                                                               for(j=5;j<consolechars[0];j++){
-                                                                       mapname[j-5]=consoletext[0][j];
-                                                               }
-
-                                                               player[0].scale=atof(mapname)*.2;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"sizenear ",0,8)||Compare(consoletext[0],"Sizenear ",0,8)){
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
-
-                                                                       for(j=9;j<consolechars[0];j++){
-                                                                               mapname[j-9]=consoletext[0][j];
-                                                                       }
-
-                                                                       player[closest].scale=atof(mapname)*.2;
-
-                                                                       donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"proportionnear ",0,14)||Compare(consoletext[0],"Proportionnear ",0,14)){
-                                                               int startpoint;
-                                                               int alldone;
-
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
-
-                                                                       alldone=0;
-                                                                       startpoint=15;
-                                                                       j=startpoint;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       headprop=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       bodyprop=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       armprop=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       legprop=atof(mapname);
-
-                                                                       if(player[closest].creature==wolftype){
-                                                                               player[closest].proportionhead=1.1*headprop;
-                                                                               player[closest].proportionbody=1.1*bodyprop;
-                                                                               player[closest].proportionarms=1.1*armprop;
-                                                                               player[closest].proportionlegs=1.1*legprop;
-                                                                       }
-
-                                                                       if(player[closest].creature==rabbittype){
-                                                                               player[closest].proportionhead=1.2*headprop;
-                                                                               player[closest].proportionbody=1.05*bodyprop;
-                                                                               player[closest].proportionarms=1.00*armprop;
-                                                                               player[closest].proportionlegs=1.1*legprop;
-                                                                               player[closest].proportionlegs.y=1.05*legprop;
-                                                                       }
-
-                                                                       donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"sizemin ",0,7)||Compare(consoletext[0],"Sizemin ",0,7)){
-                                                               for(i=1;i<numplayers;i++){
-                                                                       if(player[i].scale<0.8*0.2)player[i].scale=0.8*0.2;
-                                                               }
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"tutorial ",0,8)||Compare(consoletext[0],"Tutorial ",0,8)){
-                                                               for(j=9;j<consolechars[0];j++){
-                                                                       mapname[j-9]=consoletext[0][j];
-                                                               }
-
-                                                               tutoriallevel=atoi(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"tintg ",0,5)||Compare(consoletext[0],"Tintg ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               tintg=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"tintb ",0,5)||Compare(consoletext[0],"Tintb ",0,5)){
-                                                               for(j=6;j<consolechars[0];j++){
-                                                                       mapname[j-6]=consoletext[0][j];
-                                                               }
-
-                                                               tintb=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"hostile ",0,7)){
-                                                               for(j=8;j<consolechars[0];j++){
-                                                                       mapname[j-8]=consoletext[0][j];
-                                                               }
-
-                                                               hostile=atoi(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"type active ",0,11)){
-                                                               editoractive=typeactive;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"indemo ",0,6)){
-                                                               indemo=1;
-                                                               hotspot[numhotspots]=player[0].coords;
-                                                               hotspotsize[numhotspots]=0;
-                                                               hotspottype[numhotspots]=-111;
-                                                               mapname[0]='\0';
-                                                               strcpy(hotspottext[numhotspots],"mapname");
-                                                               numhotspots++;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"notindemo ",0,9)){
-                                                               indemo=0;
-                                                               numhotspots--;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"type sitting ",0,12)){
-                                                               editoractive=typesitting;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"type sitting wall ",0,17)){
-                                                               editoractive=typesittingwall;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"type sleeping ",0,13)){
-                                                               editoractive=typesleeping;
-
-                                                               donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"type dead1 ",0,10)){
-                                                               editoractive=typedead1;
-
-                                                               donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"type dead2 ",0,10)){
-                                                               editoractive=typedead2;
-
-                                                               donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"type dead3 ",0,10)){
-                                                               editoractive=typedead3;
-                                                               donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"type dead4 ",0,10)){
-                                                               editoractive=typedead4;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"path keepwalking ",0,16)){
-                                                               editorpathtype=wpkeepwalking;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"path pause ",0,10)){
-                                                               editorpathtype=wppause;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"mapkilleveryone ",0,15)){
-                                                               maptype=mapkilleveryone;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"mapgosomewhere ",0,14)){
-                                                               maptype=mapgosomewhere;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"mapkillsomeone ",0,14)){
-                                                               maptype=mapkillsomeone;
-
-                                                               donesomething=1;
-
-                                                       }
-
-                                                       if(Compare(consoletext[0],"mapkillmost ",0,11)){
-                                                               maptype=mapkillmost;
-
-                                                               donesomething=1;
-
-                                                       }
-
-                                                       if(Compare(consoletext[0],"hs ",0,2)){
-                                                               int startpoint;
-                                                               int alldone;
-
-                                                               hotspot[numhotspots]=player[0].coords;
-
-                                                               alldone=0;
-                                                               startpoint=3;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               hotspotsize[numhotspots]=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               hotspottype[numhotspots]=atoi(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\n';
-                                                               mapname[j-startpoint+1]='\0';
-
-                                                               strcpy(hotspottext[numhotspots],mapname);
-
-                                                               numhotspots++;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"dialogue ",0,8)){
-                                                               int startpoint;
-                                                               int alldone;
-
-                                                               alldone=0;
-                                                               startpoint=9;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-                                                               startpoint=j+1;
-
-                                                               dialoguetype[numdialogues]=atoi(mapname);
-
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='D';
-                                                               mapname[7]='i';
-                                                               mapname[8]='a';
-                                                               mapname[9]='l';
-                                                               mapname[10]='o';
-                                                               mapname[11]='g';
-                                                               mapname[12]='u';
-                                                               mapname[13]='e';
-                                                               mapname[14]='s';
-                                                               mapname[15]=':';
-                                                               for(j=startpoint;j<consolechars[0];j++){
-                                                                       mapname[j-startpoint+16]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-startpoint+16]='.';
-                                                               mapname[consolechars[0]-startpoint+17]='t';
-                                                               mapname[consolechars[0]-startpoint+18]='x';
-                                                               mapname[consolechars[0]-startpoint+19]='t';
-                                                               mapname[consolechars[0]-startpoint+20]='\0';
-
-                                                               for(j=0;j<max_dialoguelength;j++){
-                                                                       for(k=0;k<128;k++){
-                                                                               dialoguetext[numdialogues][j][k]='\0';
-                                                                       }
-                                                                       for(k=0;k<64;k++){
-                                                                               dialoguename[numdialogues][j][k]='\0';
-                                                                       }
-                                                               }
-
-                                                               ifstream ipstream(ConvertFileName(mapname));
-                                                               ipstream.ignore(256,':');
-                                                               ipstream >> numdialogueboxes[numdialogues];
-                                                               for(i=0;i<numdialogueboxes[numdialogues];i++){
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,' ');
-                                                                       ipstream >> dialogueboxlocation[numdialogues][i];
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream >> dialogueboxcolor[numdialogues][i][0];
-                                                                       ipstream >> dialogueboxcolor[numdialogues][i][1];
-                                                                       ipstream >> dialogueboxcolor[numdialogues][i][2];
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.getline(dialoguename[numdialogues][i],64);
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,' ');
-                                                                       ipstream.getline(dialoguetext[numdialogues][i],128);
-                                                                       for(j=0;j<128;j++){
-                                                                               if(dialoguetext[numdialogues][i][j]=='\\')dialoguetext[numdialogues][i][j]='\n';
-                                                                       }
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream >> dialogueboxsound[numdialogues][i];
-                                                               }
-
-                                                               for(i=0;i<numdialogueboxes[numdialogues];i++){
-                                                                       for(j=0;j<numplayers;j++){
-                                                                               participantfacing[numdialogues][i][j]=player[j].facing;
-                                                                       }
-                                                               }
-                                                               ipstream.close();
-
-                                                               directing=1;
-                                                               indialogue=0;
-                                                               whichdialogue=numdialogues;
-
-
-                                                               numdialogues++;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"fixdialogue ",0,11)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               int whichdi;
-
-                                                               alldone=0;
-                                                               startpoint=12;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-                                                               startpoint=j+1;
-
-                                                               whichdi=atoi(mapname);
-
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='D';
-                                                               mapname[7]='i';
-                                                               mapname[8]='a';
-                                                               mapname[9]='l';
-                                                               mapname[10]='o';
-                                                               mapname[11]='g';
-                                                               mapname[12]='u';
-                                                               mapname[13]='e';
-                                                               mapname[14]='s';
-                                                               mapname[15]=':';
-                                                               for(j=startpoint;j<consolechars[0];j++){
-                                                                       mapname[j-startpoint+16]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-startpoint+16]='.';
-                                                               mapname[consolechars[0]-startpoint+17]='t';
-                                                               mapname[consolechars[0]-startpoint+18]='x';
-                                                               mapname[consolechars[0]-startpoint+19]='t';
-                                                               mapname[consolechars[0]-startpoint+20]='\0';
-
-                                                               for(j=0;j<max_dialoguelength;j++){
-                                                                       for(k=0;k<128;k++){
-                                                                               dialoguetext[whichdi][j][k]='\0';
-                                                                       }
-                                                                       for(k=0;k<64;k++){
-                                                                               dialoguename[whichdi][j][k]='\0';
-                                                                       }
-                                                               }
-
-                                                               ifstream ipstream(ConvertFileName(mapname));
-                                                               ipstream.ignore(256,':');
-                                                               ipstream >> numdialogueboxes[whichdi];
-                                                               for(i=0;i<numdialogueboxes[whichdi];i++){
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,' ');
-                                                                       ipstream >> dialogueboxlocation[whichdi][i];
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream >> dialogueboxcolor[whichdi][i][0];
-                                                                       ipstream >> dialogueboxcolor[whichdi][i][1];
-                                                                       ipstream >> dialogueboxcolor[whichdi][i][2];
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.getline(dialoguename[whichdi][i],64);
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream.ignore(256,' ');
-                                                                       ipstream.getline(dialoguetext[whichdi][i],128);
-                                                                       for(j=0;j<128;j++){
-                                                                               if(dialoguetext[whichdi][i][j]=='\\')dialoguetext[whichdi][i][j]='\n';
-                                                                       }
-                                                                       ipstream.ignore(256,':');
-                                                                       ipstream >> dialogueboxsound[whichdi][i];
-                                                               }
-
-                                                               ipstream.close();
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"fixtype ",0,7)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               int whichdi;
-
-                                                               alldone=0;
-                                                               startpoint=8;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-                                                               dialoguetype[0]=atoi(mapname);
-
-                                                               startpoint=j+1;
-
-                                                               donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"fixrotation ",0,11)){
-                                                               participantrotation[whichdialogue][participantfocus[whichdialogue][indialogue]]=player[participantfocus[whichdialogue][indialogue]].rotation;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"ddialogue ",0,9)){
-                                                               numdialogues--;
-                                                               if(numdialogues<0)numdialogues=0;
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"immobile ",0,8)){
-                                                               player[0].immobile=1;
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"mobile ",0,6)){
-                                                               player[0].immobile=0;
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"play ",0,4)){
-                                                               int startpoint;
-                                                               int alldone;
-
-                                                               alldone=0;
-                                                               startpoint=5;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-                                                               startpoint=j+1;
-
-                                                               whichdialogue=atoi(mapname);
-
-                                                               if(numdialogues>whichdialogue){
-                                                                       for(i=0;i<numdialogueboxes[whichdialogue];i++){
-                                                                               player[participantfocus[whichdialogue][i]].coords=participantlocation[whichdialogue][participantfocus[whichdialogue][i]];
-                                                                               player[participantfocus[whichdialogue][i]].rotation=participantrotation[whichdialogue][participantfocus[whichdialogue][i]];
-                                                                               player[participantfocus[whichdialogue][i]].targetrotation=participantrotation[whichdialogue][participantfocus[whichdialogue][i]];
-                                                                               player[participantfocus[whichdialogue][i]].velocity=0;
-                                                                               player[participantfocus[whichdialogue][i]].targetanimation=player[participantfocus[whichdialogue][i]].getIdle();
-                                                                               player[participantfocus[whichdialogue][i]].targetframe=0;
-                                                                       }
-
-                                                                       directing=0;
-                                                                       indialogue=0;
-
-                                                                       donesomething=1;
-
-                                                                       //if(dialogueboxsound[whichdialogue][indialogue]!=0){
-                                                                       float gLoc[3];
-                                                                       float vel[3];
-                                                                       XYZ temppos;
-                                                                       temppos=player[participantfocus[whichdialogue][indialogue]].coords;
-                                                                       temppos=temppos-viewer;
-                                                                       Normalise(&temppos);
-                                                                       temppos+=viewer;
-
-                                                                       gLoc[0]=temppos.x;
-                                                                       gLoc[1]=temppos.y;
-                                                                       gLoc[2]=temppos.z;
-                                                                       vel[0]=0;
-                                                                       vel[1]=0;
-                                                                       vel[2]=0;
-                                                                       int whichsoundplay;
-                                                                       whichsoundplay=rabbitchitter;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==2)whichsoundplay=rabbitchitter2;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==3)whichsoundplay=rabbitpainsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==4)whichsoundplay=rabbitpain1sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==5)whichsoundplay=rabbitattacksound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==6)whichsoundplay=rabbitattack2sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==7)whichsoundplay=rabbitattack3sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==8)whichsoundplay=rabbitattack4sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==9)whichsoundplay=growlsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==10)whichsoundplay=growl2sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==11)whichsoundplay=snarlsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==12)whichsoundplay=snarl2sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==13)whichsoundplay=barksound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==14)whichsoundplay=bark2sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==15)whichsoundplay=bark3sound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==16)whichsoundplay=barkgrowlsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==-1)whichsoundplay=fireendsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==-2)whichsoundplay=firestartsound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==-3)whichsoundplay=consolesuccesssound;
-                                                                       if(dialogueboxsound[whichdialogue][indialogue]==-4)whichsoundplay=consolefailsound;
-                                                                       PlaySoundEx( whichsoundplay, samp[whichsoundplay], NULL, true);
-                                                                       OPENAL_3D_SetAttributes(channels[whichsoundplay], gLoc, vel);
-                                                                       OPENAL_SetVolume(channels[whichsoundplay], 256);
-                                                                       OPENAL_SetPaused(channels[whichsoundplay], false);
-                                                                       //}
-                                                               }
-                                                       }
-
-
-
-
-                                                       if(Compare(consoletext[0],"dhs ",0,3)){
-                                                               numhotspots--;
-                                                               if(numhotspots<0)numhotspots=0;
-                                                               donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"proportion ",0,10)||Compare(consoletext[0],"Proportion ",0,4)){
-                                                               int startpoint;
-                                                               int alldone;
-
-                                                               alldone=0;
-                                                               startpoint=11;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               headprop=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               bodyprop=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               armprop=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               legprop=atof(mapname);
-
-                                                               if(player[0].creature==wolftype){
-                                                                       player[0].proportionhead=1.1*headprop;
-                                                                       player[0].proportionbody=1.1*bodyprop;
-                                                                       player[0].proportionarms=1.1*armprop;
-                                                                       player[0].proportionlegs=1.1*legprop;
-                                                               }
-
-                                                               if(player[0].creature==rabbittype){
-                                                                       player[0].proportionhead=1.2*headprop;
-                                                                       player[0].proportionbody=1.05*bodyprop;
-                                                                       player[0].proportionarms=1.00*armprop;
-                                                                       player[0].proportionlegs=1.1*legprop;
-                                                                       player[0].proportionlegs.y=1.05*legprop;
-                                                               }
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"allimmobile ",0,11)||Compare(consoletext[0],"Allimmobile ",0,11)){
-                                                               for(i=0;i<numplayers;i++){
-                                                                       if(i>0)player[i].immobile=1;
-                                                               }
-                                                               donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"default ",0,7)||Compare(consoletext[0],"Default ",0,7)){
-                                                               player[0].armorhead=1;
-                                                               player[0].armorhigh=1;
-                                                               player[0].armorlow=1;
-                                                               player[0].protectionhead=1;
-                                                               player[0].protectionhigh=1;
-                                                               player[0].protectionlow=1;
-                                                               player[0].metalhead=1;
-                                                               player[0].metalhigh=1;
-                                                               player[0].metallow=1;
-                                                               player[0].power=1;
-                                                               player[0].speedmult=1;
-                                                               player[0].scale=1;
-
-                                                               if(player[0].creature==wolftype){
-                                                                       player[0].proportionhead=1.1;
-                                                                       player[0].proportionbody=1.1;
-                                                                       player[0].proportionarms=1.1;
-                                                                       player[0].proportionlegs=1.1;
-                                                               }
-
-                                                               if(player[0].creature==rabbittype){
-                                                                       player[0].proportionhead=1.2;
-                                                                       player[0].proportionbody=1.05;
-                                                                       player[0].proportionarms=1.00;
-                                                                       player[0].proportionlegs=1.1;
-                                                                       player[0].proportionlegs.y=1.05;
-                                                               }
-
-                                                               player[0].numclothes=0;
-                                                               if(player[0].whichskin==0){
-                                                                       LoadTextureSave(":Data:Textures:Fur3.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==1){
-                                                                       LoadTextureSave(":Data:Textures:Fur.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==2){
-                                                                       LoadTextureSave(":Data:Textures:Fur2.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==3){
-                                                                       LoadTextureSave(":Data:Textures:Lynx.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==4){
-                                                                       LoadTextureSave(":Data:Textures:Otter.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==5){
-                                                                       LoadTextureSave(":Data:Textures:Opal.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==6){
-                                                                       LoadTextureSave(":Data:Textures:Sable.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==7){
-                                                                       LoadTextureSave(":Data:Textures:Chocolate.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==8){
-                                                                       LoadTextureSave(":Data:Textures:BW2.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-                                                               else if(player[0].whichskin==9){
-                                                                       LoadTextureSave(":Data:Textures:WB2.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               }
-
-                                                               editoractive=typeactive;
-                                                               player[0].immobile=0;
-
-
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"tint ",0,4)||Compare(consoletext[0],"Tint ",0,4)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=5;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               tintr=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               tintg=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               tintb=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"sky tint ",0,8)||Compare(consoletext[0],"Sky Tint ",0,8)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=9;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxr=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxg=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxb=atof(mapname);
-
-                                                               skyboxlightr=skyboxr;
-                                                               skyboxlightg=skyboxg;
-                                                               skyboxlightb=skyboxb;
-
-                                                               SetUpLighting();
-
-                                                               //if(skyboxtexture){
-                                                               terrain.DoShadows();
-                                                               objects.DoShadows();
-                                                               /*}
-                                                               else terrain.DoLighting();
-                                                               */
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"sky light ",0,9)||Compare(consoletext[0],"Sky Light ",0,9)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=10;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxlightr=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxlightg=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               skyboxlightb=atof(mapname);
-
-                                                               SetUpLighting();
-
-                                                               //if(skyboxtexture){
-                                                               terrain.DoShadows();
-                                                               objects.DoShadows();
-                                                               /*}
-                                                               else terrain.DoLighting();
-                                                               */
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"skybox ",0,6)||Compare(consoletext[0],"Skybox ",0,6)){
-                                                               skyboxtexture=1-skyboxtexture;
-
-                                                               SetUpLighting();
-                                                               //if(skyboxtexture){
-                                                               terrain.DoShadows();
-                                                               objects.DoShadows();
-                                                               /*}
-                                                               else terrain.DoLighting();
-                                                               */
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"protection ",0,10)||Compare(consoletext[0],"Protection ",0,10)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=11;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].protectionhead=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].protectionhigh=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].protectionlow=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"armor ",0,5)||Compare(consoletext[0],"Armor ",0,5)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=6;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].armorhead=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].armorhigh=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].armorlow=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"protectionreset ",0,15)||Compare(consoletext[0],"Protectionreset ",0,15)){
-                                                               for(i=0;i<numplayers;i++){
-                                                                       player[i].protectionhead=1.0;
-                                                                       player[i].protectionhigh=1.0;
-                                                                       player[i].protectionlow=1.0;
-                                                                       player[i].armorhead=1.0;
-                                                                       player[i].armorhigh=1.0;
-                                                                       player[i].armorlow=1.0;
-                                                               }
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"protectionnear ",0,14)||Compare(consoletext[0],"Protectionnear ",0,14)){
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
-
-                                                                       int startpoint;
-                                                                       int alldone;
-                                                                       alldone=0;
-                                                                       startpoint=15;
-                                                                       j=startpoint;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].protectionhead=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].protectionhigh=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].protectionlow=atof(mapname);
-
-                                                                       donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"armornear ",0,9)||Compare(consoletext[0],"Armornear ",0,9)){
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
-                                                                       int startpoint;
-                                                                       int alldone;
-                                                                       alldone=0;
-                                                                       startpoint=10;
-                                                                       j=startpoint;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].armorhead=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].armorhigh=atof(mapname);
-
-                                                                       j++;
-                                                                       startpoint=j;
-                                                                       while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                               mapname[j-startpoint]=consoletext[0][j];
-                                                                               j++;
-                                                                               if(consoletext[0][j]=='\0')alldone=1;
-                                                                       }
-                                                                       mapname[j-startpoint]='\0';
-
-                                                                       player[closest].armorlow=atof(mapname);
-
-                                                                       donesomething=1;
-                                                       }
-
-
-                                                       if(Compare(consoletext[0],"metal ",0,5)||Compare(consoletext[0],"Metal ",0,5)){
-                                                               int startpoint;
-                                                               int alldone;
-                                                               alldone=0;
-                                                               startpoint=6;
-                                                               j=startpoint;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].metalhead=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].metalhigh=atof(mapname);
-
-                                                               j++;
-                                                               startpoint=j;
-                                                               while(consoletext[0][j]!='\0'&&consoletext[0][j]!=' '&&!alldone&&j<255){
-                                                                       mapname[j-startpoint]=consoletext[0][j];
-                                                                       j++;
-                                                                       if(consoletext[0][j]=='\0')alldone=1;
-                                                               }
-
-                                                               mapname[j-startpoint]='\0';
-
-                                                               player[0].metallow=atof(mapname);
-
-                                                               donesomething=1;
-                                                       }
-
-                                                       if(Compare(consoletext[0],"noclothesnear ",0,13)||Compare(consoletext[0],"Noclothesnear ",0,13)){
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
-                                                                       player[closest].numclothes=0;
-                                                                       if(player[closest].whichskin==0){
-                                                                               LoadTextureSave(":Data:Textures:Fur3.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==1){
-                                                                               LoadTextureSave(":Data:Textures:Fur.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==2){
-                                                                               LoadTextureSave(":Data:Textures:Fur2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==3){
-                                                                               LoadTextureSave(":Data:Textures:Lynx.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==4){
-                                                                               LoadTextureSave(":Data:Textures:Otter.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==5){
-                                                                               LoadTextureSave(":Data:Textures:Opal.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==6){
-                                                                               LoadTextureSave(":Data:Textures:Sable.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==7){
-                                                                               LoadTextureSave(":Data:Textures:Chocolate.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==8){
-                                                                               LoadTextureSave(":Data:Textures:BW2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-                                                                       else if(player[closest].whichskin==9){
-                                                                               LoadTextureSave(":Data:Textures:WB2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                       }
-
-                                                                       donesomething=1;
-                                                       }
+                                                               flashg=0;
+                                                               flashb=0;
+                                                               flashamount=1;
+                                                               flashdelay=1;
 
-                                                       if(Compare(consoletext[0],"noclothes ",0,9)||Compare(consoletext[0],"Noclothes ",0,9)){
-                                                               int closest=0;
+                                                               float gLoc[3]={0,0,0};
+                                                               float vel[3]={0,0,0};
+                                                               OPENAL_Sample_SetMinMaxDistance(samp[firestartsound], 9999.0f, 99999.0f);
+                                                               PlaySoundEx( firestartsound, samp[firestartsound], NULL, true);
+                                                               OPENAL_3D_SetAttributes(channels[firestartsound], gLoc, vel);
+                                                               OPENAL_SetVolume(channels[firestartsound], 256);
+                                                               OPENAL_SetPaused(channels[firestartsound], false);
+                                                               OPENAL_Sample_SetMinMaxDistance(samp[firestartsound], 8.0f, 2000.0f);
 
-                                                               player[closest].numclothes=0;
-                                                               if(player[closest].whichskin==0){
-                                                                       LoadTextureSave(":Data:Textures:Fur3.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==1){
-                                                                       LoadTextureSave(":Data:Textures:Fur.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==2){
-                                                                       LoadTextureSave(":Data:Textures:Fur2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==3){
-                                                                       LoadTextureSave(":Data:Textures:Lynx.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==4){
-                                                                       LoadTextureSave(":Data:Textures:Otter.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==5){
-                                                                       LoadTextureSave(":Data:Textures:Opal.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==6){
-                                                                       LoadTextureSave(":Data:Textures:Sable.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==7){
-                                                                       LoadTextureSave(":Data:Textures:Chocolate.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==8){
-                                                                       LoadTextureSave(":Data:Textures:BW2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                               }
-                                                               else if(player[closest].whichskin==9){
-                                                                       LoadTextureSave(":Data:Textures:WB2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
+                                                               for(j=0;j<255;j++){
+                                                                       displaytext[0][j]=' ';
                                                                }
+                                                               displaychars[0]=0;
+                        
+                                                               displayselected=0;
+                                                       }}
+                                       }
+                                       togglekey[i]=1;
+                               }
+                               else {
+                                       togglekey[i]=0;
+                                       togglekeydelay[i]=0;
+                               }
+                       }
 
-                                                               donesomething=1;
-                                                       }
+                       displayblinkdelay-=multiplier;
+                       if(displayblinkdelay<=0){
+                               displayblinkdelay=.3;
+                               displayblink=1-displayblink;
+                       }
+               }
+       }
 
-                                                       if((Compare(consoletext[0],"Clothes ",0,7)||Compare(consoletext[0],"clothes ",0,7))){
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='T';
-                                                               mapname[7]='e';
-                                                               mapname[8]='x';
-                                                               mapname[9]='t';
-                                                               mapname[10]='u';
-                                                               mapname[11]='r';
-                                                               mapname[12]='e';
-                                                               mapname[13]='s';
-                                                               mapname[14]=':';
-                                                               for(j=8;j<consolechars[0];j++){
-                                                                       mapname[j-8+15]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-8+15]='.';
-                                                               mapname[consolechars[0]-8+16]='p';
-                                                               mapname[consolechars[0]-8+17]='n';
-                                                               mapname[consolechars[0]-8+18]='g';
-                                                               mapname[consolechars[0]-8+19]='\0';
-
-                                                               //:Data:Textures:Pants.png
-
-                                                               if(AddClothes((char *)mapname,0,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize)){
-                                                                       player[0].DoMipmaps(5,0,0,player[0].skeleton.skinsize,player[0].skeleton.skinsize);
-                                                                       strcpy(player[0].clothes[player[0].numclothes],mapname);
-                                                                       player[0].clothestintr[player[0].numclothes]=tintr;
-                                                                       player[0].clothestintg[player[0].numclothes]=tintg;
-                                                                       player[0].clothestintb[player[0].numclothes]=tintb;
-                                                                       player[0].numclothes++;
-                                                               }
+       if(!mainmenu){
+               if(hostile==1)hostiletime+=multiplier;
+               else hostiletime=0;
+               if(!winfreeze)leveltime+=multiplier;
+               if(IsKeyDown(theKeyMap, MAC_ESCAPE_KEY)){
+                       chatting=0;
+                       console=0;
+                       freeze=0;
+                       displaychars[0]=0;
+               }
 
-                                                               donesomething=1;
-                                                       }
+               if(IsKeyDown(theKeyMap, chatkey)&&!chattogglekeydown&&!console&&!chatting&&debugmode){
+                       chatting=1;
+                       chattogglekeydown=1;
+                       togglekey[chatkey]=1;
+                       togglekeydelay[chatkey]=-20;
+               }
 
-                                                       if(Compare(consoletext[0],"belt ",0,4)||Compare(consoletext[0],"belt ",0,4)){
-                                                               player[0].skeleton.clothes = 1-player[0].skeleton.clothes;
+               if(!IsKeyDown(theKeyMap, chatkey)){
+                       chattogglekeydown=0;
+               }
 
-                                                               donesomething=1;
+               if(chatting){
+                       for(i=0;i<140;i++){
+                               if(IsKeyDown(theKeyMap, i)){
+                                       togglekeydelay[i]+=multiplier;
+                                       if(togglekeydelay[i]>.4){
+                                               togglekey[i]=0;
+                                               togglekeydelay[i]=.36;
+                                       }
+                                       if(!togglekey[i]){
+                                               if(KeyToSingleChar(i)!='\0'&&displaychars[0]<60){
+                                                       for(j=255;j>=displayselected+1;j--){
+                                                               displaytext[0][j]=displaytext[0][j-1];
                                                        }
-
-                                                       if(Compare(consoletext[0],"Cellophane ",0,10)||Compare(consoletext[0],"cellophane ",0,10)){
-                                                               cellophane=1-cellophane;
-
-                                                               if(cellophane){
-                                                                       for(i=0;i<numplayers;i++){
-                                                                               player[i].proportionhead.z=0;
-                                                                               player[i].proportionbody.z=0;
-                                                                               player[i].proportionarms.z=0;
-                                                                               player[i].proportionlegs.z=0;
-                                                                       }
+                                                       displaytext[0][displayselected]=KeyToSingleChar(i);
+                                                       if(IsKeyDown(theKeyMap, MAC_SHIFT_KEY))displaytext[0][displayselected]=Shift(displaytext[0][displayselected]);
+                                                       displayselected++;
+                                                       displaychars[0]++;
+                                               }
+                                               if(i==MAC_DELETE_KEY&&displayselected!=0){
+                                                       for(j=displayselected-1;j<255;j++){
+                                                               displaytext[0][j]=displaytext[0][j+1];
+                                                       }
+                                                       displaytext[0][255]=' ';
+                                                       displayselected--;
+                                                       displaychars[0]--;
+                                               }
+                                               if(i==MAC_ARROW_LEFT_KEY&&displayselected!=0){
+                                                       displayselected--;
+                                               }
+                                               if(i==MAC_ARROW_RIGHT_KEY&&displayselected<displaychars[0]){
+                                                       displayselected++;
+                                               }
+                                               if(i==MAC_RETURN_KEY){
+                                                       if(displaychars[0]){
+                                                               /*for(j=0;j<displaychars[0];j++){
+                                                               talkname[j]=displaytext[0][j];
                                                                }
-
-                                                               if(!cellophane){
-                                                                       for(i=0;i<numplayers;i++){
-                                                                               player[i].proportionhead.z=player[i].proportionhead.x;
-                                                                               player[i].proportionbody.z=player[i].proportionbody.x;
-                                                                               player[i].proportionarms.z=player[i].proportionarms.x;
-                                                                               player[i].proportionlegs.z=player[i].proportionlegs.x;
-                                                                       }
+                                                               talkname[displaychars[0]]='\0';
+                                                               sprintf (chatname, "%s: %s",playerName,talkname);
+                                                               //NetworkSendInformation(chatname);
+                                                               */
+                                                               for(j=0;j<255;j++){
+                                                                       displaytext[0][j]=' ';
                                                                }
-
-                                                               donesomething=1;
+                                                               displaychars[0]=0;
+                                                               displayselected=0;
+                                                               chatting=0;
                                                        }
+                                               }
+                                       }
+                                       togglekey[i]=1;
+                               }
+                               else {
+                                       togglekey[i]=0;
+                                       togglekeydelay[i]=0;
+                               }
+                       }
 
-                                                       if((Compare(consoletext[0],"Clothesnear ",0,11)||Compare(consoletext[0],"clothesnear ",0,11))){
-                                                               mapname[0]=':';
-                                                               mapname[1]='D';
-                                                               mapname[2]='a';
-                                                               mapname[3]='t';
-                                                               mapname[4]='a';
-                                                               mapname[5]=':';
-                                                               mapname[6]='T';
-                                                               mapname[7]='e';
-                                                               mapname[8]='x';
-                                                               mapname[9]='t';
-                                                               mapname[10]='u';
-                                                               mapname[11]='r';
-                                                               mapname[12]='e';
-                                                               mapname[13]='s';
-                                                               mapname[14]=':';
-                                                               for(j=12;j<consolechars[0];j++){
-                                                                       mapname[j-12+15]=consoletext[0][j];
-                                                               }
-                                                               mapname[consolechars[0]-12+15]='.';
-                                                               mapname[consolechars[0]-12+16]='p';
-                                                               mapname[consolechars[0]-12+17]='n';
-                                                               mapname[consolechars[0]-12+18]='g';
-                                                               mapname[consolechars[0]-12+19]='\0';
-
-                                                               //:Data:Textures:Pants.png
-                                                               int closest=-1;
-                                                               float closestdist=-1;
-                                                               float distance;
-                                                               if(numplayers>1)
-                                                                       for(i=1;i<numplayers;i++){
-                                                                               distance=findDistancefast(&player[i].coords,&player[0].coords);
-                                                                               if(closestdist==-1||distance<closestdist){
-                                                                                       closestdist=distance;
-                                                                                       closest=i;
-                                                                               }
-                                                                       }
+                       displayblinkdelay-=multiplier;
+                       if(displayblinkdelay<=0){
+                               displayblinkdelay=.3;
+                               displayblink=1-displayblink;
+                       }
+               }
 
-                                                                       if(AddClothes((char *)mapname,0,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize)){
-                                                                               player[closest].DoMipmaps(5,0,0,player[closest].skeleton.skinsize,player[closest].skeleton.skinsize);
-                                                                               strcpy(player[closest].clothes[player[closest].numclothes],mapname);
-                                                                               player[closest].clothestintr[player[closest].numclothes]=tintr;
-                                                                               player[closest].clothestintg[player[closest].numclothes]=tintg;
-                                                                               player[closest].clothestintb[player[closest].numclothes]=tintb;
-                                                                               player[closest].numclothes++;
-                                                                       }
+               if(chatting)keyboardfrozen=1;
 
-                                                                       donesomething=1;
-                                                       }
+               if(IsKeyDown(theKeyMap, MAC_V_KEY)&&!freezetogglekeydown&&debugmode){
+                       freeze=1-freeze;
+                       if(freeze){
+                               OPENAL_SetFrequency(OPENAL_ALL, 0.001);
+                       }
+                       freezetogglekeydown=1;
+               }
 
-                                                       if(Compare(consoletext[0],"funnybunny ",0,10)||Compare(consoletext[0],"funny bunny ",0,11)){
-                                                               player[0].skeleton.id=0;
-                                                               player[0].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);
-                                                               LoadTextureSave(":Data:Textures:fur3.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               player[0].creature=rabbittype;
-                                                               player[0].scale=.2;
+               if(!IsKeyDown(theKeyMap, MAC_V_KEY)&&!IsKeyDown(theKeyMap, MAC_F1_KEY)){
+                       freezetogglekeydown=0;
+               }
 
-                                                               player[0].proportionhead=1.2;
-                                                               player[0].proportionbody=1.05;
-                                                               player[0].proportionarms=1.00;
-                                                               player[0].proportionlegs=1.1;
-                                                               player[0].proportionlegs.y=1.05;
-                                                               player[0].headless=0;
+               if(IsKeyDown(theKeyMap, MAC_TILDE_KEY)&&!consoletogglekeydown&&debugmode){
+                       console=1-console;
+                       if(!console)freeze=0;
+                       if(console){
+                               OPENAL_SetFrequency(OPENAL_ALL, 0.001);
+                       }
+                       consoletogglekeydown=1;
+               }
 
-                                                               player[0].damagetolerance=200;
+               if(!IsKeyDown(theKeyMap, MAC_TILDE_KEY)){
+                       consoletogglekeydown=0;
+               }
 
-                                                               donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"wolfieisgod ",0,11)||Compare(consoletext[0],"wolfie is god ",0,12)){
-                                                               player[0].skeleton.id=0;
-                                                               player[0].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);
-                                                               LoadTextureSave(":Data:Textures:Wolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               player[0].creature=wolftype;
-
-                                                               player[0].proportionhead=1.1;
-                                                               player[0].proportionbody=1.1;
-                                                               player[0].proportionarms=1.1;
-                                                               player[0].proportionlegs=1.1;
-                                                               player[0].proportionlegs.y=1.1;
-                                                               player[0].scale=.23;
-
-                                                               player[0].damagetolerance=300;
-
-                                                               donesomething=1;
-                                                       }
-                                                       /*if(Compare(consoletext[0],"kungfu ",0,6)||Compare(consoletext[0],"kung fu ",0,7)){
-                                                       LoadTextureSave(":Data:Textures:Kungfu.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                       donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"rambo ",0,5)){
-                                                       LoadTextureSave(":Data:Textures:Leather.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                       donesomething=1;
-                                                       }
-                                                       if(Compare(consoletext[0],"david ",0,5)){
-                                                       LoadTextureSave(":Data:Textures:David.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                       donesomething=1;
-                                                       }*/
-                                                       if(Compare(consoletext[0],"wolf ",0,4)){
-                                                               LoadTextureSave(":Data:Textures:Wolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
+               if(console)freeze=1;
+
+               if(console&&!IsKeyDown(theKeyMap,MAC_COMMAND_KEY)){
+                       for(i=0;i<140;i++){
+                               if(IsKeyDown(theKeyMap, i)){
+                                       togglekeydelay[i]+=multiplier;
+                                       if(togglekeydelay[i]>.4){
+                                               togglekey[i]=0;
+                                               togglekeydelay[i]=.36;
+                                       }
+                                       if(!togglekey[i]){
+                                               if(KeyToSingleChar(i)!='\0'&&consolechars[0]<255){
+                                                       for(j=255;j>=consoleselected+1;j--){
+                                                               consoletext[0][j]=consoletext[0][j-1];
                                                        }
-                                                       if(Compare(consoletext[0],"darkwolf ",0,8)){
-                                                               LoadTextureSave(":Data:Textures:DarkWolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
+                                                       consoletext[0][consoleselected]=KeyToSingleChar(i);
+                                                       if(IsKeyDown(theKeyMap, MAC_SHIFT_KEY))consoletext[0][consoleselected]=Shift(consoletext[0][consoleselected]);
+                                                       consoleselected++;
+                                                       consolechars[0]++;
+                                               }
+                                               else if(i==MAC_ENTER_KEY){
+                                                       for(j=255;j>=consoleselected+1;j--){
+                                                               consoletext[0][j]=consoletext[0][j-1];
                                                        }
-                                                       if(Compare(consoletext[0],"snowwolf ",0,8)){
-                                                               LoadTextureSave(":Data:Textures:Snowwolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
-                                                       }/*
-                                                        if(Compare(consoletext[0],"lizardwolf ",0,10)){
-                                                        LoadTextureSave(":Data:Textures:Lizardwolf.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                        donesomething=1;
-                                                        }*/
-                                                       if(Compare(consoletext[0],"white ",0,5)){
-                                                               LoadTextureSave(":Data:Textures:fur.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
+                                                       consoletext[0][consoleselected]='\n';
+                                                       consoleselected++;
+                                                       consolechars[0]++;
+                                               }
+                                               if(i==MAC_DELETE_KEY&&consoleselected!=0){
+                                                       for(j=consoleselected-1;j<255;j++){
+                                                               consoletext[0][j]=consoletext[0][j+1];
                                                        }
-                                                       if(Compare(consoletext[0],"brown ",0,5)){
-                                                               LoadTextureSave(":Data:Textures:fur3.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
+                                                       consoletext[0][255]=' ';
+                                                       consoleselected--;
+                                                       consolechars[0]--;
+                                               }
+                                               if(i==MAC_ARROW_UP_KEY){
+                                                       if(archiveselected<14)archiveselected++;
+                                                       for(j=0;j<255;j++){
+                                                               consolechars[0]=consolechars[archiveselected];
+                                                               consoletext[0][j]=consoletext[archiveselected][j];
+                                                               consoleselected=consolechars[0];
                                                        }
-                                                       if(Compare(consoletext[0],"black ",0,5)){
-                                                               LoadTextureSave(":Data:Textures:fur2.jpg",&player[0].skeleton.drawmodel.textureptr,1,&player[0].skeleton.skinText[0],&player[0].skeleton.skinsize);
-                                                               donesomething=1;
+                                               }
+                                               if(i==MAC_ARROW_DOWN_KEY){
+                                                       if(archiveselected>0)archiveselected--;
+                                                       for(j=0;j<255;j++){
+                                                               consolechars[0]=consolechars[archiveselected];
+                                                               consoletext[0][j]=consoletext[archiveselected][j];
+                                                               consoleselected=consolechars[0];
                                                        }
+                                               }
+                                               if(i==MAC_ARROW_LEFT_KEY&&consoleselected!=0){
+                                                       consoleselected--;
+                                               }
+                                               if(i==MAC_ARROW_RIGHT_KEY&&consoleselected<consolechars[0]){
+                                                       consoleselected++;
+                                               }
+                                               if(i==MAC_RETURN_KEY){
+                                                       archiveselected=0;
+                                                       cmd_dispatch(this, consoletext[0]);
+
                                                        if(consolechars[0]>0){
                                                                for(k=14;k>=1;k--){
                                                                        for(j=0;j<255;j++){
@@ -5363,12 +3997,6 @@ void     Game::Tick()
                                                                }
                                                                consolechars[0]=0;
                                                                consoleselected=0;
-
-                                                               if(!donesomething){
-                                                                       PlaySoundEx( consolefailsound, samp[consolefailsound], NULL, true);
-                                                                       OPENAL_SetVolume(channels[consolefailsound], 256);
-                                                                       OPENAL_SetPaused(channels[consolefailsound], false);
-                                                               }
                                                        }
                                                }
                                        }
@@ -5469,6 +4097,12 @@ void     Game::Tick()
                                opstream << KeyToChar(attackkey);
                                opstream << "\nChat key:\n";
                                opstream << KeyToChar(chatkey);
+                               opstream << "\nStereoMode:\n";
+                               opstream << stereomode;
+                               opstream << "\nStereoSeparation:\n";
+                               opstream << stereoseparation;
+                               opstream << "\nStereoReverse:\n";
+                               opstream << stereoreverse;
                                opstream.close();
                        }
                }
@@ -7178,50 +5812,8 @@ void     Game::Tick()
                                                                        if(player[closest].whichskin>9)player[closest].whichskin=0;
                                                                        if(player[closest].whichskin>2&&player[closest].creature==wolftype)player[closest].whichskin=0;
 
-                                                                       if(player[closest].creature==rabbittype){
-                                                                               if(player[closest].whichskin==0){
-                                                                                       LoadTextureSave(":Data:Textures:Fur3.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==1){
-                                                                                       LoadTextureSave(":Data:Textures:Fur.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==2){
-                                                                                       LoadTextureSave(":Data:Textures:Fur2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==3){
-                                                                                       LoadTextureSave(":Data:Textures:Lynx.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==4){
-                                                                                       LoadTextureSave(":Data:Textures:Otter.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==5){
-                                                                                       LoadTextureSave(":Data:Textures:Opal.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==6){
-                                                                                       LoadTextureSave(":Data:Textures:Sable.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==7){
-                                                                                       LoadTextureSave(":Data:Textures:Chocolate.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==8){
-                                                                                       LoadTextureSave(":Data:Textures:BW2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==9){
-                                                                                       LoadTextureSave(":Data:Textures:WB2.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                       }
-                                                                       if(player[closest].creature==wolftype){
-                                                                               k=abs(Random()%3);
-                                                                               if(player[closest].whichskin==0){
-                                                                                       LoadTextureSave(":Data:Textures:Wolf.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==1){
-                                                                                       LoadTextureSave(":Data:Textures:Darkwolf.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                               else if(player[closest].whichskin==2){
-                                                                                       LoadTextureSave(":Data:Textures:Snowwolf.jpg",&player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
-                                                                               }
-                                                                       }
+                                                                       LoadTextureSave(creatureskin[player[closest].creature][player[closest].whichskin],
+                                                                                       &player[closest].skeleton.drawmodel.textureptr,1,&player[closest].skeleton.skinText[0],&player[closest].skeleton.skinsize);
                                                                }
 
                                                                if(player[closest].numclothes){
@@ -7761,7 +6353,7 @@ void      Game::Tick()
                                                                        player[numplayers].proportionlegs.z=0;
                                                                }
 
-                                                               player[numplayers].tempanimation.Load((char *)ConvertFileName(":Data:Animations:Tempanim"),0,0);
+                                                               player[numplayers].tempanimation.Load((char *)":Data:Animations:Tempanim",0,0);
 
                                                                player[numplayers].damagetolerance=200;