// ***********************************************************************************
// Programs written by R.Swan - rs108@mdx.ac.uk - www.netyaroze-europe.com/~middex2
// Taken from the tutorial by P.Passmore - p.passmore@mdx.ac.uk
//   Tutorial file can be found at the above web site
// Step ten - add a road to drive around on
// ***********************************************************************************

// ***********************************************************************************
// Preprocessor functions
// ***********************************************************************************

#define FADER 0
#define FADEG 0
#define FADEB 0

#include "header.h"
//#include "function.c"

// **** create global variables, structures, headers and arrays (mostly system stuff)
u_long    CirclePressed = 0;

u_long    LapsCounter = 0;
u_long    TimeCurrent, TimeFastest, TimeSlowest;

u_long    PlayerStartedRacing=0;
long      PlayerTilt;
u_long    DrawSection = 0;
u_long    DrawSectionFlag = 0;

GsSPRITE  DialSprite;
GsSPRITE  PointerSprite;

void      RotateTrack(u_long tAngle, u_long tTrackNumber);
void      UpdateWorld();
void      MoveToNextTrackSection();
u_long    CheckCollide(u_long tSection);

// ***********************************************************************************
// Main function
// ***********************************************************************************

void main()
  {
  TimeCurrent=0;
  TimeSlowest=0;
  TimeFastest=9999999;

  GhostArrayInUse = 0;
  GhostInUse = 0;
  GhostMaxPosition = 0;

  TRANSPARENCY = 0;

  LoadTIMData(TIM_DIAL);
  LoadTIMData(TIM_POINTER);
  LoadTIMData(TIM_BARR);
  LoadTIMData(TIM_GRASS);
  LoadTIMData(TIM_LBARR);
  LoadTIMData(TIM_LOGO);
  LoadTIMData(TIM_LROAD);
  LoadTIMData(TIM_ROAD);
  LoadTIMData(TIM_TREE);
  SetSpriteInfo(&DialSprite, TIM_DIAL, -150, 52);
  DialSprite.attribute += (1<<30) + (1<<28);// + (1<<29);
  SetSpriteInfo(&PointerSprite, TIM_POINTER, -150, 110);
  PointerSprite.attribute += (1<<30);
  PointerSprite.mx = 12;
  PointerSprite.my = 12;
  PointerSprite.scalex = PointerSprite.scaley = ONE*0.52;

  FntLoad(960, 256);                                  // load font into area of frame
                                                      // specified by 960, 256
  FntOpen(-160, -70, 320, 100, 0, 512);              // specify where on screen text goes
                                                      // (0, 0) is center of screen
  PadInit();                                          // initialise joypad reading
  InitialiseGraphics();                               // initialise graphics
  InitialiseCounter();
  InitView(&Camera, 250, 0, 0,-900,-1500, 0,-200,1000 ,&CarModel.Object_Coord);
//  InitView(&Camera, 250, 0, 0,-600,-200, 0,-200,1000 ,&CarModel.Object_Coord);
//  InitView(&Camera, 250, 0, 0,-7000,-2000, 0,0,3000 ,&CarModel.Object_Coord);
                                                      // initialise all cameras

  InitAllLights();                                    // call function that creates two lights
  InitTrack();
  InitModel(&CarModel, 30500, -100, 40000, (u_long *)CAR_MEM_ADDR);
  InitModel(&GhostModel, 30500, -100, 40000, (u_long *)CAR_MEM_ADDR);
                                                      // prepare objects for use
                                                      // car's position set to (0, -200, 0);
  GhostModel.Object_Handler.attribute += TRANSPARENCY;

  Fogging.dqa = -15000;                                // this is a measure of the distance
                                                      // at which objects start to fade to
                                                      // the specified colours. IT IS NOT
                                                      // directly related to world units.
                                                      // The more negative the value, the
                                                      // farther in front of you an object
                                                      // has to be before it starts to fade
  Fogging.dqb = 5120*5120*1.0;                        // this is a measure of how far either
                                                      // side of the distance above that
                                                      // objects fade in or out. A value of
                                                      //   5120*5120*2   = very abrupt fading
                                                      //   5120*5120*0.7 = very gradual fade
  Fogging.rfc = FADER;                                   // set colour for objects to fade to
  Fogging.gfc = FADEG;
  Fogging.bfc = FADEB;
  GsSetLightMode(1);                                  // set fogging to be used in light
  GsSetFogParam(&Fogging);                            // define which fogging to be used

  while(Running)                                      // do loop while program is running
    {
//    FntPrint("Speed (%d)\n", VerticalSync);
//    FntPrint("GhostInUse (%d)\n", GhostInUse);
//    FntPrint("GhostArrayInUse (%d)\n", GhostArrayInUse);
//    FntPrint("GhostArrayPosition (%d)", GhostArrayPosition);
                                    // display speed of screen drawing
//    FntPrint("X %d\n", CarModel.Object_Coord.coord.t[0]);
//    FntPrint("Z %d\n", CarModel.Object_Coord.coord.t[2]);
    ProcessUserInput();                               // call function to process joypad
    UpdateWorld();
    MoveToNextTrackSection();
    RenderWorld();                                    // render the playstation screen
    }
  ResetGraph(3);                                      // clear up before quitting
  };

