SHARE
TWEET

Psychon

a guest Dec 16th, 2011 208 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //--------------------------------------------------------------
  2. // Playstation Psycheual (Psychon)
  3. //--------------------------------------------------------------
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <libps.h>
  8. #include <string.h>
  9.  
  10. #include "pad.h"
  11.  
  12. #define SOUNDS_VH 0x80090000
  13. #define SOUNDS_VB 0x80091a20
  14. #define BANNER_TIM 0x800adc10
  15. #define BLITFORM_TIM 0x800b7c24
  16. #define BOBS_TIM 0x800fdc38
  17. #define CLEAR_TIM 0x800ffecc
  18. #define FALL_TIM 0x801032e0
  19. #define FLAME_TIM 0x80106ef4
  20. #define FONT_TIM 0x80107408
  21. #define MAIN_TIM 0x8010ea44
  22. #define NUMBERS_TIM 0x801104c0
  23. #define PANEL_TIM 0x8011072c
  24. #define TITLE_TIM 0x80111640
  25. #define WORLD_TIM 0x80116054
  26. #define MAPS_DAT 0x8013b868
  27. #define DEAD_TIM 0x8014f868
  28. #define CONTROL_TIM 0x80153bfc
  29. #define TIME_TIM 0x8015a790
  30. #define GLOBE_TIM 0x8015b1a4
  31. #define INTRO_TIM 0x8015b280
  32. #define SOUNDS2_VH 0x80180a94
  33. #define SOUNDS2_VB 0x801824b4
  34. #define EARTH_TIM 0x80192f14
  35. #define CURSOR_TIM 0x80199bd0
  36. #define SOUNDS3_VB 0x8019a2e4
  37. #define SOUNDS3_VH 0x801ad324
  38.  
  39. #define OT_LEN 12
  40. #define MAX_PACKETS 102400
  41. #define MAX_ENEMIES 200
  42. #define MAX_BSPLATS 256
  43. #define SPACE 8
  44.  
  45. #define PISTOL 5
  46. #define SHOTGUN 6
  47. #define AUTOGUN 7
  48. #define MACHINEGUN 8
  49. #define AUTOPISTOL 9
  50.  
  51. //--------------------------------------------------------------
  52.  
  53. typedef struct
  54. {
  55.   GsSPRITE sprite;
  56.   GsSPRITE flame;
  57.   GsIMAGE image;
  58.   int x,y;
  59.   int d,a,dir;
  60.   int lx,ly;
  61.   int mx,my;
  62.   int score;
  63.   int lives;
  64.   int energy, shield;
  65.   int ammo, keys;
  66.   int damage, rounds;
  67.   int panel, pon;
  68.   int holdL1, holdSQ, holdTR;
  69. }Player;
  70.  
  71. typedef struct
  72. {
  73.   GsSPRITE sprite;
  74.   int dx,dy;
  75.   int x,y;
  76.   int energy;
  77. }Enemy;
  78.  
  79. typedef struct
  80. {
  81.   GsGLINE line;
  82.   int x,y;
  83.   int ax,ay;
  84. }BSplat;
  85.  
  86. u_long PADstatus=0;
  87. volatile u_char *bb0, *bb1;
  88.  
  89. int nFired;
  90. int nTarget;
  91. int nEnemies;
  92. int nKilled;
  93.  
  94. int nGlobes;
  95. int nMin, nSec, nSplit;
  96. int nBuffer;
  97. int bPlaying;
  98. int bRunning=1;
  99. int bComplete;
  100. int nVab;
  101. int nVab2;
  102. int nVab3;
  103. int nMapx;
  104. int nMapy;
  105. int nLevel;
  106. int nMap[4096];
  107. int nGrid[3];
  108. int nFont[91]={0,5,12,25,35,48,59,63,69,74,80,90,93,99,102,110,120,128,137,146,157,167,177,185,195,205,209,213,223,233,243,253,268,278,289,299,310,318,325,336,346,351,358,368,375,389,
  109.                0,11,20,31,41,50,59,70,79,95,104,113,121,126,133,139,147,158,165,174,184,194,203,212,219,228,238,243,249,258,263,278,288,298,307,317,324,332,339,348,357,369,378,386,393};
  110. int nDoor[2];
  111.  
  112. char szScroll[230]="Welcome to Psychon.   Created with the Net Yaroze tools and libraries.  See www.netyaroze-europe.com for more information.   Psychon code, graphics and sound by Ben James. Special thanks to Craig Smith for his design ideas.";
  113.  
  114. char szNames[10][4]={"ELV", "EMA", "JON", "TRI", "POD", "XNA", "SAM", "C J", "ZIQ", "LBE"};
  115. int nScore[10]={10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000};
  116.  
  117. PACKET out_packet[2][MAX_PACKETS];
  118. GsOT othWorld[2];
  119. GsOT_TAG otWorld[2][1<<OT_LEN];
  120.  
  121. Player player1;
  122. Player player2;
  123.  
  124. Player * player;
  125.  
  126. Enemy enemy[MAX_ENEMIES];
  127. BSplat splat[MAX_BSPLATS];
  128.  
  129. int LoadTIM(long);
  130. int Collision(long, long, long, long, long);
  131. int IsCoordAWall(int, int);
  132. int IsObjectOverWall(int, int, int, int);
  133. int IsObjectOverEnemy(int, int, int);
  134. void OutputString(char *, int, int, int);
  135. void OutputNum(int, int, int, int);
  136. void SmearClear(int, int, int, int, int, int);
  137. void CheckPickups(int, int);
  138. int GetCentre(char *);
  139. void GetInput();
  140. void Initialise();
  141. int ShowTitles();
  142. void NewGame();
  143. void NewLevel();
  144. void MoveEnemies();
  145. void KillPlayer();
  146. void CalcScreen();
  147. void DrawMap();
  148. void DrawPlayer();
  149. void DrawEnemies();
  150. void StartFiring();
  151. void FireGun();
  152. void GetGrid(int, int, int, Player*);
  153. int CheckBullet(int, int);
  154. int OpenDoor(int);
  155. int CheckDoors(int);
  156. void DrawPanel(int,int);
  157. void DrawTime();
  158. void ActivateGlobe(int);
  159. void LevelClear();
  160. void GameOver();
  161. void Intro();
  162. void Complete();
  163. int Difference(int, int);
  164. void OtherChecks();
  165. void EnterName();
  166. void StartSplat(int, int, int);
  167. void DrawSplats(void);
  168.  
  169. //--------------------------------------------------------------
  170.  
  171. int main()
  172. {
  173.   int nStrobe=0;
  174.   int nNumplayers;
  175.   long lSync=0;
  176.   char szText[100];
  177.   RECT rClear={0,0,320,512};
  178.   static long lBack=0;
  179.  
  180.   FntLoad(960, 400);
  181.   FntOpen(0, 0, 256, 256, 0, 512);
  182.   srand(3107);
  183.  
  184.   PadInit();
  185.   Initialise();
  186.   Intro();
  187.   SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  188.   SmearClear(127,128,128,1,0,-1);
  189.  
  190.   while(bRunning)
  191.   {
  192.     nNumplayers=ShowTitles();
  193.     SsUtKeyOn(nVab, 3,0, 36, 0, 128,128);
  194.     SmearClear(127,127,128,2,0,0);
  195.     bPlaying=1;
  196.     NewGame(nNumplayers);
  197.  
  198.     while((nLevel<=10)&&(bPlaying)&&(bRunning))
  199.     {
  200.       NewLevel(nLevel);
  201.       bComplete=0;
  202.       while((!bComplete)&&(bPlaying))
  203.       {
  204.         nBuffer=GsGetActiveBuff();
  205.         GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  206.         GsClearOt(0, 0, &othWorld[nBuffer]);
  207.  
  208.         CalcScreen();
  209.         DrawMap();
  210.  
  211.         player=&player1;
  212.         if(player1.lives>-1)
  213.         {
  214.           if(player->energy>=0)
  215.             GetInput();
  216.           else
  217.             KillPlayer();
  218.           DrawPlayer();
  219.           if(player->rounds)
  220.             FireGun();
  221.         }
  222.         DrawPanel(0,256);
  223.        
  224.         player=&player2;
  225.         if(player2.lives>-1)
  226.         {
  227.           if(player->energy>=0)
  228.             GetInput();
  229.           else
  230.             KillPlayer();
  231.           DrawPlayer();
  232.           if(player->rounds)
  233.             FireGun();
  234.         }
  235.         DrawPanel(200,272);
  236.  
  237.         DrawTime();
  238.         MoveEnemies();
  239.         OtherChecks();
  240.         DrawSplats();
  241.         DrawEnemies();
  242.        
  243.         if(CheckDoors(nDoor[0]))
  244.         {
  245.           SsUtKeyOn(nVab2, 0,0, 48, 0, 128,128);
  246.           nDoor[0]=0;
  247.         }
  248.         if(CheckDoors(nDoor[1]))
  249.           nDoor[1]=0;
  250.        
  251.         GsDrawOt(&othWorld[nBuffer]);
  252.           FntFlush(-1);
  253.  
  254.         DrawSync(0);
  255.         lSync=VSync(0);
  256.  
  257.         GsSwapDispBuff();
  258.         GsSortClear(0,0,0,&othWorld[nBuffer]);
  259.    
  260.         nSplit--;
  261.         if(nSplit<0)
  262.         {
  263.           nSplit=50;
  264.           nSec--;
  265.         }
  266.         if(nSec<0)
  267.         {
  268.           nSec=59;
  269.           nMin--;
  270.         }
  271.         if(nMin<0)
  272.           bPlaying=0;
  273.        
  274.         if(!nStrobe)
  275.           SsUtKeyOn(nVab3, 0,0, 36, 0, 70,70);
  276.         nStrobe++;
  277.         if(nStrobe>=160)
  278.           nStrobe=0;
  279.       }  
  280.       SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  281.       if(bComplete)
  282.       {
  283.         SmearClear(128,127,127,1,0,0);
  284.         LevelClear();
  285.         SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  286.         SmearClear(127,127,128,1,1,0);
  287.         nLevel++;
  288.       }
  289.       else
  290.       {
  291.         SmearClear(128,127,127,1,0,1);
  292.         GameOver();
  293.         SmearClear(128,127,127,2,0,1);
  294.       }
  295.     }
  296.     if(nLevel==11)
  297.       Complete();
  298.  
  299.     if(player1.lives>-1)
  300.     {
  301.       player=&player1;
  302.       if(player->score>nScore[9])
  303.         EnterName();
  304.     }
  305.     if(player2.lives>-1)
  306.     {
  307.       player=&player2;
  308.       if(player->score>nScore[9])
  309.         EnterName();
  310.     }
  311.   }
  312.   SsVabClose(nVab);
  313.   SsVabClose(nVab2);
  314.   SsVabClose(nVab3);
  315.   ClearImage(&rClear,0,0,0);
  316.   ResetGraph(3);
  317.   return 0;
  318. }
  319.  
  320. //--------------------------------------------------------------
  321.  
  322. int ShowTitles(void)
  323. {
  324.   int nSound=250;
  325.   int nTimer=0;
  326.   int nOff;
  327.   int nCount;
  328.   int nPlayer;
  329.   int nNumPlayers=0;
  330.   char szText[128];
  331.   RECT rClear={0,0,320,512};
  332.   RECT rArea={704,325,320,64};
  333.   RECT rPlanet={0,0,320,0};
  334.   RECT rControl={832,426,160,86};
  335.   GsSPRITE title;
  336.  
  337.   title.attribute=1<<25;
  338.   title.w=256;
  339.   title.h=37;
  340.   title.mx=128;
  341.   title.my=18;
  342.   title.u=0;
  343.   title.v=32;
  344.   title.tpage=GetTPage(2, 0, 704, 288);
  345.  
  346.   nCount=360;
  347.  
  348.   ClearImage(&rClear, 0, 0, 0);
  349.   rClear.h=256;
  350.  
  351.   LoadTIM(TITLE_TIM);
  352.   LoadTIM(BANNER_TIM);
  353.   LoadTIM(CONTROL_TIM);
  354.  
  355.   do
  356.   {
  357.     nBuffer=GsGetActiveBuff();
  358.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  359.     GsClearOt(0, 0, &othWorld[nBuffer]);
  360.  
  361.     rClear.y=nBuffer*256;
  362.     ClearImage(&rClear, 0, 0, 0);
  363.    
  364.     if(nTimer==2000)
  365.     {
  366.       SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  367.       SmearClear(128,128,128,1,0,-1);
  368.       nSound+=92;
  369.     }
  370.     else if(nTimer==3329)
  371.     {
  372.       SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  373.       SmearClear(128,128,128,1,0,1);
  374.       nSound+=92;
  375.     }
  376.    
  377.     if(nTimer<2000)
  378.     {  
  379.       if(!nTimer)
  380.       {
  381.         title.r=127;
  382.         title.g=127;
  383.         title.b=127;
  384.         SsUtKeyOn(nVab2, 1,0, 44, 0, 128,128);
  385.       }
  386.      
  387.       MoveImage(&rArea, 0, (nBuffer*256));
  388.       if(nCount>=0)
  389.       {
  390.         title.scalex=ONE+(8*nCount);
  391.         title.scaley=ONE+(8*nCount);
  392.         title.rotate=ONE*nCount;
  393.         title.x=160;
  394.         title.y=32+(nCount/2);
  395.         nCount-=10;
  396.       }
  397.       else if(title.r==127)
  398.       {
  399.         SsUtKeyOn(nVab, 1,0, 48, 0, 128,128);
  400.         title.r=248;
  401.         title.g=248;
  402.         title.b=248;
  403.       }
  404.       else if(title.r>128)
  405.       {
  406.         title.r-=10;
  407.         title.g-=10;
  408.         title.b-=10;
  409.       }
  410.       else
  411.       {
  412.         nCount--;
  413.         if(nCount<-50)
  414.           nCount=-1;
  415.       }
  416.      
  417.       if((nTimer<1000)&&(nTimer>100))
  418.       {
  419.         strcpy(szText, "CONTROLS");
  420.         OutputString(szText, -1, GetCentre(szText), 70);
  421.         MoveImage(&rControl, 80, 100+(nBuffer*256));
  422.         if(nCount<-10)
  423.         {
  424.           strcpy(szText, "Controller 1 START - 1 Player");
  425.           OutputString(szText, -1, GetCentre(szText) ,193);
  426.           strcpy(szText, "Controller 2 START - 2 Players");
  427.           OutputString(szText, -1, GetCentre(szText) ,217);
  428.         }
  429.       }
  430.       else if(nTimer>100)
  431.       {
  432.         nOff=16320-(nTimer*16);
  433.         if(nOff<10)
  434.           nOff=10;
  435.  
  436.         if(nTimer==1000)
  437.           SsUtKeyOn(nVab2, 1,0, 44, 0, 128,128);
  438.         strcpy(szText, "Today's Best Scores");
  439.         OutputString(szText, -1, GetCentre(szText), 70);
  440.         for(nPlayer=1; nPlayer<=5; nPlayer++)
  441.         {
  442.           sprintf(szText, "%d", nPlayer);
  443.           OutputString(szText, -1, nOff+0, 80+(nPlayer*23));
  444.           OutputString(szNames[nPlayer-1], -1, nOff+24, 80+(nPlayer*23));
  445.           sprintf(szText, "%5.5d", nScore[nPlayer-1]);
  446.           OutputString(szText, -1, nOff+80, 80+(nPlayer*23));
  447.         }
  448.         for(nPlayer=6; nPlayer<=10; nPlayer++)
  449.         {
  450.           sprintf(szText, "%d", nPlayer);
  451.           OutputString(szText, -1, 190-nOff, 80+((nPlayer-5)*23));
  452.           OutputString(szNames[nPlayer-1], -1, 214-nOff, 80+((nPlayer-5)*23));
  453.           sprintf(szText, "%5.5d", nScore[nPlayer-1]);
  454.           OutputString(szText, -1, 270-nOff, 80+((nPlayer-5)*23));
  455.         }
  456.       }
  457.      
  458.       GsSortSprite(&title, &othWorld[nBuffer], 0);
  459.     }
  460.     else
  461.     {
  462.       nCount=nTimer-2000;
  463.       if(nCount>200)
  464.         nCount=200;
  465.      
  466.       rPlanet.y=240-nCount+(nBuffer*256);
  467.       rPlanet.h=nCount;
  468.      
  469.       LoadImage(&rPlanet, (u_long *)WORLD_TIM+5);
  470.    
  471.       OutputString(szScroll, -1, 4400-(nTimer*2), 0);
  472.     }
  473.    
  474.     nTimer++;
  475.     if(nTimer>3330)
  476.       nTimer=0;
  477.    
  478.     GsDrawOt(&othWorld[nBuffer]);
  479.     DrawSync(0);
  480.     VSync(0);
  481.     GsSwapDispBuff();
  482.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  483.  
  484.     nSound++;
  485.     if(nSound>340)
  486.     {
  487.       SsUtKeyOn(nVab3, 2,0, 36, 0, 128,128);
  488.       nSound=0;
  489.     }
  490.  
  491.     PADstatus=PadRead(0);
  492.     if(PADstatus & PADselect)
  493.       bRunning=0;
  494.     if(PADstatus & PADstart)
  495.       nNumPlayers=1;
  496.  
  497.     PADstatus=PADstatus>>16;
  498.     if(PADstatus & PADstart)
  499.       nNumPlayers=2;
  500.  
  501.   } while(!nNumPlayers&&bRunning);
  502.   return nNumPlayers;
  503. }
  504.  
  505.  
  506. //--------------------------------------------------------------
  507.  
  508. int LoadTIM(long addr)
  509. {
  510.   RECT rect;
  511.   GsIMAGE tim1;
  512.  
  513.   GsGetTimInfo((u_long *)(addr+4),&tim1);
  514.  
  515.   rect.x=tim1.px;
  516.   rect.y=tim1.py;
  517.   rect.w=tim1.pw;
  518.   rect.h=tim1.ph;
  519.  
  520.   LoadImage(&rect,tim1.pixel);
  521.  
  522.   if((tim1.pmode>>3)&0x01)
  523.   {
  524.     rect.x=tim1.cx;
  525.     rect.y=tim1.cy;
  526.     rect.w=tim1.cw;
  527.     rect.h=tim1.ch;
  528.  
  529.     LoadImage(&rect,tim1.clut);
  530.   }
  531.  
  532.   DrawSync(0);
  533.   return(0);
  534. }
  535.  
  536.  
  537. //--------------------------------------------------------------
  538.  
  539. void Initialise()
  540. {
  541.   SetVideoMode(MODE_PAL);
  542.   GsInitGraph(320, 240, GsINTER|GsOFSGPU, 0, 0);
  543.   GsDefDispBuff(0, 0, 0, 256);
  544.  
  545.   othWorld[0].length=OT_LEN;
  546.   othWorld[1].length=OT_LEN;
  547.   othWorld[0].org=otWorld[0];
  548.   othWorld[1].org=otWorld[1];
  549.  
  550.   GsClearOt(0,0,&othWorld[0]);
  551.   GsClearOt(0,0,&othWorld[1]);
  552.  
  553.   LoadTIM(FONT_TIM);
  554.   LoadTIM(NUMBERS_TIM);
  555.  
  556.   GsGetTimInfo((unsigned long *)MAIN_TIM+4, &player1.image);
  557.   GsGetTimInfo((unsigned long *)MAIN_TIM+4, &player2.image);
  558.  
  559.   player1.sprite.attribute= 1 << 25;
  560.   player1.sprite.w=26;
  561.   player1.sprite.h=26;
  562.   player1.sprite.r=128;
  563.   player1.sprite.g=128;
  564.   player1.sprite.b=128;
  565.   player1.sprite.scalex=ONE;
  566.   player1.sprite.scaley=ONE;
  567.   player1.sprite.mx=13;
  568.   player1.sprite.my=13;
  569.   player1.sprite.u=0;
  570.  
  571.   player2.sprite.attribute= 1 << 25;
  572.   player2.sprite.w=26;
  573.   player2.sprite.h=26;
  574.   player2.sprite.r=128;
  575.   player2.sprite.g=128;
  576.   player2.sprite.b=128;
  577.   player2.sprite.scalex=ONE;
  578.   player2.sprite.scaley=ONE;
  579.   player2.sprite.mx=13;
  580.   player2.sprite.my=13;
  581.   player2.sprite.u=0;
  582.  
  583.   player1.flame.attribute=(1<<25);
  584.   player1.flame.w=16;
  585.   player1.flame.h=40;
  586.   player1.flame.mx=8;
  587.   player1.flame.my=40;
  588.   player1.flame.tpage=GetTPage(2, 0, 768, 0);
  589.  
  590.   player2.flame.attribute=(1<<25);
  591.   player2.flame.w=16;
  592.   player2.flame.h=40;
  593.   player2.flame.mx=8;
  594.   player2.flame.my=40;
  595.   player2.flame.tpage=GetTPage(2, 0, 768, 0);
  596.  
  597.   nVab=SsVabTransfer((u_char *)SOUNDS_VH, (u_char *)SOUNDS_VB, -1, 1);
  598.   nVab2=SsVabTransfer((u_char *)SOUNDS2_VH, (u_char *)SOUNDS2_VB, -1, 1);
  599.   nVab3=SsVabTransfer((u_char *)SOUNDS3_VH, (u_char *)SOUNDS3_VB, -1, 1);
  600. }
  601.  
  602.  
  603. //--------------------------------------------------------------
  604.  
  605. void NewGame(int numplayers)
  606. {
  607.   RECT rPanel={704,256,120,16};
  608.  
  609.   LoadTIM(BLITFORM_TIM);
  610.   LoadTIM(MAIN_TIM);
  611.   LoadTIM(FLAME_TIM);
  612.   LoadTIM(BOBS_TIM);
  613.   LoadTIM(FALL_TIM);
  614.   LoadTIM(PANEL_TIM);
  615.  
  616.   MoveImage(&rPanel, 704, 272);
  617.  
  618.   nLevel=1;
  619.   nMin=60;
  620.   nSec=0;
  621.   nSplit=50;
  622.  
  623.   player1.a=0;
  624.   player1.keys=20;
  625.   player1.ammo=500;
  626.   player1.damage=PISTOL;
  627.   player1.energy=100;
  628.   player1.score=0;
  629.   player1.pon=1;
  630.   player1.flame.r=128;
  631.   player1.flame.g=128;
  632.   player1.flame.b=128;
  633.   player1.flame.scalex=ONE;
  634.   player1.flame.scaley=ONE;
  635.  
  636.   player2.a=0;
  637.   player2.keys=20;
  638.   player2.ammo=500;
  639.   player2.damage=PISTOL;
  640.   player2.energy=100;
  641.   player2.score=0;
  642.   player2.flame.r=128;
  643.   player2.flame.g=128;
  644.   player2.flame.b=128;
  645.   player2.flame.scalex=ONE;
  646.   player2.flame.scaley=ONE;
  647.  
  648.   player1.lives=3;
  649.   if(numplayers==2)
  650.   {
  651.     player2.lives=3;
  652.     player2.pon=1;
  653.   }
  654.   else
  655.   {
  656.     player2.lives=-1;
  657.     player2.pon=0;
  658.   }
  659. }
  660.  
  661.  
  662. //--------------------------------------------------------------
  663.  
  664. void NewLevel()
  665. {
  666.   int nCount;
  667.   int nEnemy=0;
  668.   unsigned char * lSource;
  669.   static int x[10]={32,32,32,32,32,32,32,32,16,0};
  670.   static int y[10]={-16,-16,0,0,0,0,0,-16,-32,-32};
  671.    
  672.   LoadTIM(TIME_TIM);
  673.   LoadTIM(GLOBE_TIM);
  674.  
  675.   nGlobes=0;
  676.   nFired=0;
  677.   nTarget=0;
  678.   nEnemies=0;
  679.   nKilled=0;
  680.  
  681.   for(nCount=0; nCount<MAX_ENEMIES; nCount++)
  682.   {
  683.     enemy[nCount].sprite.attribute=1<<25;
  684.     enemy[nCount].sprite.mx=12;
  685.     enemy[nCount].sprite.my=12;
  686.     enemy[nCount].energy=-9;
  687.     enemy[nCount].dx=0;
  688.     enemy[nCount].dy=0;
  689.     enemy[nCount].sprite.w=24;
  690.     enemy[nCount].sprite.h=23;
  691.     enemy[nCount].sprite.rotate=(nCount&7)*ONE*45;
  692.     enemy[nCount].sprite.scalex=ONE;
  693.     enemy[nCount].sprite.scaley=ONE;
  694.     enemy[nCount].sprite.r=128;
  695.     enemy[nCount].sprite.g=128;
  696.     enemy[nCount].sprite.b=128;
  697.   }
  698.  
  699.   lSource=(unsigned char *)MAPS_DAT+(8192*(nLevel-1));
  700.  
  701.   for(nCount=0; nCount<4096; nCount++)
  702.   {
  703.     nMap[nCount]=(unsigned char)(*lSource)*256;
  704.     nMap[nCount]+=(unsigned char)*(lSource+1);
  705.  
  706.     switch(nMap[nCount])
  707.     {
  708.       case 109:
  709.       case 110:
  710.       player1.x=((nCount%64)*16)+15;
  711.       player1.y=((nCount/64)*16)+15;
  712.       player1.lx=player1.x;
  713.       player1.ly=player1.y;
  714.  
  715.       player2.x=player1.x+x[nLevel-1];
  716.       player2.y=player1.y+y[nLevel-1];
  717.       player2.lx=player2.x;
  718.       player2.ly=player2.y;
  719.       break;
  720.    
  721.       case 117:
  722.       case 118:
  723.       case 119:
  724.       case 120:
  725.       enemy[nEnemy].energy=5+(nLevel*4);
  726.       enemy[nEnemy].x=(1+nCount%64)*16;
  727.       enemy[nEnemy].y=(1+nCount/64)*16;
  728.       nEnemy++;
  729.       nEnemies++;
  730.       break;
  731.  
  732.       default:
  733.       break;
  734.     }
  735.  
  736.     lSource++;
  737.     lSource++;
  738.   }
  739.  
  740.   nDoor[0]=0;
  741.   nDoor[1]=0;
  742.  
  743.   player1.sprite.rotate=0;
  744.   player1.rounds=0;
  745.   player1.shield=100;
  746.  
  747.   player2.sprite.rotate=0;
  748.   player2.rounds=0;
  749.   player2.shield=100;
  750. }
  751.  
  752.  
  753. //--------------------------------------------------------------
  754.  
  755. void GetInput()
  756. {
  757.   Player * otherplayer;
  758.   PADstatus=PadRead(0);
  759.  
  760.   if(player==&player2)
  761.   {
  762.     PADstatus=PADstatus>>16;
  763.     otherplayer=&player1;
  764.   }
  765.   else
  766.     otherplayer=&player2;
  767.  
  768.   if(PADstatus & PADLup)
  769.     player->y-=2;
  770.   else if(PADstatus & PADLdown)
  771.     player->y+=2;
  772.  
  773.   GetGrid(player->x, player->y, 12, otherplayer);
  774.   player->my=player->y;
  775.  
  776.   if(IsObjectOverWall(player->x, player->y, 12, 1))
  777.   {
  778.     if(player->y<player->ly)
  779.     {
  780.       if(!nGrid[0])
  781.         player->x-=2;
  782.       if(!nGrid[1])
  783.         player->x+=2;
  784.     }
  785.     else
  786.     {
  787.       if(!nGrid[2])
  788.         player->x-=2;
  789.       if(!nGrid[3])
  790.         player->x+=2;
  791.     }
  792.     player->y=player->ly;
  793.   }
  794.   if((Difference(player->y,otherplayer->y)>=240)&&(otherplayer->lives>-1))
  795.     player->y=player->ly;
  796.   if(otherplayer->lives>-1)
  797.   {
  798.     if((Difference(player->x, otherplayer->x)<22)&&(Difference(player->y, otherplayer->y)<22))
  799.     //if(Collision(player->x, player->y, otherplayer->x, otherplayer->y, 20))
  800.       player->y=player->ly;
  801.   }
  802.  
  803.   if(PADstatus & PADLleft)
  804.     player->x-=2;
  805.   else if(PADstatus & PADLright)
  806.     player->x+=2;
  807.  
  808.   GetGrid(player->x, player->y, 12, otherplayer);
  809.   player->mx=player->x;
  810.  
  811.   if(IsObjectOverWall(player->x, player->y, 12, 1))
  812.   {
  813.     if(player->x<player->lx)
  814.     {
  815.       if(!nGrid[0])
  816.         player->y-=2;
  817.       if(!nGrid[2])
  818.         player->y+=2;
  819.     }
  820.     else
  821.     {
  822.       if(!nGrid[1])
  823.         player->y-=2;
  824.       if(!nGrid[3])
  825.         player->y+=2;
  826.     }
  827.     player->x=player->lx;
  828.   }
  829.   if((Difference(player->x,otherplayer->x)>=320)&&(otherplayer->lives>-1))
  830.     player->x=player->lx;
  831.   if(otherplayer->lives>-1)
  832.   {
  833.     if((Difference(player->x, otherplayer->x)<22)&&(Difference(player->y, otherplayer->y)<22))
  834.     //if(Collision(player->x, player->y, otherplayer->x, otherplayer->y, 20))
  835.       player->x=player->lx;
  836.   }
  837.  
  838.   if(Difference(player->x, player->lx)>2)
  839.   {
  840.     if(player->x>player->lx)
  841.       player->x=player->lx+2;
  842.     else
  843.       player->x=player->lx-2;
  844.   }
  845.   if(Difference(player->y, player->ly)>2)
  846.   {
  847.     if(player->y>player->ly)
  848.       player->y=player->ly+2;
  849.     else
  850.       player->y=player->ly-2;
  851.   }
  852.  
  853.   CheckPickups(player->x+4, player->y+4);
  854.   CheckPickups(player->x+4, player->y-4);
  855.   CheckPickups(player->x-4, player->y+4);
  856.   CheckPickups(player->x-4, player->y-4);
  857.  
  858.   //if(PADstatus & PADL1)
  859.     //bComplete=1;
  860.  
  861.   if(PADstatus & PADRup)
  862.   {
  863.     if(!player->holdTR)
  864.       player->pon=!player->pon;
  865.     player->holdTR=1;
  866.   }
  867.   else
  868.     player->holdTR=0;    
  869.  
  870.   if(PADstatus & PADselect)
  871.     bPlaying=0;
  872.  
  873.   if(PADstatus & PADRdown)
  874.   {
  875.     if((!player->rounds)&&(!player->holdSQ))
  876.       StartFiring();
  877.     player->holdSQ=1;
  878.   }
  879.   else
  880.     player->holdSQ=0;
  881.  
  882.   if(!player->shield)
  883.   {
  884.     if(IsObjectOverEnemy(player->x, player->y, 12))
  885.     {
  886.       player->energy--;
  887.       player->sprite.r=255;
  888.       player->sprite.g=255;
  889.       player->sprite.b=255;
  890.       player->x=player->lx;
  891.       player->y=player->ly;
  892.     }
  893.   }
  894. }
  895.  
  896. //--------------------------------------------------------------
  897.  
  898. void GetGrid(int x, int y, int r, Player* otherplayer)
  899. {
  900.   int nAddr;
  901.  
  902.   nAddr=((x-r)>>4)+(((y-r)<<2)&0xffc0);
  903.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  904.     nGrid[0]=1;
  905.   else
  906.     nGrid[0]=0;
  907.   nAddr=((x+r)>>4)+(((y-r)<<2)&0xffc0);
  908.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  909.     nGrid[1]=1;
  910.   else
  911.     nGrid[1]=0;
  912.  
  913.   nAddr=((x+r)>>4)+(((y+r)<<2)&0xffc0);
  914.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  915.     nGrid[3]=1;
  916.   else
  917.     nGrid[3]=0;
  918.  
  919.   nAddr=((x-r)>>4)+(((y+r)<<2)&0xffc0);
  920.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  921.     nGrid[2]=1;
  922.   else
  923.     nGrid[2]=0;
  924.  
  925.   if(otherplayer->lives>-1)
  926.   {
  927.     if((Difference(x-r, otherplayer->x)<12)&&(Difference(y-r, otherplayer->y)<12))
  928.       nGrid[0]=1;
  929.     if((Difference(x+r, otherplayer->x)<12)&&(Difference(y-r, otherplayer->y)<12))
  930.       nGrid[1]=1;
  931.     if((Difference(x+r, otherplayer->x)<12)&&(Difference(y+r, otherplayer->y)<12))
  932.       nGrid[3]=1;
  933.     if((Difference(x-r, otherplayer->x)<12)&&(Difference(y+r, otherplayer->y)<12))
  934.       nGrid[2]=1;
  935.   }
  936. }
  937.  
  938. //--------------------------------------------------------------
  939.  
  940. void KillPlayer()
  941. {
  942.   int nCount;
  943.  
  944.   if(player->energy==-1)
  945.   {
  946.     SsUtKeyOn(nVab2, 6,0, 48, 0, 128,128);
  947.     player->lives--;
  948.     if(player->lives==-1)
  949.       player->pon=0;
  950.   }
  951.  
  952.   player->energy--;
  953.  
  954.   nCount=50+player->energy;
  955.   if(nCount)
  956.   {
  957.     player->sprite.scalex=ONE-(81*(-player->energy));
  958.     player->sprite.scaley=ONE-(81*(-player->energy));
  959.     player->sprite.rotate=nCount*20*ONE;
  960.   }
  961.   else
  962.   {
  963.     player->energy=100;
  964.     player->sprite.scalex=ONE;
  965.     player->sprite.scaley=ONE;
  966.     player->sprite.rotate=0;
  967.     player->shield=50;
  968.   }
  969. }
  970.  
  971.  
  972. //--------------------------------------------------------------
  973.  
  974. int Collision(long cx, long cy, long x, long y, long r)
  975. {
  976.   if((x>cx-r && x<cx+r) && (y>cy-r && y<cy+r))
  977.     return 1;
  978.   else
  979.     return 0;
  980. }
  981.  
  982.  
  983. //--------------------------------------------------------------
  984.  
  985. void MoveEnemies()
  986. {
  987.   int lx,ly;
  988.   int nCount;
  989.   int hit=0;
  990.  
  991.   for(nCount=0; nCount<MAX_ENEMIES; nCount++)
  992.   {
  993.     if(enemy[nCount].energy==-9)
  994.       return;
  995.    
  996.     if(enemy[nCount].energy>-1)
  997.     {
  998.       if(((enemy[nCount].sprite.x>-13)&&(enemy[nCount].sprite.x<333))&&
  999.         ((enemy[nCount].sprite.y>-13)&&(enemy[nCount].sprite.y<253)))
  1000.       {
  1001.         lx=enemy[nCount].x;
  1002.         ly=enemy[nCount].y;
  1003.        
  1004.         switch(enemy[nCount].sprite.rotate)
  1005.         {
  1006.           case 0:
  1007.           enemy[nCount].y-=2;
  1008.           break;
  1009.  
  1010.           case 45*ONE:
  1011.           enemy[nCount].x+=2;
  1012.           enemy[nCount].y-=2;
  1013.           break;
  1014.  
  1015.           case 90*ONE:
  1016.           enemy[nCount].x+=2;
  1017.           break;
  1018.  
  1019.           case 135*ONE:
  1020.           enemy[nCount].x+=2;
  1021.           enemy[nCount].y+=2;
  1022.           break;
  1023.  
  1024.           case 180*ONE:
  1025.           enemy[nCount].y+=2;
  1026.           break;
  1027.  
  1028.           case 225*ONE:
  1029.           enemy[nCount].x-=2;
  1030.           enemy[nCount].y+=2;
  1031.           break;
  1032.  
  1033.           case 270*ONE:
  1034.           enemy[nCount].x-=2;
  1035.           break;
  1036.  
  1037.           case 315*ONE:
  1038.           enemy[nCount].x-=2;
  1039.           enemy[nCount].y-=2;
  1040.           break;
  1041.    
  1042.           default:
  1043.           break;
  1044.         }
  1045.        
  1046.         if((IsObjectOverEnemy(enemy[nCount].x, enemy[nCount].y, 12))||(IsObjectOverWall(enemy[nCount].x, enemy[nCount].y, 12, 0)))
  1047.         {
  1048.           enemy[nCount].x=lx;
  1049.           enemy[nCount].y=ly;
  1050.           enemy[nCount].sprite.rotate+=(45*ONE);
  1051.           if(enemy[nCount].sprite.rotate>=360*ONE)
  1052.             enemy[nCount].sprite.rotate=0;
  1053.         }
  1054.         else
  1055.         {
  1056.           if(rand()>31500)
  1057.           {
  1058.             enemy[nCount].sprite.rotate-=(45*ONE);
  1059.             if(enemy[nCount].sprite.rotate<0)
  1060.               enemy[nCount].sprite.rotate=315*ONE;
  1061.           }
  1062.           if(player1.lives>-1)
  1063.           {
  1064.             if(Collision(enemy[nCount].x, enemy[nCount].y, player1.x, player1.y, 20))
  1065.             {
  1066.               enemy[nCount].x=lx;
  1067.               enemy[nCount].y=ly;
  1068.               enemy[nCount].sprite.rotate+=(45*ONE);
  1069.               if(enemy[nCount].sprite.rotate>=360*ONE)
  1070.                 enemy[nCount].sprite.rotate=0;
  1071.             }
  1072.           }
  1073.           if(player2.lives>-1)
  1074.           {
  1075.             if(Collision(enemy[nCount].x, enemy[nCount].y, player2.x, player2.y, 20))
  1076.             {
  1077.               enemy[nCount].x=lx;
  1078.               enemy[nCount].y=ly;
  1079.               enemy[nCount].sprite.rotate+=(45*ONE);
  1080.               if(enemy[nCount].sprite.rotate>=360*ONE)
  1081.                 enemy[nCount].sprite.rotate=0;
  1082.             }
  1083.           }
  1084.         }
  1085.       }
  1086.     }
  1087.     else if((enemy[nCount].dx)||(enemy[nCount].dy))
  1088.     {
  1089.       enemy[nCount].x+=enemy[nCount].dx;
  1090.       if(IsObjectOverWall(enemy[nCount].x, enemy[nCount].y, 12, 0))
  1091.       {
  1092.         enemy[nCount].x-=enemy[nCount].dx;
  1093.         enemy[nCount].dx=0;
  1094.       }
  1095.      
  1096.       enemy[nCount].y+=enemy[nCount].dy;
  1097.       if(IsObjectOverWall(enemy[nCount].x, enemy[nCount].y, 12, 0))
  1098.       {
  1099.         enemy[nCount].y-=enemy[nCount].dy;
  1100.         enemy[nCount].dy=0;
  1101.       }
  1102.      
  1103.       if(enemy[nCount].dx>0)
  1104.         enemy[nCount].dx--;
  1105.       else if(enemy[nCount].dx<0)
  1106.         enemy[nCount].dx++;
  1107.       if(enemy[nCount].dy>0)
  1108.         enemy[nCount].dy--;
  1109.       else if(enemy[nCount].dy<0)
  1110.         enemy[nCount].dy++;
  1111.     }
  1112.   }
  1113. }
  1114.  
  1115. //--------------------------------------------------------------
  1116.  
  1117. void CalcScreen()
  1118. {
  1119.   int x=0,y=0,c=0;
  1120.  
  1121.   if(player1.lives>-1)
  1122.   {
  1123.     x=player1.x;
  1124.     y=player1.y;
  1125.     c=1;
  1126.   }
  1127.   if(player2.lives>-1)
  1128.   {
  1129.     x+=player2.x;
  1130.     y+=player2.y;
  1131.     c++;
  1132.   }
  1133.  
  1134.  
  1135.   nMapx=(x/c)-160;
  1136.   nMapy=(y/c)-120;
  1137.  
  1138.   if(nMapx<0)
  1139.     nMapx=0;
  1140.   else if(nMapx>(44*16))
  1141.     nMapx=(44*16);
  1142.  
  1143.   if(nMapy<0)
  1144.     nMapy=0;
  1145.   else if(nMapy>(49*16))
  1146.     nMapy=(49*16);
  1147. }
  1148.  
  1149. //--------------------------------------------------------------
  1150.  
  1151. void DrawMap()
  1152. {
  1153.   int nX;
  1154.   int nY;
  1155.   int nBlock;
  1156.   static int nAnim=0;
  1157.   RECT rBlock={0,0,320,240};
  1158.  
  1159.   rBlock.y=nBuffer*256;
  1160.  
  1161.   if((player1.lives<0)||(player2.lives<0))
  1162.     LoadImage(&rBlock, (u_long *)WORLD_TIM+5);
  1163.  
  1164.   rBlock.w=16;
  1165.   rBlock.h=16;
  1166.  
  1167.   nAnim++;
  1168.   if(nAnim>=16)
  1169.     nAnim=0;
  1170.  
  1171.   for(nY=0; nY<16; nY++)
  1172.   {
  1173.     for(nX=0; nX<21; nX++)
  1174.     {
  1175.       nBlock=nMap[(nX+(nMapx/16))+((nY+(nMapy/16))*64)];
  1176.      
  1177.       if(nBlock)
  1178.       {
  1179.         nBlock--;
  1180.        
  1181.         if((nBlock>=286)&&(nBlock<510))
  1182.           nBlock+=(nAnim/2);
  1183.        
  1184.         rBlock.x=336+((nBlock%20)*16);
  1185.         rBlock.y=(nBlock/20)*16;
  1186.      
  1187.         MoveImage(&rBlock, nX*16-(nMapx%16), (nBuffer*256)+nY*16-(nMapy%16));
  1188.       }
  1189.       else if((player1.lives>-1)&&(player2.lives>-1))
  1190.       {
  1191.         rBlock.x=nX*16-(nMapx%16);
  1192.         rBlock.y=(nBuffer*256)+nY*16-(nMapy%16);
  1193.         ClearImage(&rBlock, 0,0,0);
  1194.       }
  1195.     }
  1196.   }
  1197. }
  1198.  
  1199.  
  1200. //--------------------------------------------------------------
  1201.  
  1202. void DrawPlayer()
  1203. {
  1204.   player->sprite.u=0;
  1205.   player->sprite.v=player->a*player->sprite.h;
  1206.   player->sprite.x=player->x-nMapx;
  1207.   player->sprite.y=player->y-nMapy;
  1208.   player->sprite.tpage=GetTPage(2, 0, 704, 0);
  1209.  
  1210.   if((player->mx==player->lx)&&(player->my<player->ly))
  1211.     player->sprite.rotate=0;
  1212.   else if((player->mx>player->lx)&&(player->my<player->ly))
  1213.     player->sprite.rotate=45*ONE;
  1214.   else if((player->mx>player->lx)&&(player->my==player->ly))
  1215.     player->sprite.rotate=90*ONE;
  1216.   else if((player->mx>player->lx)&&(player->my>player->ly))
  1217.     player->sprite.rotate=135*ONE;
  1218.   else if((player->mx==player->lx)&&(player->my>player->ly))
  1219.     player->sprite.rotate=180*ONE;
  1220.   else if((player->mx<player->lx)&&(player->my>player->ly))
  1221.     player->sprite.rotate=225*ONE;
  1222.   else if((player->mx<player->lx)&&(player->my==player->ly))
  1223.     player->sprite.rotate=270*ONE;
  1224.   else if((player->mx<player->lx)&&(player->my<player->ly))
  1225.     player->sprite.rotate=315*ONE;
  1226.  
  1227.   if(!(player->shield&1))
  1228.     GsSortSprite(&player->sprite, &othWorld[nBuffer], 0);
  1229.  
  1230.   if((player->lx!=player->x)||(player->ly!=player->y))
  1231.     player->a+=player->dir;
  1232.  
  1233.   if(player->a>=4)
  1234.     player->dir=-1;
  1235.   else if(player->a<=0)
  1236.     player->dir=1;
  1237.  
  1238.   if(player->shield)
  1239.     player->shield--;
  1240.  
  1241.   player->lx=player->x;
  1242.   player->ly=player->y;
  1243.  
  1244.   player->sprite.r=128;
  1245.   player->sprite.g=128;
  1246.   player->sprite.b=128;
  1247. }
  1248.  
  1249.  
  1250. //--------------------------------------------------------------
  1251.  
  1252. void DrawEnemies()
  1253. {
  1254.   int nPri;
  1255.   int nCount=0;
  1256.   static int nAnim=0;
  1257.  
  1258.   for(nCount=0; nCount<MAX_ENEMIES; nCount++)
  1259.   {
  1260.     if(enemy[nCount].energy>-9)
  1261.     {
  1262.       enemy[nCount].sprite.x=enemy[nCount].x-nMapx;
  1263.       enemy[nCount].sprite.y=enemy[nCount].y-nMapy;
  1264.       if(((enemy[nCount].sprite.x>-13)&&(enemy[nCount].sprite.x<333))&&
  1265.         ((enemy[nCount].sprite.y>-13)&&(enemy[nCount].sprite.y<253)))
  1266.       {
  1267.         if(enemy[nCount].energy>-1)
  1268.         {
  1269.           enemy[nCount].sprite.v=23*nAnim;
  1270.           enemy[nCount].sprite.tpage=GetTPage(2, 0, 832, 0);
  1271.           nPri=1;
  1272.         }
  1273.         else
  1274.         {
  1275.           enemy[nCount].sprite.mx=16;
  1276.           enemy[nCount].sprite.my=15;
  1277.           enemy[nCount].sprite.w=32;
  1278.           enemy[nCount].sprite.h=30;
  1279.           enemy[nCount].sprite.v=30*(-(enemy[nCount].energy+1));
  1280.           enemy[nCount].sprite.tpage=GetTPage(2, 0, 896, 0);
  1281.           if(enemy[nCount].energy>-8)
  1282.           {
  1283.             if(nAnim&1)
  1284.               enemy[nCount].energy--;
  1285.             enemy[nCount].sprite.rotate+=ONE*11;
  1286.           }
  1287.           nPri=2;
  1288.         }
  1289.         GsSortSprite(&enemy[nCount].sprite, &othWorld[nBuffer], nPri);
  1290.         enemy[nCount].sprite.r=128;
  1291.         enemy[nCount].sprite.g=128;
  1292.         enemy[nCount].sprite.b=128;
  1293.       }
  1294.     }
  1295.     else
  1296.       nCount=MAX_ENEMIES;
  1297.   }
  1298.  
  1299.   nAnim++;
  1300.   if(nAnim>=8)
  1301.     nAnim=0;
  1302. }
  1303.  
  1304.  
  1305. //--------------------------------------------------------------
  1306.  
  1307. void DrawPanel(int x, int y)
  1308. {
  1309.   GsSPRITE panel;
  1310.   //RECT rPanel={704,0,120,16};
  1311.  
  1312.   panel.attribute=1<<25;
  1313.   panel.w=120;
  1314.   panel.h=16;
  1315.   panel.u=0;
  1316.   panel.v=y-256;
  1317.   panel.r=128;
  1318.   panel.g=128;
  1319.   panel.b=128;
  1320.   panel.tpage=GetTPage(2,0,704,y);
  1321.  
  1322.   if((player->pon)&&(player->panel<16))
  1323.     player->panel++;
  1324.   else if((!player->pon)&&(player->panel>0))
  1325.     player->panel--;
  1326.  
  1327.   if(player->panel)
  1328.   {
  1329.     OutputNum(player->ammo, 4, 704+18,y+3);
  1330.     OutputNum(player->keys, 3, 704+48,y+3);
  1331.     OutputNum(player->lives, 2, 704+73,y+3);
  1332.     OutputNum(player->energy, 3, 704+93,y+3);
  1333.      
  1334.     panel.y=player->panel-16;
  1335.     panel.x=x;
  1336.     GsSortFastSprite(&panel, &othWorld[nBuffer], 0);
  1337.    
  1338.     //rPanel.y=y+(16-player->panel);
  1339.     //rPanel.h=player->panel;
  1340.  
  1341.     //MoveImage(&rPanel, x, nBuffer*256);
  1342.   }
  1343. }
  1344.  
  1345.  
  1346. //--------------------------------------------------------------
  1347.  
  1348. void DrawTime()
  1349. {
  1350.   int y;
  1351.   //RECT rArea={832,256,80,16};
  1352.   GsSPRITE panel;
  1353.  
  1354.   panel.attribute=1<<25;
  1355.   panel.w=80;
  1356.   panel.h=16;
  1357.   panel.u=0;
  1358.   panel.v=0;
  1359.   panel.r=128;
  1360.   panel.g=128;
  1361.   panel.b=128;
  1362.   panel.tpage=GetTPage(2,0,832,256);
  1363.  
  1364.   if(player1.panel>player2.panel)
  1365.     y=player1.panel;
  1366.   else
  1367.     y=player2.panel;
  1368.  
  1369.   if(y)
  1370.   {
  1371.     OutputNum(nMin, 2, 832+29,259);
  1372.     OutputNum(nSec, 2, 832+43,259);
  1373.    
  1374.     //rArea.y=272-y;
  1375.     //rArea.h=y;
  1376.     //MoveImage(&rArea, 120, nBuffer*256);
  1377.     panel.x=120;
  1378.     panel.y=y-16;
  1379.     GsSortFastSprite(&panel, &othWorld[nBuffer], 0);
  1380.   }  
  1381. }
  1382.  
  1383.  
  1384. //--------------------------------------------------------------
  1385.  
  1386. void StartFiring()
  1387. {
  1388.   if(!player->ammo)
  1389.   {
  1390.     SsUtKeyOn(nVab2, 4,0, 48, 0, 128,128);
  1391.     return;
  1392.   }
  1393.  
  1394.   switch(player->damage)
  1395.   {
  1396.     case PISTOL:
  1397.     SsUtKeyOn(nVab, 4,0, 48, 0, 128,128);
  1398.     player->rounds=2;
  1399.     break;
  1400.  
  1401.     case SHOTGUN:
  1402.     SsUtKeyOn(nVab2, 2,0, 48, 0, 128,128);
  1403.     player->rounds=4;
  1404.     break;
  1405.  
  1406.     case AUTOGUN:
  1407.     player->rounds=10;
  1408.     SsUtKeyOn(nVab, 2,0, 48, 0, 128,128);
  1409.     break;
  1410.  
  1411.     case MACHINEGUN:
  1412.     SsUtKeyOn(nVab, 7,0, 48, 0, 128,128);
  1413.     player->rounds=12;
  1414.     break;
  1415.  
  1416.     case AUTOPISTOL:
  1417.     player->rounds=14;
  1418.     SsUtKeyOn(nVab2, 7,0, 48, 0, 128,128);
  1419.     break;
  1420.    
  1421.     default:
  1422.     break;
  1423.   }
  1424. }
  1425.  
  1426.  
  1427. //--------------------------------------------------------------
  1428.  
  1429. #define BRES 16;
  1430.  
  1431. void FireGun()
  1432. {
  1433.   int x,y,ax,ay;
  1434.  
  1435.   player->flame.rotate=player->sprite.rotate;
  1436.  
  1437.   if(!player->ammo)
  1438.   {
  1439.     player->rounds=0;
  1440.     return;
  1441.   }
  1442.  
  1443.   if(player->rounds&1)
  1444.   {
  1445.     switch(player->flame.rotate)
  1446.     {
  1447.       case 0:
  1448.       player->flame.x=player->sprite.x;
  1449.       player->flame.y=player->sprite.y-13;
  1450.       ax=0;
  1451.       ay=-BRES;
  1452.       break;
  1453.  
  1454.       case 45*ONE:
  1455.       player->flame.x=player->sprite.x+10;
  1456.       player->flame.y=player->sprite.y-10;
  1457.       ax=BRES;
  1458.       ay=-BRES;
  1459.       break;
  1460.  
  1461.       case 90*ONE:
  1462.       player->flame.x=player->sprite.x+13;
  1463.       player->flame.y=player->sprite.y;
  1464.       ax=BRES;
  1465.       ay=0;
  1466.       break;
  1467.  
  1468.       case 135*ONE:
  1469.       player->flame.x=player->sprite.x+10;
  1470.       player->flame.y=player->sprite.y+10;
  1471.       ax=BRES;
  1472.       ay=BRES;
  1473.       break;
  1474.  
  1475.       case 180*ONE:
  1476.       player->flame.x=player->sprite.x;
  1477.       player->flame.y=player->sprite.y+13;
  1478.       ax=0;
  1479.       ay=BRES;
  1480.       break;
  1481.  
  1482.       case 225*ONE:
  1483.       player->flame.x=player->sprite.x-10;
  1484.       player->flame.y=player->sprite.y+10;
  1485.       ax=-BRES;
  1486.       ay=BRES;
  1487.       break;
  1488.  
  1489.       case 270*ONE:
  1490.       player->flame.x=player->sprite.x-13;
  1491.       player->flame.y=player->sprite.y;
  1492.       ax=-BRES;
  1493.       ay=0;
  1494.       break;
  1495.  
  1496.       case 315*ONE:
  1497.       player->flame.x=player->sprite.x-10;
  1498.       player->flame.y=player->sprite.y-10;
  1499.       ax=-BRES;
  1500.       ay=-BRES;
  1501.       break;
  1502.    
  1503.       default:
  1504.       break;
  1505.     }
  1506.     GsSortSprite(&player->flame, &othWorld[nBuffer], 0);
  1507.     player->ammo--;
  1508.     nFired++;
  1509.  
  1510.     x=player->x+ax;
  1511.     y=player->y+ay;
  1512.    
  1513.     while(!CheckBullet(x, y))
  1514.     {
  1515.       x+=ax;
  1516.       y+=ay;
  1517.     }
  1518.   }
  1519.   player->rounds--;
  1520. }
  1521.  
  1522. //--------------------------------------------------------------
  1523.  
  1524. #define FRES 8
  1525.  
  1526. int CheckBullet(int x, int y)
  1527. {
  1528.   int nCount;
  1529.  
  1530.   if(IsCoordAWall(x,y))
  1531.   {
  1532.     StartSplat(1,x,y);
  1533.     StartSplat(1,x,y);
  1534.     StartSplat(1,x,y);
  1535.     StartSplat(1,x,y);
  1536.     StartSplat(1,x,y);
  1537.     StartSplat(1,x,y);
  1538.     StartSplat(1,x,y);
  1539.     StartSplat(1,x,y);
  1540.     StartSplat(1,x,y);
  1541.     StartSplat(1,x,y);
  1542.     StartSplat(1,x,y);
  1543.     StartSplat(1,x,y);
  1544.     StartSplat(1,x,y);
  1545.     StartSplat(1,x,y);
  1546.     StartSplat(1,x,y);
  1547.     StartSplat(1,x,y);
  1548.     return 1;
  1549.   }
  1550.  
  1551.   if((x<nMapx)||(x>nMapx+320)||(y<nMapy)||(y>nMapy+240))
  1552.     return 1;
  1553.    
  1554.   for(nCount=0; nCount<MAX_ENEMIES; nCount++)
  1555.   {
  1556.     if(enemy[nCount].energy==-9)
  1557.       nCount=MAX_ENEMIES;
  1558.    
  1559.     if(enemy[nCount].energy>-1)
  1560.     {
  1561.       if(((enemy[nCount].sprite.x>-13)&&(enemy[nCount].sprite.x<333))&&
  1562.         ((enemy[nCount].sprite.y>-13)&&(enemy[nCount].sprite.y<253)))
  1563.       {
  1564.         if(Collision(enemy[nCount].x, enemy[nCount].y, x,y, 16))
  1565.         {
  1566.           nTarget++;
  1567.           enemy[nCount].energy-=player->damage;
  1568.           if(enemy[nCount].energy<-1)
  1569.             enemy[nCount].energy=-1;
  1570.           StartSplat(0,x,y);
  1571.           StartSplat(0,x,y);
  1572.           StartSplat(0,x,y);
  1573.           StartSplat(0,x,y);
  1574.           StartSplat(0,x,y);
  1575.           StartSplat(0,x,y);
  1576.           StartSplat(0,x,y);
  1577.           StartSplat(0,x,y);
  1578.           StartSplat(0,x,y);
  1579.           StartSplat(0,x,y);
  1580.           StartSplat(0,x,y);
  1581.           StartSplat(0,x,y);
  1582.           StartSplat(0,x,y);
  1583.           StartSplat(0,x,y);
  1584.           StartSplat(0,x,y);
  1585.           StartSplat(0,x,y);
  1586.          
  1587.           if(enemy[nCount].energy==-1)
  1588.           {
  1589.             enemy[nCount].sprite.rotate=(rand()/10)*ONE;
  1590.             SsUtKeyOn(nVab2, 5,0, 48, 0, 128,128);
  1591.             nKilled++;
  1592.             player->score+=25;
  1593.            
  1594.             switch(player->sprite.rotate)
  1595.             {
  1596.               case 0:
  1597.               enemy[nCount].dy=-FRES;
  1598.               break;
  1599.  
  1600.               case 45*ONE:
  1601.               enemy[nCount].dx=FRES;
  1602.               enemy[nCount].dy=-FRES;
  1603.               break;
  1604.  
  1605.               case 90*ONE:
  1606.               enemy[nCount].dx=FRES;
  1607.               break;
  1608.  
  1609.               case 135*ONE:
  1610.               enemy[nCount].dx=+FRES;
  1611.               enemy[nCount].dy=+FRES;
  1612.               break;
  1613.  
  1614.               case 180*ONE:
  1615.               enemy[nCount].dy=FRES;
  1616.               break;
  1617.  
  1618.               case 225*ONE:
  1619.               enemy[nCount].dx=-FRES;
  1620.               enemy[nCount].dy=FRES;
  1621.               break;
  1622.  
  1623.               case 270*ONE:
  1624.               enemy[nCount].dx=-FRES;
  1625.               break;
  1626.  
  1627.               case 315*ONE:
  1628.               enemy[nCount].dx=-FRES;
  1629.               enemy[nCount].dy=-FRES;
  1630.               break;
  1631.    
  1632.               default:
  1633.               break;
  1634.             }
  1635.           }
  1636.           enemy[nCount].sprite.r=255;          
  1637.           enemy[nCount].sprite.g=255;          
  1638.           enemy[nCount].sprite.g=255;          
  1639.           return 1;
  1640.         }
  1641.       }
  1642.     }
  1643.   }
  1644.  
  1645.   return 0;
  1646. }
  1647.  
  1648.  
  1649. //--------------------------------------------------------------
  1650.  
  1651. int IsCoordAWall(int x, int y)
  1652. {
  1653.   int nAddr;
  1654.  
  1655.   nAddr=(x>>4)+((y<<2)&0xffc0);
  1656.  
  1657.   if(((nMap[nAddr]>=194)&&(nMap[nAddr]<=389))||((nMap[nAddr]>=511)&&(nMap[nAddr]<=518)))
  1658.     return 1;
  1659.  
  1660.   return 0;
  1661. }
  1662.  
  1663.  
  1664. //--------------------------------------------------------------
  1665.  
  1666. int IsObjectOverWall(int x, int y, int r, int p)
  1667. {
  1668.   int nAddr;
  1669.   static int nRad;
  1670.  
  1671.   nAddr=((x-r)>>4)+(((y-r)<<2)&0xffc0);
  1672.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1673.     return 1;
  1674.  
  1675.   nAddr=((x+r)>>4)+(((y-r)<<2)&0xffc0);
  1676.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1677.     return 1;
  1678.  
  1679.   nAddr=((x+r)>>4)+(((y+r)<<2)&0xffc0);
  1680.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1681.     return 1;
  1682.    
  1683.   nAddr=((x-r)>>4)+(((y+r)<<2)&0xffc0);
  1684.   if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1685.     return 1;
  1686.  
  1687.   nAddr=((x-r)>>4)+(((y)<<2)&0xffc0);
  1688.   if((nMap[nAddr]>=511)&&(nMap[nAddr]<=518))
  1689.   {
  1690.     if(p&!player->d)
  1691.     {
  1692.       if(OpenDoor(nAddr))
  1693.         return 1;
  1694.     }
  1695.     else
  1696.       return 1;
  1697.   }
  1698.   else if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1699.     return 1;
  1700.  
  1701.   nAddr=((x+r)>>4)+(((y)<<2)&0xffc0);
  1702.   if((nMap[nAddr]>=511)&&(nMap[nAddr]<=518))
  1703.   {
  1704.     if(p&!player->d)
  1705.     {
  1706.       if(OpenDoor(nAddr))
  1707.         return 1;
  1708.     }
  1709.     else
  1710.       return 1;
  1711.   }
  1712.   else if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1713.     return 1;
  1714.  
  1715.   nAddr=((x)>>4)+(((y-r)<<2)&0xffc0);
  1716.   if((nMap[nAddr]>=511)&&(nMap[nAddr]<=518))
  1717.   {
  1718.     if(p&!player->d)
  1719.     {
  1720.       if(OpenDoor(nAddr))
  1721.         return 1;
  1722.     }
  1723.     else
  1724.       return 1;
  1725.   }
  1726.   else if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1727.     return 1;
  1728.  
  1729.   nAddr=((x)>>4)+(((y+r)<<2)&0xffc0);
  1730.   if((nMap[nAddr]>=511)&&(nMap[nAddr]<=518))
  1731.   {
  1732.     if(p&!player->d)
  1733.     {
  1734.       if(OpenDoor(nAddr))
  1735.         return 1;
  1736.     }
  1737.     else
  1738.       return 1;
  1739.   }
  1740.   else if((nMap[nAddr]>=197)&&(nMap[nAddr]<=390))
  1741.     return 1;
  1742.  
  1743.   if(p)
  1744.   {
  1745.     nAddr=(x>>4)+((y<<2)&0xffc0);
  1746.     if((nMap[nAddr]>=174)&&(nMap[nAddr]<=189))
  1747.     {
  1748.       nRad++;
  1749.       if((nRad>=32-nLevel)&&(!player->shield))
  1750.       {
  1751.         player->sprite.r=255;
  1752.         player->sprite.g=255;
  1753.         player->sprite.b=255;
  1754.         player->energy--;
  1755.         nRad=0;
  1756.       }
  1757.     }
  1758.   }
  1759.  
  1760.   return 0;  
  1761. }
  1762.  
  1763.  
  1764. //--------------------------------------------------------------
  1765.  
  1766. int IsObjectOverEnemy(int x, int y, int r)
  1767. {
  1768.   int nCount;
  1769.  
  1770.   for(nCount=0; nCount<MAX_ENEMIES; nCount++)
  1771.   {
  1772.     if(enemy[nCount].energy==-9)
  1773.       return 0;
  1774.     else if(enemy[nCount].energy>=0)
  1775.     {
  1776.       if(Collision(x,y, enemy[nCount].x, enemy[nCount].y, 22))
  1777.       //if(Difference(x, enemy[nCount].x)<22)&&(Difference(y, enemy[nCount].y)<22))
  1778.       {
  1779.         if((enemy[nCount].x!=x)||(enemy[nCount].y!=y))
  1780.           return 1;
  1781.       }
  1782.     }
  1783.   }
  1784. }
  1785.  
  1786.  
  1787. //--------------------------------------------------------------
  1788.  
  1789. void CheckPickups(int x, int y)
  1790. {
  1791.   Player * otherplayer;
  1792.   int nAddr;
  1793.  
  1794.   if(player==&player1)
  1795.     otherplayer=&player2;
  1796.   else
  1797.     otherplayer=&player1;
  1798.  
  1799.   nAddr=(x>>4)+((y<<2)&0xffc0);
  1800.  
  1801.   if(((nMap[nAddr]>=37)&&(nMap[nAddr]<=53))||((nMap[nAddr]>=23)&&(nMap[nAddr]<32)))
  1802.     SsUtKeyOn(nVab3, 1,0, 48, 0, 64,64);
  1803.  
  1804.   switch(nMap[nAddr])
  1805.   {
  1806.     case 23:
  1807.     player->energy+=5;
  1808.     nMap[nAddr]=1;
  1809.     break;
  1810.    
  1811.     case 24:
  1812.     player->energy+=5;
  1813.     nMap[nAddr]=4;
  1814.     break;
  1815.  
  1816.     case 25:
  1817.     player->energy+=5;
  1818.     nMap[nAddr]=141;
  1819.     break;
  1820.    
  1821.     case 26:
  1822.     player->energy+=5;
  1823.     nMap[nAddr]=144;
  1824.     break;
  1825.    
  1826.     case 27:
  1827.     player->energy+=15;
  1828.     nMap[nAddr]=1;
  1829.     break;
  1830.    
  1831.     case 28:
  1832.     player->energy+=15;
  1833.     nMap[nAddr]=4;
  1834.     break;
  1835.  
  1836.     case 29:
  1837.     player->energy+=15;
  1838.     nMap[nAddr]=141;
  1839.     break;
  1840.    
  1841.     case 30:
  1842.     player->energy+=15;
  1843.     nMap[nAddr]=144;
  1844.     break;
  1845.  
  1846.     case 31:
  1847.     player->shield=250;
  1848.     nMap[nAddr]=1;
  1849.     break;
  1850.    
  1851.     case 32:
  1852.     player->ammo+=100;
  1853.     nMap[nAddr]=1;
  1854.     break;
  1855.    
  1856.     case 33:
  1857.     if(player->damage!=AUTOGUN)
  1858.     {
  1859.       player->flame.r=168;
  1860.       player->flame.g=168;
  1861.       player->flame.b=120;
  1862.       player->flame.scalex=ONE;
  1863.       player->flame.scaley=ONE+(ONE/4);
  1864.       player->damage=AUTOGUN;
  1865.       if((otherplayer->damage==AUTOGUN)||(otherplayer->lives<0))
  1866.         nMap[nAddr]=1;
  1867.       SsUtKeyOn(nVab, 5,0, 48, 0, 128,128);
  1868.     }
  1869.     break;
  1870.    
  1871.     case 34:
  1872.     if(player->damage!=AUTOPISTOL)
  1873.     {
  1874.       player->flame.r=188;
  1875.       player->flame.g=158;
  1876.       player->flame.b=120;
  1877.       player->flame.scalex=ONE;
  1878.       player->flame.scaley=ONE*2;
  1879.       player->damage=AUTOPISTOL;
  1880.       if((otherplayer->damage==AUTOPISTOL)||(otherplayer->lives<0))
  1881.         nMap[nAddr]=1;
  1882.       SsUtKeyOn(nVab, 5,0, 48, 0, 128,128);
  1883.     }
  1884.     break;
  1885.    
  1886.     case 35:
  1887.     if(player->damage!=MACHINEGUN)
  1888.     {
  1889.       player->flame.r=198;
  1890.       player->flame.g=158;
  1891.       player->flame.b=128;
  1892.       player->flame.scalex=ONE;
  1893.       player->flame.scaley=ONE+(ONE/2);
  1894.       player->damage=MACHINEGUN;
  1895.       if((otherplayer->damage==MACHINEGUN)||(otherplayer->lives<0))
  1896.         nMap[nAddr]=1;
  1897.       SsUtKeyOn(nVab, 5,0, 48, 0, 128,128);
  1898.     }
  1899.     break;
  1900.    
  1901.     case 36:
  1902.     if(player->damage!=SHOTGUN)
  1903.     {
  1904.       player->flame.r=148;
  1905.       player->flame.g=148;
  1906.       player->flame.b=100;
  1907.       player->flame.scalex=ONE+(ONE/2);
  1908.       player->flame.scaley=ONE;
  1909.       player->damage=SHOTGUN;
  1910.       if((otherplayer->damage==SHOTGUN)||(otherplayer->lives<0))
  1911.         nMap[nAddr]=1;
  1912.       SsUtKeyOn(nVab, 5,0, 48, 0, 128,128);
  1913.     }
  1914.     break;
  1915.    
  1916.     case 37:
  1917.     player->keys+=3;
  1918.     nMap[nAddr]=1;
  1919.     break;
  1920.    
  1921.     case 38:
  1922.     player->keys+=3;
  1923.     nMap[nAddr]=4;
  1924.     break;
  1925.    
  1926.     case 39:
  1927.     player->keys+=3;
  1928.     nMap[nAddr]=141;
  1929.     break;
  1930.  
  1931.     case 40:
  1932.     player->keys+=3;
  1933.     nMap[nAddr]=144;
  1934.     break;
  1935.    
  1936.     case 41:
  1937.     player->keys++;
  1938.     nMap[nAddr]=1;
  1939.     break;
  1940.    
  1941.     case 42:
  1942.     player->keys++;
  1943.     nMap[nAddr]=4;
  1944.     break;
  1945.    
  1946.     case 43:
  1947.     player->keys++;
  1948.     nMap[nAddr]=141;
  1949.     break;
  1950.    
  1951.     case 44:
  1952.     player->keys++;
  1953.     nMap[nAddr]=144;
  1954.     break;
  1955.    
  1956.     case 45:
  1957.     player->ammo+=15;
  1958.     nMap[nAddr]=1;
  1959.     break;
  1960.    
  1961.     case 46:
  1962.     player->ammo+=15;
  1963.     nMap[nAddr]=4;
  1964.     break;
  1965.    
  1966.     case 47:
  1967.     player->ammo+=15;
  1968.     nMap[nAddr]=141;
  1969.     break;
  1970.    
  1971.     case 48:
  1972.     player->ammo+=15;
  1973.     nMap[nAddr]=144;
  1974.     break;
  1975.    
  1976.     case 49:
  1977.     player->energy=100;
  1978.     nMap[nAddr]=1;
  1979.     break;
  1980.    
  1981.     case 50:
  1982.     player->energy=100;
  1983.     nMap[nAddr]=4;
  1984.     break;
  1985.    
  1986.     case 51:
  1987.     player->energy=100;
  1988.     nMap[nAddr]=141;
  1989.     break;
  1990.    
  1991.     case 52:
  1992.     player->energy=100;
  1993.     nMap[nAddr]=144;
  1994.     break;
  1995.    
  1996.     case 53:
  1997.     if(player->energy==100)
  1998.       player->lives++;
  1999.     else
  2000.       player->energy=100;
  2001.     nMap[nAddr]=1;
  2002.     break;
  2003.    
  2004.     case 439:
  2005.     case 447:
  2006.     case 455:
  2007.     case 463:
  2008.     ActivateGlobe(nAddr);
  2009.     break;
  2010.  
  2011.     case 471:
  2012.     case 479:
  2013.     case 487:
  2014.     case 495:
  2015.     if(nGlobes==4)
  2016.       bComplete=1;
  2017.     break;
  2018.    
  2019.     default:
  2020.     break;
  2021.   }
  2022.   if(player->energy>100)
  2023.     player->energy=100;
  2024. }
  2025.  
  2026.  
  2027. //--------------------------------------------------------------
  2028.  
  2029. int OpenDoor(int nAddr)
  2030. {
  2031.   static n=0;
  2032.  
  2033.   if(!player->keys)
  2034.     return 1;
  2035.  
  2036.   nDoor[0]=nAddr;
  2037.  
  2038.   if(!player->d)
  2039.   {
  2040.     player->d=1;
  2041.     player->keys--;
  2042.     SsUtKeyOn(nVab, 6,0, 48, 0, 128,128);
  2043.   }
  2044.  
  2045.   switch(nMap[nAddr])
  2046.   {
  2047.     case 511:
  2048.     nDoor[1]=nAddr+64;
  2049.     break;
  2050.  
  2051.     case 512:
  2052.     nDoor[1]=nAddr-64;
  2053.     break;
  2054.  
  2055.     case 513:
  2056.     nDoor[1]=nAddr+1;
  2057.     break;
  2058.  
  2059.     case 514:
  2060.     nDoor[1]=nAddr-1;
  2061.     break;
  2062.  
  2063.     case 515:
  2064.     nDoor[1]=nAddr+64;
  2065.     break;
  2066.  
  2067.     case 516:
  2068.     nDoor[1]=nAddr-64;
  2069.     break;
  2070.  
  2071.     case 517:
  2072.     nDoor[1]=nAddr+1;
  2073.     break;
  2074.  
  2075.     case 518:
  2076.     nDoor[1]=nAddr-1;
  2077.     break;
  2078.    
  2079.     default:
  2080.     break;
  2081.   }
  2082.   return 0;
  2083. }
  2084.  
  2085.  
  2086. //--------------------------------------------------------------
  2087.  
  2088. int CheckDoors(int nAddr)
  2089. {
  2090.   if(!nAddr)
  2091.     return 0;
  2092.   if((nMap[nAddr]>=511)&&(nMap[nAddr]<=518))
  2093.     nMap[nAddr]=((nMap[nAddr]-511)<<2)+519;
  2094.   else
  2095.   {  
  2096.     nMap[nAddr]++;
  2097.     if(nMap[nAddr]&2)
  2098.       return 1;
  2099.   }
  2100.   return 0;
  2101. }
  2102.  
  2103.  
  2104. //--------------------------------------------------------------
  2105.  
  2106. void ActivateGlobe(int nAddr)
  2107. {
  2108.   RECT rGlobe={912,256,10,10};
  2109.  
  2110.   switch(nMap[nAddr])
  2111.   {
  2112.     case 447:
  2113.     nAddr-=64;
  2114.     break;
  2115.    
  2116.     case 455:
  2117.     nAddr-=1;
  2118.     break;
  2119.    
  2120.     case 463:
  2121.     nAddr-=65;
  2122.     break;
  2123.    
  2124.     default:
  2125.     break;
  2126.   }
  2127.   nMap[nAddr]=2;
  2128.   nMap[nAddr+1]=3;
  2129.   nMap[nAddr+64]=9;
  2130.   nMap[nAddr+65]=10;
  2131.  
  2132.   nGlobes++;
  2133.   SsUtKeyOn(nVab2, 3,0, 48, 0, 128,128);
  2134.  
  2135.   if(nGlobes==1)
  2136.     MoveImage(&rGlobe,832+17, 256);
  2137.   if(nGlobes==2)
  2138.     MoveImage(&rGlobe,832+54, 256);
  2139.   if(nGlobes==3)
  2140.     MoveImage(&rGlobe,832+7, 256);
  2141.   if(nGlobes==4)
  2142.     MoveImage(&rGlobe,832+64, 256);
  2143.  
  2144. }
  2145.  
  2146.  
  2147. //--------------------------------------------------------------
  2148.  
  2149. void LevelClear()
  2150. {
  2151.   int nTimer=0;
  2152.   int nX;
  2153.   int nCount;
  2154.   int nAcc, nEff;
  2155.   RECT rClear={0,0,320,512};
  2156.   GsSPRITE title;
  2157.   char szText[8][64];
  2158.  
  2159.   title.attribute=1<<25;
  2160.   title.r=128;
  2161.   title.g=128;
  2162.   title.b=128;
  2163.   title.w=256;
  2164.   title.h=26;
  2165.   title.mx=128;
  2166.   title.my=0;
  2167.   title.u=0;
  2168.   title.v=144;
  2169.   title.tpage=GetTPage(2, 0, 704, 400);
  2170.   title.scalex=ONE;
  2171.   title.scaley=ONE;
  2172.   title.rotate=0;
  2173.  
  2174.   ClearImage(&rClear, 0, 0, 0);
  2175.   rClear.h=256;
  2176.  
  2177.   LoadTIM(CLEAR_TIM);
  2178.   SsUtKeyOn(nVab2, 1,0, 44, 0, 128,128);
  2179.  
  2180.   nEff=(nKilled*100)/nEnemies;
  2181.   if(nFired)
  2182.     nAcc=(nTarget*100)/nFired;
  2183.   else
  2184.     nAcc=0;
  2185.  
  2186.   sprintf(szText[0], "Bullets fired: %d", nFired);
  2187.   sprintf(szText[1], "Bullets on target: %d", nTarget);
  2188.   sprintf(szText[2], "Accuracy: %d%%", nAcc);
  2189.   if(nAcc>=80)
  2190.   {
  2191.     strcat(szText[2], " - EXTRA LIFE!");
  2192.     if(player1.lives>-1)
  2193.       player1.lives++;
  2194.     if(player2.lives>-1)
  2195.       player2.lives++;
  2196.   }
  2197.    
  2198.   sprintf(szText[4], "Enemies on level: %d", nEnemies);
  2199.   sprintf(szText[5], "Enemies eliminated: %d", nKilled);
  2200.   sprintf(szText[6], "Efficiency: %d%%", nEff);
  2201.   if(nEff>=90)
  2202.   {
  2203.     strcat(szText[6], " - BONUS AMMO!");
  2204.     player1.ammo+=500;
  2205.     player2.ammo+=500;
  2206.   }
  2207.  
  2208.   strcpy(szText[3], "");
  2209.   strcpy(szText[7], "");
  2210.  
  2211.   do
  2212.   {
  2213.     PADstatus=PadRead(1);
  2214.     nBuffer=GsGetActiveBuff();
  2215.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2216.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2217.  
  2218.     rClear.y=nBuffer*256;
  2219.     ClearImage(&rClear, 0, 0, 0);
  2220.    
  2221.     title.x=160;
  2222.     title.y=240-nTimer;
  2223.     if(title.y<0)
  2224.       title.y=0;
  2225.    
  2226.     GsSortSprite(&title, &othWorld[nBuffer], 0);
  2227.  
  2228.     for(nCount=0; nCount<8; nCount++)
  2229.     {
  2230.       nX=320-nTimer+(nCount*64);
  2231.       if(nX<20)
  2232.         nX=20;
  2233.       OutputString(szText[nCount], -1, nX, (45+(nCount*23)));
  2234.     }
  2235.    
  2236.     if(nTimer<1500)
  2237.       nTimer+=16;
  2238.    
  2239.     GsDrawOt(&othWorld[nBuffer]);
  2240.     DrawSync(0);
  2241.     VSync(0);
  2242.     GsSwapDispBuff();
  2243.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2244.  
  2245.   } while((!(PADstatus & PADRdown))||(nTimer<320));
  2246. }
  2247.  
  2248.  
  2249. //--------------------------------------------------------------
  2250.  
  2251. void GameOver()
  2252. {
  2253.   int nTimer=0;
  2254.   RECT rClear={0,0,320,512};
  2255.   RECT rArea={704, 130, 72, 0};
  2256.   char szDead[13]="YOU ARE DEAD";
  2257.   char szOver[10]="GAME OVER";
  2258.   char szPress[8]="PRESS X";
  2259.  
  2260.   ClearImage(&rClear, 0, 0, 0);
  2261.   rClear.h=256;
  2262.  
  2263.   LoadTIM(DEAD_TIM);
  2264.  
  2265.   do
  2266.   {
  2267.     PADstatus=PadRead(1);
  2268.     nBuffer=GsGetActiveBuff();
  2269.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2270.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2271.  
  2272.     rClear.y=nBuffer*256;
  2273.     ClearImage(&rClear, 0, 0, 0);
  2274.    
  2275.     rArea.h=nTimer*2;
  2276.     if(rArea.h>120)
  2277.       rArea.h=120;
  2278.    
  2279.     MoveImage(&rArea, 124,20+(nBuffer*256));
  2280.    
  2281.     if(nTimer>90)
  2282.       OutputString(szDead, nTimer-90, GetCentre(szDead), 150);
  2283.     if(nTimer>150)
  2284.       OutputString(szOver, nTimer-150, GetCentre(szOver), 180);
  2285.     if(nTimer>500)
  2286.       OutputString(szPress, nTimer-150, GetCentre(szPress), 210);
  2287.    
  2288.     if(nTimer<1500)
  2289.       nTimer++;
  2290.    
  2291.     GsDrawOt(&othWorld[nBuffer]);
  2292.     DrawSync(0);
  2293.     VSync(0);
  2294.     GsSwapDispBuff();
  2295.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2296.  
  2297.   } while((!(PADstatus & PADRdown))||(nTimer<10));
  2298. }
  2299.  
  2300.  
  2301. //--------------------------------------------------------------
  2302.  
  2303. void Complete()
  2304. {
  2305.   int nScroll=400;
  2306.   int nTimer=0;
  2307.   RECT rClear={0,0,320,512};
  2308.   RECT rArea={320,0,122,114};
  2309.   char sz1[28]="CONGRATULATIONS!";
  2310.   char sz2[500]="You reach the final deck lift in the nick of time.   The doomed space station explodes taking the Psychon virus with it.  You escape the inferno and return to Earth having ";
  2311.   char sz4[185]="saved it from a brutal death.   You will be remembered.      For more information on the Net Yaroze point your browser at: www.netyaroze-europe.com.   Thank you for playing!";
  2312.   char sz3[8]="PRESS X";
  2313.  
  2314.   LoadTIM(EARTH_TIM);
  2315.  
  2316.   strcat(sz2, sz4);
  2317.   ClearImage(&rClear, 0, 0, 0);
  2318.   rClear.h=256;
  2319.  
  2320.   do
  2321.   {
  2322.     PADstatus=PadRead(1);
  2323.     nBuffer=GsGetActiveBuff();
  2324.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2325.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2326.  
  2327.     rClear.y=nBuffer*256;
  2328.     ClearImage(&rClear, 0, 0, 0);
  2329.    
  2330.     rArea.h=nTimer*2;
  2331.     if(rArea.h>114)
  2332.       rArea.h=114;
  2333.     MoveImage(&rArea, 96,(nBuffer*256)+80);
  2334.    
  2335.     OutputString(sz1, nTimer, GetCentre(sz1), 10);
  2336.     OutputString(sz2, -1, nScroll, 40);
  2337.     if(nTimer>3000)
  2338.       OutputString(sz3, -1, GetCentre(sz3), 220);
  2339.    
  2340.     GsDrawOt(&othWorld[nBuffer]);
  2341.     DrawSync(0);
  2342.     VSync(0);
  2343.     GsSwapDispBuff();
  2344.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2345.    
  2346.     nTimer++;
  2347.     if(nTimer>4000)
  2348.       nTimer=4000;
  2349.    
  2350.     nScroll--;
  2351.     if(nScroll<-3800)
  2352.       nScroll=400;
  2353.    
  2354.   } while((!(PADstatus & PADRdown))||(nTimer<3000));
  2355.   SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  2356.   SmearClear(127,128,128,1,0,-1);
  2357. }
  2358.  
  2359.  
  2360. //--------------------------------------------------------------
  2361.  
  2362. void SmearClear(int r, int g, int b, int s, int ax, int ay)
  2363. {
  2364.   int nCount;
  2365.   char lLine[640];
  2366.   RECT rLine={0,0,320,1};
  2367.   RECT rImage={0,0,320,240};
  2368.   GsSPRITE screen;
  2369.   GsSPRITE screen2;
  2370.  
  2371.   for(rLine.y=(1-nBuffer)*256; rLine.y<((1-nBuffer)*256)+240; rLine.y++)
  2372.   {
  2373.     StoreImage(&rLine, (u_long *)&lLine[0]);
  2374.     for(nCount=0; nCount<640; nCount+=2)
  2375.       lLine[nCount+1]|=0x80;
  2376.     LoadImage(&rLine, (u_long *)&lLine[0]);  
  2377.   }
  2378.  
  2379.   screen.attribute=(1<<25)+(1<<30);
  2380.   screen.r=r;
  2381.   screen.g=g;
  2382.   screen.b=b;
  2383.   screen.mx=160;
  2384.   screen.my=120;
  2385.   screen.x=160;
  2386.   screen.y=120;
  2387.   screen.w=160;
  2388.   screen.h=240;
  2389.   screen.u=0;
  2390.   screen.v=0;
  2391.   screen.rotate=ONE*(2/s);
  2392.   screen.scalex=ONE+(512/s);
  2393.   screen.scaley=ONE+(512/s);
  2394.  
  2395.   screen2.attribute=(1<<25)+(1<<30);
  2396.   screen2.r=r;
  2397.   screen2.g=g;
  2398.   screen2.b=b;
  2399.   screen2.mx=0;
  2400.   screen2.my=120;
  2401.   screen2.x=160;
  2402.   screen2.y=120;
  2403.   screen2.w=160;
  2404.   screen2.h=240;
  2405.   screen2.rotate=ONE*(2/s);
  2406.   screen2.scalex=ONE+(512/s);
  2407.   screen2.scaley=ONE+(512/s);
  2408.   screen2.u=32;
  2409.   screen2.v=0;
  2410.  
  2411.   rImage.y=(1-nBuffer)*256;
  2412.   MoveImage(&rImage, 0, nBuffer*256);
  2413.  
  2414.   for(nCount=92*s; nCount>0; nCount--)
  2415.   {
  2416.     if(nCount==64*s)
  2417.     {
  2418.       screen.r=127;
  2419.       screen.g=127;
  2420.       screen.b=127;
  2421.       screen2.r=127;
  2422.       screen2.g=127;
  2423.       screen2.b=127;
  2424.     }
  2425.    
  2426.     if(nCount>64)
  2427.     {
  2428.       screen.x+=ax;
  2429.       screen.y+=ay;
  2430.       screen2.x+=ax;
  2431.       screen2.y+=ay;
  2432.     }
  2433.     else
  2434.     {
  2435.       screen.x=160;
  2436.       screen.y=120;
  2437.       screen2.x=160;
  2438.       screen2.y=120;
  2439.     }
  2440.    
  2441.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2442.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2443.  
  2444.     screen.tpage=GetTPage(2,0, 0, (1-nBuffer)*256);    
  2445.     GsSortSprite(&screen, &othWorld[nBuffer], 0);
  2446.     screen2.tpage=screen.tpage+2;    
  2447.     GsSortSprite(&screen2, &othWorld[nBuffer], 1);
  2448.    
  2449.     GsDrawOt(&othWorld[nBuffer]);
  2450.     DrawSync(0);
  2451.     VSync(0);
  2452.  
  2453.     GsSwapDispBuff();
  2454.     nBuffer=GsGetActiveBuff();
  2455.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2456.   }
  2457. }
  2458.  
  2459.  
  2460. //--------------------------------------------------------------
  2461.  
  2462. void OutputString(char * string, int len, int x, int y)
  2463. {
  2464.   RECT rChar;
  2465.  
  2466.   while(len&&*string)
  2467.   {
  2468.     if(*string==32)
  2469.       rChar.w=SPACE;
  2470.     else
  2471.     {
  2472.       rChar.x=nFont[*string-33]+336;
  2473.       rChar.w=(nFont[*string-32]+336)-rChar.x;
  2474.      
  2475.       if(rChar.w<0)
  2476.         rChar.w=398-nFont[*string-33];
  2477.      
  2478.       if((x<0)&&(rChar.w>-x))
  2479.       {
  2480.         rChar.x-=x;
  2481.         rChar.w+=x;
  2482.         x=0;
  2483.       }
  2484.  
  2485.       if((x+rChar.w>320)&&(x<320))
  2486.         rChar.w=320-x;
  2487.  
  2488.       rChar.h=19;
  2489.      
  2490.       if(*string>'N')
  2491.         rChar.y=467;
  2492.       else
  2493.         rChar.y=448;
  2494.       if((x<320)&&(y<256)&&(x+rChar.w>0))
  2495.         MoveImage(&rChar, x,y+(nBuffer*256));
  2496.     }
  2497.  
  2498.     x+=rChar.w;
  2499.     string++;
  2500.     len--;
  2501.   }
  2502. }
  2503.  
  2504.  
  2505. //--------------------------------------------------------------
  2506.  
  2507. int GetCentre(char * string)
  2508. {
  2509.   int nLen=0;
  2510.   int nAdd;
  2511.  
  2512.   while(*string)
  2513.   {
  2514.     if(*string==32)
  2515.       nAdd=SPACE;
  2516.     else
  2517.       nAdd=(nFont[*string-32])-(nFont[*string-33]);
  2518.    
  2519.     if(nAdd<0)
  2520.       nAdd=398-nFont[*string-33];
  2521.  
  2522.     nLen+=nAdd;
  2523.    
  2524.     string++;
  2525.   }
  2526.  
  2527.   nLen=160-(nLen>>1);
  2528.  
  2529.   return nLen;
  2530. }
  2531.  
  2532.  
  2533. //--------------------------------------------------------------
  2534.  
  2535. void OutputNum(int num, int len, int x, int y)
  2536. {
  2537.   RECT rArea={704, 389, 5, 6};
  2538.   int nCol;
  2539.  
  2540.   if(num<0)
  2541.     num=0;
  2542.  
  2543.   while(len)
  2544.   {
  2545.     if(num)
  2546.       nCol=num%10;
  2547.     else
  2548.       nCol=0;
  2549.     num-=nCol;
  2550.     num/=10;
  2551.    
  2552.     rArea.x=(nCol*5)+704;
  2553.     MoveImage(&rArea, x+(5*(len-1)), y);
  2554.     len--;
  2555.   }
  2556. }
  2557.  
  2558.  
  2559. //--------------------------------------------------------------
  2560.  
  2561. int Difference(int a, int b)
  2562. {
  2563.   if(a>b)
  2564.     return a-b;
  2565.   else
  2566.     return b-a;
  2567. }
  2568.  
  2569. //--------------------------------------------------------------
  2570.  
  2571.  
  2572. void OtherChecks()
  2573. {
  2574.   int nRand;
  2575.  
  2576.   if((player1.lives<0)&&(player2.lives<0))
  2577.     bPlaying=0;
  2578.   player1.d=0;
  2579.   player2.d=0;
  2580.  
  2581.   nRand=rand()/48;
  2582.  
  2583.   if(nRand==1)
  2584.     SsUtKeyOn(nVab, 0,0, 36, 0, 32,128);
  2585.   if(nRand==2)
  2586.     SsUtKeyOn(nVab, 0,0, 36, 0, 128,32);
  2587. }
  2588.  
  2589. //--------------------------------------------------------------
  2590.  
  2591. void Intro()
  2592. {
  2593.  
  2594.   int nCount=0;
  2595.   RECT rClear={0,0,320,240};
  2596.  
  2597.   ClearImage(&rClear, 0, 0, 0);
  2598.   rClear.h=256;
  2599.  
  2600.   while(nCount<260)
  2601.   {
  2602.     PADstatus=PadRead(1);
  2603.     nBuffer=GsGetActiveBuff();
  2604.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2605.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2606.  
  2607.     rClear.y=nBuffer*256;
  2608.     LoadImage(&rClear, (u_long *)INTRO_TIM+5);
  2609.    
  2610.     GsDrawOt(&othWorld[nBuffer]);
  2611.     DrawSync(0);
  2612.     VSync(0);
  2613.     GsSwapDispBuff();
  2614.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2615.     nCount++;
  2616.   }
  2617. }
  2618.  
  2619.  
  2620. //--------------------------------------------------------------
  2621.  
  2622. void EnterName()
  2623. {
  2624.   int nPos=0;
  2625.   int nHold=0;
  2626.   int nHoldX=0;
  2627.   int nHoldT=0;
  2628.   int nRank;
  2629.   int nCount;
  2630.   int nLetter=0;
  2631.   int x[30]={4,14,25,35,45,53,61,72,80,86,94,103,113,125,134,144,154,165,175,184,194,204,216,229,238,246,255,260};
  2632.   char szPlayer[9]="PLAYER 1";
  2633.   char sz1[32]="You have achieved a great score";
  2634.   char sz2[32]="Please enter your initials";
  2635.   char szLetters[40]="ABCDEFGHIJKLMNOPQRSTUVWXYZ .";
  2636.   char szRank[24]="";
  2637.   char szName[5]="...";
  2638.   RECT rClear={0,0,320,240};
  2639.   GsSPRITE cursor;
  2640.  
  2641.   LoadTIM(CURSOR_TIM);
  2642.  
  2643.   cursor.attribute=1<<25;
  2644.   cursor.w=28;
  2645.   cursor.h=32;
  2646.   cursor.u=26;
  2647.   cursor.v=0;
  2648.   cursor.r=128;
  2649.   cursor.g=128;
  2650.   cursor.b=128;
  2651.   cursor.tpage=GetTPage(2,0,922,256);
  2652.  
  2653.   nRank=10;
  2654.   while((player->score>nScore[nRank-1])&&(nRank))
  2655.     nRank--;
  2656.  
  2657.   sprintf(szRank, "Your ranking is %d", nRank+1);
  2658.   if(nRank==0)
  2659.     strcat(szRank, "st");
  2660.   else if(nRank==1)
  2661.     strcat(szRank, "nd");
  2662.   else if(nRank==2)
  2663.     strcat(szRank, "rd");
  2664.   else
  2665.     strcat(szRank, "th");  
  2666.  
  2667.   do
  2668.   {
  2669.     PADstatus=PadRead(1);
  2670.     if(player==&player2)
  2671.     {
  2672.       PADstatus=PADstatus>>16;
  2673.       szPlayer[7]='2';
  2674.     }
  2675.      
  2676.     nBuffer=GsGetActiveBuff();
  2677.     GsSetWorkBase((PACKET*)out_packet[nBuffer]);
  2678.     GsClearOt(0, 0, &othWorld[nBuffer]);
  2679.  
  2680.     rClear.y=nBuffer*256;
  2681.     ClearImage(&rClear, 0,0,0);
  2682.  
  2683.     OutputString(szPlayer, -1, GetCentre(szPlayer), 10);
  2684.     OutputString(sz1, -1, GetCentre(sz1), 50);
  2685.     OutputString(sz2, -1, GetCentre(sz2), 80);
  2686.     OutputString(szLetters, -1, GetCentre(szLetters), 120);
  2687.     OutputString(szName, -1, GetCentre(szName), 150);
  2688.     OutputString(szRank, -1, GetCentre(szRank), 190);
  2689.  
  2690.     if(PADstatus & PADLleft)
  2691.     {
  2692.       if(!nHold)
  2693.       {
  2694.         SsUtKeyOn(nVab3, 1,0, 48, 0, 64,64);
  2695.         nPos--;
  2696.         nHold=1;
  2697.       }
  2698.     }
  2699.     else if(PADstatus & PADLright)
  2700.     {
  2701.       if(!nHold)
  2702.       {
  2703.         SsUtKeyOn(nVab3, 1,0, 48, 0, 64,64);
  2704.         nPos++;
  2705.         nHold=1;
  2706.       }
  2707.     }
  2708.     else
  2709.       nHold=0;
  2710.    
  2711.     if(PADstatus & PADRdown)
  2712.     {
  2713.       if(!nHoldX)
  2714.       {
  2715.         if(nPos<=25)
  2716.           szName[nLetter]=nPos+65;
  2717.         else if(nPos==26)
  2718.           szName[nLetter]=' ';  
  2719.         else if(nPos==27)
  2720.           szName[nLetter]='.';  
  2721.         nLetter++;
  2722.         nHoldX=1;
  2723.         if(nLetter<=3)
  2724.           SsUtKeyOn(nVab2, 2,0, 48, 0, 128,128);
  2725.       }
  2726.     }
  2727.     else
  2728.       nHoldX=0;
  2729.    
  2730.     if(PADstatus & PADRup)
  2731.     {
  2732.       if(!nHoldT)
  2733.       {
  2734.         if(nLetter)
  2735.         {
  2736.           nLetter--;
  2737.           szName[nLetter]='.';
  2738.           SsUtKeyOn(nVab, 4,0, 48, 0, 128,128);
  2739.         }
  2740.         nHoldT=1;
  2741.       }
  2742.     }
  2743.     else
  2744.       nHoldT=0;
  2745.  
  2746.  
  2747.     if(nPos<0)
  2748.       nPos=27;
  2749.     else if(nPos>27)
  2750.       nPos=0;
  2751.  
  2752.     cursor.x=x[nPos]+16;
  2753.     cursor.y=114;
  2754.    
  2755.     GsSortFastSprite(&cursor, &othWorld[nBuffer], 0);
  2756.    
  2757.     GsDrawOt(&othWorld[nBuffer]);
  2758.     DrawSync(0);
  2759.     VSync(0);
  2760.     GsSwapDispBuff();
  2761.     GsSortClear(0,0,0,&othWorld[nBuffer]);
  2762.   }while(nLetter<4);
  2763.  
  2764.  
  2765.   for(nCount=9; nCount>=nRank; nCount--)
  2766.   {
  2767.     nScore[nCount]=nScore[nCount-1];
  2768.     strcpy(szNames[nCount], szNames[nCount-1]);
  2769.   }
  2770.   szName[3]='\0';
  2771.   nScore[nRank]=player->score;
  2772.   strcpy(szNames[nRank], szName);
  2773.  
  2774.   SsUtKeyOn(nVab, 0,0, 48, 0, 128,128);
  2775.   SmearClear(128,128,128,1,0,1);
  2776. }
  2777.  
  2778.  
  2779. //--------------------------------------------------------------
  2780.  
  2781. void StartSplat(int type, int x, int y)
  2782. {
  2783.   int nCount=0;
  2784.  
  2785.   while(((splat[nCount].ax)||(splat[nCount].ay))&&(nCount<MAX_BSPLATS))
  2786.     nCount++;
  2787.  
  2788.   splat[nCount].x=x;
  2789.   splat[nCount].y=y;
  2790.   splat[nCount].ax=(rand()/1024)-16;
  2791.   splat[nCount].ay=(rand()/1024)-16;
  2792.  
  2793.   splat[nCount].line.x1=x-nMapx;
  2794.   splat[nCount].line.y1=y-nMapy;
  2795.  
  2796.   if(type)
  2797.   {
  2798.     splat[nCount].line.r1=255;
  2799.     splat[nCount].line.g1=255-rand()/256;
  2800.     splat[nCount].line.b1=255-rand()/128;
  2801.     splat[nCount].line.r0=0;
  2802.     splat[nCount].line.g0=0;
  2803.     splat[nCount].line.b0=0;
  2804.   }
  2805.   else
  2806.   {
  2807.     splat[nCount].line.r1=255;
  2808.     splat[nCount].line.g1=0;
  2809.     splat[nCount].line.b1=0;
  2810.     splat[nCount].line.r0=64;
  2811.     splat[nCount].line.g0=0;
  2812.     splat[nCount].line.b0=0;
  2813.   }
  2814. }
  2815.  
  2816.  
  2817. //--------------------------------------------------------------
  2818.  
  2819. void DrawSplats(void)
  2820. {
  2821.   int nCount;
  2822.  
  2823.   for(nCount=0; nCount<MAX_BSPLATS; nCount++)
  2824.   {
  2825.     if((splat[nCount].ax)||(splat[nCount].ay))
  2826.     {
  2827.       if(splat[nCount].ax>0)
  2828.         splat[nCount].ax--;
  2829.       else if(splat[nCount].ax<0)
  2830.         splat[nCount].ax++;
  2831.      
  2832.       if(splat[nCount].ay>0)
  2833.         splat[nCount].ay--;
  2834.       else if(splat[nCount].ay<0)
  2835.         splat[nCount].ay++;
  2836.      
  2837.       splat[nCount].line.x0=splat[nCount].line.x1;
  2838.       splat[nCount].line.y0=splat[nCount].line.y1;
  2839.      
  2840.       splat[nCount].x+=splat[nCount].ax;
  2841.       splat[nCount].y+=splat[nCount].ay;
  2842.      
  2843.       splat[nCount].line.x1=splat[nCount].x-nMapx;
  2844.       splat[nCount].line.y1=splat[nCount].y-nMapy;
  2845.    
  2846.       GsSortGLine(&splat[nCount].line, &othWorld[nBuffer], 0);
  2847.     }
  2848.   }
  2849. }
  2850.  
  2851.  
  2852.  
  2853.  
  2854.  
  2855.  
  2856.  
  2857.    
  2858. //--------------------------------------------------------------
  2859.  
  2860. void PadInit (void)
  2861. {
  2862.   GetPadBuf(&bb0, &bb1);
  2863. }
  2864.  
  2865. //--------------------------------------------------------------
  2866.  
  2867. u_long PadRead(int mode)
  2868. {
  2869.   u_long read;
  2870.   u_long temp;
  2871.  
  2872.   read=(~(*(bb0+3) | *(bb0+2) << 8 | *(bb1+3) << 16 | *(bb1+2) << 24));
  2873.   if(mode)
  2874.   {
  2875.     temp=read>>16;
  2876.     read|=temp;
  2877.   }
  2878.   return read;
  2879. }
RAW Paste Data
Top