// ***********************************************************************************
// Programs written by R.Swan - rs108@mdx.ac.uk - www.netyaroze-europe.com/~middex2
// STANDARD CODE for handling sprites and 3d
// ***********************************************************************************

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

// **** include files
#include "header.h"                                      // include joypad handling include

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

void InitialiseCounter()
  {
  long tTemp1, tTemp2, tTemp3, tTemp4;

  CurrentCounter = 1;
  LoadTIMData(TIM_NUMBERS);
  for (tTemp1=0; tTemp1<12; tTemp1++)
    {
    if (tTemp1==0)
      {
      tTemp2 = 16; tTemp3 = 0; tTemp4 = 0;
      }
    else
      {
      tTemp2 = 9;
      tTemp3 = (tTemp1-1)*12;
      tTemp4 = 310-8*8-16;
      if (tTemp1>9)
        {
        tTemp2 = 9;
        tTemp3 = (tTemp1-10)*12+20;
        tTemp4 = 0;
        }
      };
    SetSpriteInfo(&Numbers[tTemp1][0], TIM_NUMBERS, tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][1], TIM_NUMBERS, tTemp2*2 +tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][2], TIM_NUMBERS, tTemp2*3 +tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][3], TIM_NUMBERS, tTemp2*5 +tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][4], TIM_NUMBERS, tTemp2*6 +tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][5], TIM_NUMBERS, tTemp2*1 +tTemp4-155, tTemp3-115);
    SetSpriteInfo(&Numbers[tTemp1][6], TIM_NUMBERS, tTemp2*4 +tTemp4-155, tTemp3-115);
    };

  for (tTemp1=0; tTemp1<12; tTemp1++)
    {
    switch(tTemp1)
      {
      case 0:   {tTemp3 = 18; tTemp4 = 0; break;}
      case 1:   {tTemp3 = 10; tTemp4 = 18; break;}
      }
    for (tTemp2=0; tTemp2<7; tTemp2++)
      {
      Numbers[tTemp1][tTemp2].attribute += (1<<30)+(1<<28)+(1<<31);
      Numbers[tTemp1][tTemp2].w = 16;
      Numbers[tTemp1][tTemp2].h = tTemp3;
      Numbers[tTemp1][tTemp2].v = tTemp4;
      if (tTemp1>0) Numbers[tTemp1][tTemp2].r = Numbers[tTemp1][tTemp2].g = (Numbers[tTemp1][tTemp2].b = 63);
      if (tTemp1==10) Numbers[tTemp1][tTemp2].g = 128;
      if (tTemp1==11) Numbers[tTemp1][tTemp2].r = 128;
      }
    Numbers[tTemp1][5].u = Numbers[tTemp1][6].u = 160;
    }
  };

// **** This function transfers a .TIM form main memory to video memory
void LoadTIMData(u_long tMemAddress)
  {
  RECT tRect;                                         // rectangular area to be used for TIM
  GsIMAGE tTim;                                       // TIM image information
  tMemAddress += 4;                                   // advance memory pointer to data
  GsGetTimInfo((u_long *) tMemAddress, &tTim);        // fill tTim with info from TIM
  tRect.x = tTim.px;                                  // tell GPU where graphics data is
  tRect.y = tTim.py;
  tRect.w = tTim.pw;
  tRect.h = tTim.ph;
  LoadImage(&tRect, tTim.pixel);                      // load video memory with TIM data
    tRect.x = tTim.cx;                                // tell GPU where colour table is
    tRect.y = tTim.cy;
    tRect.w = tTim.cw;
    tRect.h = tTim.ch;
    LoadImage(&tRect, tTim.clut);                     // load video memory with CLUT data
  DrawSync(0);                                        // force LoadImages to complete
  };

// **** This sets up sprite information, such as x,y, what .TIM data to use etc. etc.
void SetSpriteInfo(GsSPRITE *tSprite, u_long tMemAddress, long tX, long tY)
  {
  u_long tTexturePageX, tTexturePageY;                // four variables to clear up
  u_long tTexturePageXOffset, tTexturePageYOffset;    // assignment of texture pages
  GsIMAGE tTim;                                       // TIM image information
  u_long tCLUT;

  tMemAddress += 4;                                   // advance memory pointer to data
  GsGetTimInfo((u_long *) tMemAddress, &tTim);        // fill tTim with info from TIM

  tSprite->x = tX;                                    // set sprites screen coordinates
  tSprite->y = tY;                                    // based on values passed
  if (tTim.pmode& 0x01)
    {
    tSprite->attribute = (1<<24);                     // set up for 256 colour sprite
    tSprite->w = tTim.pw*2;
    tCLUT = 1;
    }
  else
    {
    tSprite->attribute = 0;                           // set up for 16 colour sprite
    tSprite->w = tTim.pw*4;
    tCLUT = 0;
    };
  tSprite->h = tTim.ph;
    tTexturePageX = (tTim.px/64) *64;                 // calculate texture page
    tTexturePageY = (tTim.py/256) *256;
    tTexturePageXOffset = tTim.px % 64;
    tTexturePageYOffset = tTim.py % 256;
  tSprite->tpage = GetTPage(tCLUT, 0, tTim.px, tTim.py);
                                                      // calculate correct texture page
  tSprite->u = tTexturePageXOffset*4;                 // offset for sprite from left of tpage
  tSprite->v = tTexturePageYOffset;                   // offset for sprite from top of tpage
  tSprite->cx = tTim.cx;                              // set sprite to use correct CLUT
  tSprite->cy = tTim.cy;

  tSprite->r = tSprite->g = tSprite->b = 128;         // make sure the sprite is set to
                                                      // normal colour intensity
  tSprite->mx = tSprite->w/2;                         // set handle of sprite to the center
  tSprite->my = tSprite->h/2;                         // (this does not need to be done if
                                                      // you would rather move the objects
                                                      // by their top left corner)
  tSprite->scalex = tSprite->scaley = ONE;            // make sure the sprite isn't scaled
  tSprite->rotate = 0;                                // make sure its pointing up
  };