// ***********************************************************************************
// User defined drawing functions
// ***********************************************************************************

// **** update all objects + track
void UpdateWorld()
  {
  u_long tTemp1, tTemp2;

  if (LapsCounter>0)
    {
    for (tTemp1=1; tTemp1<10; tTemp1++)
      {
      for (tTemp2=0; tTemp2<7; tTemp2++)
        {
        if (tTemp1==1) Numbers[1][tTemp2].x ++;
        Numbers[tTemp1][tTemp2].y++;
        if ((LapsCounter == 6) && (tTemp1!=1)) Numbers[tTemp1][tTemp2].x ++;
        }
      }
    LapsCounter--;
    };
  PointerSprite.rotate = -(abs(CarModel.speed)) * 921;
  CarModel.Object_Coord.coord.t[1] = -100-(abs(CarModel.speed));
  if (CarModel.Object_Coord.coord.t[1] < -300) CarModel.Object_Coord.coord.t[1] = -300;
  if (PlayerStartedRacing==1)
    {
    CounterDigits[0][4] += 2;
    TimeCurrent++;
    }
  for (tTemp1 = 4; tTemp1 != 0; tTemp1--)
    {
    if (CounterDigits[0][tTemp1] > 9)
      {
      CounterDigits[0][tTemp1] = CounterDigits[0][tTemp1] % 10;
      CounterDigits[0][tTemp1-1]++;
    }
   if (CounterDigits[0][1] > 5)
    {
    CounterDigits[0][1] = CounterDigits[0][1] % 6;
    CounterDigits[0][0]++;
    }
   }
  if (CounterDigits[0][0] == 10) CounterDigits[0][0] = 0;

  for (tTemp1 = 0; tTemp1 < 5; tTemp1++)
   {
   Numbers[0][tTemp1].u = CounterDigits[0][tTemp1]*16;
   }

  tTemp2 = CheckCollide(DrawSection);
  CarModel.speed *= 0.985;
  switch(tTemp2)
   {
   case  TRACK:     break;
   case  GRASS:     if (abs(CarModel.speed)>175) CarModel.speed *= 0.97; break;
   case  SMASH:     {
                    CarModel.speed *= -1.5; break;};
   case  TREES:     if (abs(CarModel.speed)>100) CarModel.speed *= 0.9; break;
    };

  MoveModelForward(&CarModel, CarModel.speed);      // move man every frame
  if (tTemp2 == SMASH) CarModel.speed *= 0.2;
  GsSetRefView2(&Camera);                             // activates the view

  PlayerTilt *= 0.95;
  RotateModel(&CarModel, 0, PlayerTilt, PlayerTilt*8);
  Camera.rz = -PlayerTilt * 5 * 360;

  if (GhostInUse > 0)
    {
    if (GhostArrayPosition<2000)
      {
      Ghost[GhostArrayInUse][GhostArrayPosition].x = CarModel.Object_Coord.coord.t[0];
      Ghost[GhostArrayInUse][GhostArrayPosition].y = CarModel.Object_Coord.coord.t[1];
      Ghost[GhostArrayInUse][GhostArrayPosition].z = CarModel.Object_Coord.coord.t[2];
      Ghost[GhostArrayInUse][GhostArrayPosition].rotation = CarModel.rotation.vy;
      Ghost[GhostArrayInUse][GhostArrayPosition].direction = CarModel.rotation.vz;
      if ((GhostInUse == 2) && (GhostArrayPosition<GhostMaxPosition))
        {
        tTemp1 = 1-GhostArrayInUse;
        GhostModel.Object_Coord.coord.t[0] = Ghost[tTemp1][GhostArrayPosition].x;
        GhostModel.Object_Coord.coord.t[1] = Ghost[tTemp1][GhostArrayPosition].y;
        GhostModel.Object_Coord.coord.t[2] = Ghost[tTemp1][GhostArrayPosition].z;
        RotateModelTo(&GhostModel, 0, Ghost[tTemp1][GhostArrayPosition].rotation, Ghost[tTemp1][GhostArrayPosition].direction);
//        GhostModel.Object_Coord.flg=0;
        };
      GhostArrayPosition++;
      };
    };
  };

// **** Actual main screen drawing routine (calls all functions)
void RenderWorld()
  {
  u_long tTemp1;
  u_long currentBuffer = GsGetActiveBuff();              // determine which buffer is to be used
  GsSetRefView2(&Camera);                             // activates the view
  GsSetWorkBase((PACKET*)Packet_Memory[currentBuffer]);
                                                      // define where screen drawing commands
                                                      // are going to be queued
  GsClearOt(0, 0, &OTable_Header[currentBuffer]);     // clear out OTable sorting info
  DrawTrack(&TrackData, &OTable_Header[currentBuffer], DrawSection);
  DrawObject(&CarModel, &OTable_Header[currentBuffer]);
  DrawObject(&GhostModel, &OTable_Header[currentBuffer]);
  for (tTemp1=0; tTemp1<12; tTemp1++)
    {
    GsSortFastSprite(&Numbers[tTemp1][0], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][1], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][2], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][3], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][4], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][5], &OTable_Header[currentBuffer], 0);
    GsSortFastSprite(&Numbers[tTemp1][6], &OTable_Header[currentBuffer], 0);
    }
  GsSortSprite(&PointerSprite, &OTable_Header[currentBuffer], 0);
  GsSortFastSprite(&DialSprite, &OTable_Header[currentBuffer], 0);

                                                      // send draw commands to queue
//  FntFlush(-1);                                       // force text to be printed immediately
  DrawSync(0);                                        // wait for completion of all output
  VerticalSync = VSync(0);                            // wait for blank and time it
  ResetGraph(1);
  GsSwapDispBuff();                                   // swap buffer information
  GsSortClear(FADER, FADEG, FADEB,&OTable_Header[currentBuffer]); // send clear screen command to queue
  GsDrawOt(&OTable_Header[currentBuffer]);            // draw commands in queue
  };

// ***********************************************************************************
// User defined initialisation functions
// ***********************************************************************************

// Initialise the Track
void InitTrack()
  {
  u_long *tModelAddress;
  long tXpos = 30000; long tZpos = 40000, tDir = 0;   // temp variables
  long tXpos2 = 30000; long tZpos2 = 40000;           // temp variables
  long tTempX; long tTempZ, tRotate;
  long tTempX2; long tTempZ2, tRotate2;
  u_long tTemp1;
  char tTrackStatus;                                  // temp variable
  for (tTemp1 = 0; tTemp1<GROUND_OBJECTS; tTemp1++)   // this loop will go through every cell
    {
    tTrackStatus = RawGroundArray[tTemp1];            // read cell value in array
    tTempX2 = 0; tTempZ2 = GROUND_SIZE;
    switch(tTrackStatus)
      {
      case FORWARD:   {tModelAddress = (u_long *) ROAD_MEM_ADDR;
                      tTempX = 0; tTempZ = GROUND_SIZE;
                      tRotate = 0;
                      break;};
      case TUNNEL:    {tModelAddress = (u_long *) TUNN_MEM_ADDR;
                      tTempX = 0; tTempZ = GROUND_SIZE;
                      tRotate = 2;
                      break;};
      case TREE_L:    {tModelAddress = (u_long *) TREE_MEM_ADDR;
                      tTempX = 0; tTempZ = GROUND_SIZE;
                      tRotate = 0;
                      break;};
      case TREE_R:    {tModelAddress = (u_long *) TREE_MEM_ADDR;
                      tTempX = 0; tTempZ = GROUND_SIZE;
               tRotate = 2;
                      break;};
      case LEFT:      {tModelAddress = (u_long *) CORN_MEM_ADDR;
                      tTempX = GROUND_SIZE*1.5; tTempZ = GROUND_SIZE*2.5;
                      tRotate = 0;
               break;};
      case RIGHT:     {tModelAddress = (u_long *) CORN_MEM_ADDR;
                      tTempX = 0; tTempZ = GROUND_SIZE*4.0;
                      tRotate = 3;
                      break;};
      };
    switch(tDir)
      {
      case 0:         tXpos  += tTempX;  tZpos  += tTempZ;
                      tXpos2 += tTempX2; tZpos2 += tTempZ2; break;
      case 1:         tXpos  -= tTempZ;  tZpos  += tTempX;
                      tXpos2 -= tTempZ2; tZpos2 += tTempX2; break;
      case 2:         tXpos  -= tTempX;  tZpos  -= tTempZ;
                      tXpos2 -= tTempX2; tZpos2 -= tTempZ2; break;
      case 3:         tXpos  += tTempZ;  tZpos  -= tTempX;
                      tXpos2 += tTempZ2; tZpos2 -= tTempX2; break;
      };
    GroundCheck1[tTemp1][5] = tDir;
    if (tTrackStatus == RIGHT) tDir = (tDir+3) % 4;
    if (tTrackStatus == LEFT) tDir = (tDir+5) % 4;

    AddModelToTrack(&TrackData, tXpos, 0, tZpos, tModelAddress);
                                                      // call function to create read object
    RotateTrack((tDir+tRotate)%4, tTemp1);
    GroundCheck1[tTemp1][0] = tXpos2;
    GroundCheck1[tTemp1][1] = tZpos2;
    GroundCheck1[tTemp1][4] = 0;

    tTempX = tTempZ = 0;
   tTempX2 = tTempZ2 = 0;
    switch(tTrackStatus)
      {
      case LEFT:      {tTempX = 0; tTempZ = GROUND_SIZE*3.0;
                      tTempX2 = GROUND_SIZE*1.5; tTempZ2 = GROUND_SIZE*1.5;
                      GroundCheck1[tTemp1][4] = 1;
                      break;};
      case RIGHT:     {tTempX = GROUND_SIZE*1.5; tTempZ = GROUND_SIZE*1.5;
                      tTempX2 = GROUND_SIZE*-1.5; tTempZ2 = GROUND_SIZE*1.5;
                      GroundCheck1[tTemp1][4] = 1;
                      break;};
      };
    switch(tDir)
      {
      case 0:         tXpos  += tTempX;  tZpos  += tTempZ;
                      tXpos2 += tTempX2; tZpos2 += tTempZ2; break;
      case 1:         tXpos  -= tTempZ;  tZpos  += tTempX;
                      tXpos2 -= tTempZ2; tZpos2 += tTempX2; break;
      case 2:         tXpos  -= tTempX;  tZpos  -= tTempZ;
                      tXpos2 -= tTempX2; tZpos2 -= tTempZ2; break;
      case 3:         tXpos  += tTempZ;  tZpos  -= tTempX;
                      tXpos2 += tTempZ2; tZpos2 -= tTempX2; break;
      };
    GroundCheck1[tTemp1][3] = tXpos2;
   GroundCheck1[tTemp1][4] = tZpos2;
//    printf("num %2d,     xy %d %d\n", tTemp1, GroundCheck1[tTemp1][0], GroundCheck1[tTemp1][1]);
    };
  };

// ***********************************************************************************
// User defined miscellaneous functions
// ***********************************************************************************

// **** Let Yaroze respond to joypad input
void ProcessUserInput()
  {
  u_long PAD = PadRead();                             // read status of joypad 1
  if (PAD& PADselect)   Running = false;              // select will quit
  if (PAD& PADcross)    {if (CarModel.speed<400) CarModel.speed+=8;};
  if (PAD& PADsquare)   {
                if (CarModel.speed>-100) CarModel.speed-=8;};
  if (PAD& PADleft)     {PlayerTilt -= 3;};           // rotate car anti-clockwise
  if (PAD& PADright)    {PlayerTilt += 3;};           // rotate car clockwise
  if (PAD& PADL1)       {PlayerTilt -= 2;              // rotate car anti-clockwise
                        if (CarModel.speed>0) CarModel.speed *= 0.97;};
  if (PAD& PADR1)       {
                PlayerTilt += 2;              // rotate car clockwise
                if (CarModel.speed>0) CarModel.speed *= 0.97;};
  if ((PAD& PADcircle) && (CirclePressed == 0))
                        {
                        CirclePressed = 1;
                        TRANSPARENCY = (1<<30) - TRANSPARENCY;
                        GhostModel.Object_Handler.attribute = TRANSPARENCY;
                        };
  if (!(PAD& PADcircle))
                        CirclePressed = 0;
  };

// **** Rotate an object about it's own center
void RotateTrack(u_long tAngle, u_long tTrackNumber)
  {
  SVECTOR tRotate;
  MATRIX tMatrix;                                     // temporary rotation matrix

  tRotate.vx = 0;                                     // set up rotation about the axes
  tRotate.vy = 4096-(tAngle*1024);
  tRotate.vz = 0;

  RotMatrix(&tRotate, &tMatrix);                      // turn vector into rotation matrix
  MulMatrix0( &TrackData.Object_Coord[tTrackNumber].coord, &tMatrix,
              &TrackData.Object_Coord[tTrackNumber].coord);
                                                      // multiply object and rotation matrices
  TrackData.Object_Coord[tTrackNumber].flg = 0;       // signify object has changed
  };

void MoveToNextTrackSection()
  {
  u_long tTemp1, tTemp2;
  u_long tTempX1, tTempZ1;
  u_long tTempX2, tTempZ2;
  u_long tTempX3, tTempZ3;
  u_long tSection = (DrawSection+1) % GROUND_OBJECTS;
  u_long tSection2 = (DrawSection-1+GROUND_OBJECTS) % GROUND_OBJECTS;

  tTempX1 = labs(CarModel.Object_Coord.coord.t[0] - GroundCheck1[DrawSection][0]);
  tTempZ1 = labs(CarModel.Object_Coord.coord.t[2] - GroundCheck1[DrawSection][1]);

  tTempX2 = labs(CarModel.Object_Coord.coord.t[0] - GroundCheck1[tSection][0]);
  tTempZ2 = labs(CarModel.Object_Coord.coord.t[2] - GroundCheck1[tSection][1]);

  tTempX3 = labs(CarModel.Object_Coord.coord.t[0] - GroundCheck1[tSection2][0]);
  tTempZ3 = labs(CarModel.Object_Coord.coord.t[2] - GroundCheck1[tSection2][1]);

  if ((tTempX1+tTempZ1) > (tTempX2+tTempZ2))
    {
    DrawSection = (DrawSection+1) % GROUND_OBJECTS;
    if (DrawSection == 0)
      {
      if (GhostInUse == 0) GhostInUse = 1;
      if (PlayerStartedRacing == 1)
        {
        u_long tColR = 64, tColG = 64, tColB = 64;
        LapsCounter = 12;
        for (tTemp1=9; tTemp1>1; tTemp1--)
          {
          for (tTemp2=0; tTemp2<7; tTemp2++)
            {
            Numbers[tTemp1][tTemp2].u = Numbers[tTemp1-1][tTemp2].u;
            Numbers[tTemp1][tTemp2].attribute = Numbers[tTemp1-1][tTemp2].attribute;
            Numbers[tTemp1][tTemp2].r = Numbers[tTemp1-1][tTemp2].r;
            Numbers[tTemp1][tTemp2].g = Numbers[tTemp1-1][tTemp2].g;
            Numbers[tTemp1][tTemp2].b = Numbers[tTemp1-1][tTemp2].b;
            Numbers[tTemp1][tTemp2].y -= 12;
            Numbers[tTemp1][tTemp2].x = Numbers[tTemp1-1][tTemp2].x+1;
            }
          }
        for (tTemp2=0; tTemp2<7; tTemp2++)
          {
          Numbers[1][tTemp2].u = Numbers[tTemp1-1][tTemp2].u;
          Numbers[1][tTemp2].attribute = Numbers[tTemp1-1][tTemp2].attribute;
          Numbers[1][tTemp2].r = Numbers[tTemp1-1][tTemp2].r;
          Numbers[1][tTemp2].g = Numbers[tTemp1-1][tTemp2].g;
          Numbers[1][tTemp2].b = Numbers[tTemp1-1][tTemp2].b;
          Numbers[1][tTemp2].x -= 12;
          Numbers[1][tTemp2].y -= 12;
          };
        if ((TimeCurrent+25)>TimeSlowest)
          {
          tColR = 128; tColG = 128; tColB = 64;
          }
        if (TimeCurrent>TimeSlowest)
          {
          if (!(TimeCurrent<TimeFastest))
            {
            TimeSlowest = TimeCurrent;
            tColR = 128; tColG = 64; tColB = 64;
            for (tTemp2=0; tTemp2<7; tTemp2++)
              {
              Numbers[11][tTemp2].u = Numbers[0][tTemp2].u;
              Numbers[11][tTemp2].attribute = (1<<30)+(1<<28);
              }
            }
          }
        if ((TimeCurrent-25)<TimeFastest)
          {
          tColR = 64; tColG = 128; tColB = 128;
          }
        if (TimeCurrent<TimeFastest)
          {
          TimeFastest = TimeCurrent;
          tColR = 64; tColG = 128; tColB = 64;
          for (tTemp2=0; tTemp2<7; tTemp2++)
            {
            Numbers[10][tTemp2].u = Numbers[0][tTemp2].u;
            Numbers[10][tTemp2].attribute = (1<<30)+(1<<28);
            }
          if ((GhostInUse>0) && (GhostArrayPosition<2000))
            {
            GhostArrayInUse = 1-GhostArrayInUse;
            GhostInUse = 2;
            GhostMaxPosition = GhostArrayPosition;
            };
          }
        for (tTemp1=0; tTemp1<7; tTemp1++)
          {
          Numbers[1][tTemp1].u = Numbers[0][tTemp1].u;
          CounterDigits[1][tTemp1] = CounterDigits[0][tTemp1];
          CounterDigits[0][tTemp1] = 0;
          if (tTemp1<5) Numbers[0][tTemp1].u = 0;
          Numbers[1][tTemp1].attribute = (1<<30)+(1<<28);
          Numbers[1][tTemp1].r = tColR;
          Numbers[1][tTemp1].g = tColG;
          Numbers[1][tTemp1].b = tColB;
          }
        TimeCurrent=0;
        }
      else
        {
        PlayerStartedRacing=1;
        for (tTemp1=0; tTemp1<7; tTemp1++) Numbers[0][tTemp1].attribute = (1<<30)+(1<<28);
        TimeCurrent=0;
        }
      GhostArrayPosition = 0;
      }
    }
  else
    {
    if ((tTempX3+tTempZ3) < (tTempX1+tTempZ1))
      {
      DrawSection = (DrawSection-1+GROUND_OBJECTS) % GROUND_OBJECTS;
      }
    }
  };

u_long CheckCollide(u_long tSection)
  {
  u_long tReturn;
  u_long tTrack = RawGroundArray[tSection];
  u_long tDir = GroundCheck1[tSection][5];
  long tTempX,tTempZ;

  switch(tDir)
    {
    case 0:   {
              tTempX = (CarModel.Object_Coord.coord.t[0] - GroundCheck1[tSection][0]);
              tTempZ = (CarModel.Object_Coord.coord.t[2] - GroundCheck1[tSection][1]);
              break; };
    case 1:   {
              tTempX = (CarModel.Object_Coord.coord.t[2] - GroundCheck1[tSection][1]);
              tTempZ = (CarModel.Object_Coord.coord.t[0] - GroundCheck1[tSection][0]);
              break; };
    case 2:   {
              tTempX = (-CarModel.Object_Coord.coord.t[0] + GroundCheck1[tSection][0]);
              tTempZ = (-CarModel.Object_Coord.coord.t[2] + GroundCheck1[tSection][1]);
              break; };
    case 3:   {
              tTempX = (-CarModel.Object_Coord.coord.t[2] + GroundCheck1[tSection][1]);
              tTempZ = (-CarModel.Object_Coord.coord.t[0] + GroundCheck1[tSection][0]);
              break; };
    };
  tReturn = TRACK;
  switch(tTrack)
    {
    case FORWARD:   {
                    if ((tTempX>(GROUND_SIZE*0.5)) || (tTempX<-(GROUND_SIZE*0.5))) tReturn = GRASS;
                    break; };
   case TUNNEL:    {
                    if ((tTempX>(GROUND_SIZE*0.7)) || (tTempX<-(GROUND_SIZE*0.7))) tReturn = SMASH;
                    break; };
    case TREE_L:    {
                    if (tTempX>(GROUND_SIZE*0.5)) tReturn=GRASS;
                    if (tTempX<-(GROUND_SIZE*0.5)) tReturn = TREES;
                    break; };
    case TREE_R:    {
                    if (tTempX>(GROUND_SIZE*0.5)) tReturn=TREES;
                    if (tTempX<-(GROUND_SIZE*0.5)) tReturn = GRASS;
                    break; };
    case LEFT:      {
                    if ((tTempX>(GROUND_SIZE*0.5)) || (tTempX<-(GROUND_SIZE*0.5))) tReturn = GRASS;
                    break; };
    case RIGHT:     {
                    if ((tTempX>(GROUND_SIZE*0.5)) || (tTempX<-(GROUND_SIZE*0.5))) tReturn = GRASS;
                    break; };
    };
  if ((tTempX>(GROUND_SIZE*2)) ||
      (tTempX<-(GROUND_SIZE*2)) ||
      (tTempZ<-(GROUND_SIZE*2)) ||
      (tTempZ>(GROUND_SIZE*3.5))) tReturn = SMASH;
  return tReturn;
  }