mirror of
https://github.com/nebiun/ledHeadWii.git
synced 2024-11-22 18:49:17 +01:00
1341 lines
28 KiB
C
1341 lines
28 KiB
C
/*
|
|
* LEDhead for Wii
|
|
* Copyright (C) 2017-2020 Nebiun
|
|
*
|
|
* Based on the handheld electronic games by Mattel Electronics.
|
|
* All trademarks copyrighted by their respective owners. This
|
|
* program is not affiliated or endorsed by Mattel Electronics.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "Basketball2.h"
|
|
#include "Games.h"
|
|
|
|
// constants
|
|
|
|
#define GAMETIME 12.0
|
|
#define OVERTIME 5.0
|
|
#define PLAYTIME 24
|
|
#define PLAYTIME2 14
|
|
#define NUM_DEFENSEPLAYERS 5
|
|
|
|
#define TIME_TICKTIMER 10
|
|
|
|
#define TIME_STATSDISPLAY 5
|
|
#define TIME_BALLMOVE 5
|
|
#define TIME_WAITPASSAGE (10 * (4 - nLevel + 1))
|
|
#define TIME_DEFLECT 2
|
|
|
|
#define DMODE_MAN 0
|
|
#define DMODE_ZONE 1
|
|
#define DMODE_PRESS 2
|
|
|
|
typedef struct {
|
|
int state;
|
|
const int value;
|
|
} BLIP;
|
|
|
|
static BLIP Blips[BASKETBALL2_BLIP_COLUMNS][BASKETBALL2_BLIP_ROWS] = {
|
|
{ {0, 3}, {0, 0}, {0, 0}, {0, 3}, {0, 0} },
|
|
{ {0, 2}, {0, 0}, {0, 2}, {0, 0}, {0, 0} },
|
|
{ {0, 2}, {0, 2}, {0, 0}, {0, 0}, {0, 0} },
|
|
{ {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 3} },
|
|
{ {0, 2}, {0, 2}, {0, 0}, {0, 0}, {0, 0} },
|
|
{ {0, 2}, {0, 0}, {0, 2}, {0, 0}, {0, 0} },
|
|
{ {0, 3}, {0, 0}, {0, 0}, {0, 3}, {0, 0} }
|
|
};
|
|
|
|
// game variables
|
|
static BOOL bGameOver;
|
|
static BOOL bHomeTeam;
|
|
static BOOL bInFrame = FALSE;
|
|
static BOOL bPower;
|
|
static int nLevel = -1;
|
|
static int nPoints;
|
|
|
|
static int nHScore;
|
|
static int nVScore;
|
|
static float fGameTime;
|
|
static int nPlayTime;
|
|
static int nQuarter;
|
|
static int nTimerTickTimer;
|
|
static int n3secTime;
|
|
static int nFreeShoot;
|
|
|
|
static BOOL bShoot;
|
|
static BOOL bPass;
|
|
static BOOL bPassed;
|
|
static BOOL bInPass;
|
|
static BOOL bFoul;
|
|
static int nBallDirectionX;
|
|
static int nBallDirectionY;
|
|
static int nTimerBallMove;
|
|
static int nDefenseMode = -1;
|
|
|
|
static BOOL bDeflect;
|
|
static BOOL nTimerDeflect;
|
|
|
|
static int nStatsIndex;
|
|
static int nTimerStatsDisplay;
|
|
|
|
typedef struct {
|
|
int nColumn;
|
|
int nRow;
|
|
int nBright;
|
|
int nColumnOld;
|
|
int nRowOld;
|
|
int nMoveNow;
|
|
}PLAYER;
|
|
|
|
static PLAYER ball;
|
|
static PLAYER player;
|
|
static PLAYER receiver;
|
|
static PLAYER defense[NUM_DEFENSEPLAYERS];
|
|
|
|
typedef struct {
|
|
int min_x;
|
|
int min_y;
|
|
int max_x;
|
|
int max_y;
|
|
} ZONE;
|
|
|
|
// macros for dealing with the players
|
|
|
|
#define SETPLAYERBRIGHTNESS(p,b) { \
|
|
p.nBright = b; \
|
|
}
|
|
|
|
#define NOTECURRENTPLAYERPOSITION(p) { \
|
|
p.nColumnOld = p.nColumn; \
|
|
p.nRowOld = p.nRow; \
|
|
}
|
|
|
|
#define SETPLAYER(p,x,y,b) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn = x; \
|
|
p.nRow = y; \
|
|
p.nBright = b; \
|
|
}
|
|
|
|
#define UNSETPLAYER(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nBright = BLIP_OFF; \
|
|
}
|
|
|
|
#define MOVEPLAYERUP(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nRow--; \
|
|
}
|
|
#define MOVEPLAYERDOWN(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nRow++; \
|
|
}
|
|
#define MOVEPLAYERLEFT(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn--; \
|
|
}
|
|
#define MOVEPLAYERLEFTUP(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn--; \
|
|
p.nRow--;\
|
|
}
|
|
#define MOVEPLAYERLEFTDOWN(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn--; \
|
|
p.nRow++; \
|
|
}
|
|
#define MOVEPLAYERRIGHT(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn++; \
|
|
}
|
|
#define MOVEPLAYERRIGHTUP(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn++; \
|
|
p.nRow--; \
|
|
}
|
|
#define MOVEPLAYERRIGHTDOWN(p) { \
|
|
NOTECURRENTPLAYERPOSITION(p); \
|
|
p.nColumn++; \
|
|
p.nRow++; \
|
|
}
|
|
|
|
#define IN_ZONE(x, y, z) \
|
|
((x >= z->min_x && x <= z->max_x) && (y >= z->min_y && ny <= z->max_y))
|
|
|
|
#define IS_SHOOT_POSITION(x,y) ((Blips[x][y].value >= 2) ? 1 : 0)
|
|
|
|
#define IS_3SEC_ZONE(x,y) ((x >= 2 && x <= 4) && (y >= 0 && y <= 2))
|
|
|
|
static BOOL ISPLAYER(int x, int y)
|
|
{
|
|
if ((player.nColumn == x)
|
|
&& (player.nRow == y)
|
|
&& (player.nBright)){
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL ISRECEIVER(int x, int y)
|
|
{
|
|
if ((receiver.nColumn == x)
|
|
&& (receiver.nRow == y)
|
|
&& (receiver.nBright)){
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL ISDEFENSE(int x, int y)
|
|
{
|
|
for (int i=0; i<NUM_DEFENSEPLAYERS; i++){
|
|
if ((defense[i].nColumn == x)
|
|
&& (defense[i].nRow == y)
|
|
&& (defense[i].nBright)){
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL ISOCCUPIED(int x, int y)
|
|
{
|
|
if (ISPLAYER(x,y)){
|
|
return TRUE;
|
|
}
|
|
if (ISRECEIVER(x,y)){
|
|
return TRUE;
|
|
}
|
|
if (ISDEFENSE(x,y)){
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL MOVEAT(int sx, int sy, int dx, int dy, int *nx, int *ny)
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
if(sx != dx) {
|
|
if(sx > dx && sx > 0)
|
|
x--;
|
|
else if(sx < dx && sx < BASKETBALL2_BLIP_COLUMNS-1)
|
|
x++;
|
|
}
|
|
|
|
if(sy != dy) {
|
|
if(sy > dy && sy > 0)
|
|
y--;
|
|
else if(sy < dy && sy < BASKETBALL2_BLIP_ROWS-1)
|
|
y++;
|
|
}
|
|
|
|
if(x != 0 || y != 0) {
|
|
if (ISPLAYER(sx+x,sy+y) && IS_SHOOT_POSITION(sx+x,sx+y)){
|
|
if(y > 0)
|
|
y = 0;
|
|
}
|
|
if(ISOCCUPIED(sx+x,sy+y)) {
|
|
if(!ISOCCUPIED(sx,sy+y))
|
|
x = 0;
|
|
else if (!ISOCCUPIED(sx+x,sy))
|
|
y = 0;
|
|
else {
|
|
x = 0;
|
|
y = 0;
|
|
}
|
|
}
|
|
*nx = sx + x;
|
|
*ny = sy + y;
|
|
if(x == 0 && y == 0)
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
*nx = sx;
|
|
*ny = sy;
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL ISAGOODPASS()
|
|
{
|
|
int x, y;
|
|
|
|
x = player.nColumn + nBallDirectionX;
|
|
y = player.nRow + nBallDirectionY;
|
|
|
|
if(nBallDirectionX == 0) {
|
|
while(y != receiver.nRow) {
|
|
y += nBallDirectionY;
|
|
if(ISDEFENSE(x,y)) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
if(nBallDirectionY == 0) {
|
|
while(x != receiver.nColumn) {
|
|
x += nBallDirectionX;
|
|
if(ISDEFENSE(x,y)) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
while(x != receiver.nColumn && y != receiver.nRow) {
|
|
x += nBallDirectionX;
|
|
y += nBallDirectionY;
|
|
if(ISDEFENSE(x,y)) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static BOOL probability(int value)
|
|
{
|
|
int rtn;
|
|
|
|
rtn = (Platform_Random(100) <= ((value/4 * (nLevel + 1)) - Platform_Random(4 - nLevel))) ? TRUE : FALSE;
|
|
|
|
return rtn;
|
|
}
|
|
|
|
static BOOL ISFOUL()
|
|
{
|
|
int v = 0;
|
|
int d = 0;
|
|
|
|
if(ISDEFENSE(player.nColumn,player.nRow-1))
|
|
d++;
|
|
else if(ISDEFENSE(player.nColumn,player.nRow+1))
|
|
d++;
|
|
else if(ISDEFENSE(player.nColumn-1,player.nRow))
|
|
d++;
|
|
else if(ISDEFENSE(player.nColumn+1,player.nRow))
|
|
d++;
|
|
|
|
if(d == 0)
|
|
return FALSE;
|
|
|
|
if((player.nRow == 0) && (player.nColumn == 3))
|
|
v = 80;
|
|
else if((player.nRow >= 0 && player.nRow <= 1) && (player.nColumn >= 2 && player.nColumn <= 4))
|
|
v = 40;
|
|
else if((player.nRow >= 0 && player.nRow <= 2) && (player.nColumn >= 1 && player.nColumn <= 5))
|
|
v = 20;
|
|
else if(player.nRow >= 0 && player.nRow <= 3)
|
|
v = 10;
|
|
|
|
if(v == 0)
|
|
return FALSE;
|
|
|
|
if(probability(v))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void freethrow_scheme()
|
|
{
|
|
SETPLAYER(receiver, ((bHomeTeam) ? 1 : 5), 1, BLIP_DIMBLINK);
|
|
SETPLAYER(player, 3, 3, BLIP_BRIGHT);
|
|
UNSETPLAYER(ball);
|
|
SETPLAYER(defense[0], 1, 0, BLIP_DIM);
|
|
SETPLAYER(defense[1], ((bHomeTeam) ? 5 : 1), 1, BLIP_DIM);
|
|
SETPLAYER(defense[2], 5, 0, BLIP_DIM);
|
|
SETPLAYER(defense[3], 1, 2, BLIP_DIM);
|
|
SETPLAYER(defense[4], 5, 2, BLIP_DIM);
|
|
}
|
|
|
|
static void show_formation()
|
|
{
|
|
int i;
|
|
|
|
SETPLAYER(receiver, ((bHomeTeam) ? 6 : 0), 4, BLIP_DIMBLINK);
|
|
SETPLAYER(player, 3, 4, BLIP_BRIGHT);
|
|
UNSETPLAYER(ball);
|
|
SETPLAYER(defense[0], 2, 0, BLIP_DIM);
|
|
SETPLAYER(defense[1], 4, 0, BLIP_DIM);
|
|
SETPLAYER(defense[2], 1, 2, BLIP_DIM);
|
|
SETPLAYER(defense[3], 5, 2, BLIP_DIM);
|
|
SETPLAYER(defense[4], 3, 3, BLIP_DIM);
|
|
|
|
for (i=0; i<NUM_DEFENSEPLAYERS; i++)
|
|
defense[i].nMoveNow = 0;
|
|
receiver.nMoveNow = 0;
|
|
}
|
|
|
|
#define ISPLAYERMOVED(p) ((p.nColumn != p.nColumnOld) || (p.nRow != p.nRowOld))
|
|
|
|
#define UNMOVEPLAYER(p) { \
|
|
p.nRow = p.nRowOld; \
|
|
p.nColumn = p.nColumnOld; \
|
|
}
|
|
|
|
#define ISPLAYEROFFSCREEN(p) \
|
|
((p.nColumn > BASKETBALL2_BLIP_COLUMNS-1) \
|
|
|| (p.nColumn < 0) \
|
|
|| (p.nRow > BASKETBALL2_BLIP_ROWS-1) \
|
|
|| (p.nRow < 0))
|
|
|
|
|
|
#define ISPLAYERENABLED(p) \
|
|
(p.nBright)
|
|
|
|
// finite state machine stuff
|
|
|
|
static void fsmPlayStartWait();
|
|
static void fsmShowStats();
|
|
static void fsmDefenseWait();
|
|
static void fsmInPlay();
|
|
static void fsmDunk();
|
|
static void fsmGameOver();
|
|
static void fsmFreeThrow();
|
|
static void fsmFoul();
|
|
|
|
static enum FSM {
|
|
FSM_PLAYSTARTWAIT=0,
|
|
FSM_SHOWSTATS,
|
|
FSM_DEFENSEWAIT,
|
|
FSM_INPLAY,
|
|
FSM_DUNK,
|
|
FSM_GAMEOVER,
|
|
FSM_FREETHROW,
|
|
FSM_FOUL
|
|
}fsm;
|
|
|
|
typedef void (*FSMFCN)();
|
|
|
|
static FSMFCN fsmfcn[] = {
|
|
fsmPlayStartWait,
|
|
fsmShowStats,
|
|
fsmDefenseWait,
|
|
fsmInPlay,
|
|
fsmDunk,
|
|
fsmGameOver,
|
|
fsmFreeThrow,
|
|
fsmFoul
|
|
};
|
|
|
|
static void InitGame()
|
|
{
|
|
bHomeTeam = FALSE;
|
|
PlatformSetInput(bHomeTeam);
|
|
|
|
nHScore = 0;
|
|
nVScore = 0;
|
|
fGameTime = GAMETIME;
|
|
nQuarter = 0;
|
|
bGameOver = FALSE;
|
|
bDeflect = FALSE;
|
|
|
|
fsm = FSM_DEFENSEWAIT;
|
|
}
|
|
|
|
static void DrawBlips()
|
|
{
|
|
int x, y, nBright;
|
|
static BOOL bBlink = FALSE;
|
|
|
|
if(fsm != FSM_DUNK) {
|
|
for (int i=0; i<NUM_DEFENSEPLAYERS; i++){
|
|
if (defense[i].nBright != BLIP_OFF){
|
|
x = defense[i].nColumn;
|
|
y = defense[i].nRow;
|
|
nBright = defense[i].nBright;
|
|
Blips[x][y].state = nBright;
|
|
}
|
|
}
|
|
if (receiver.nBright != BLIP_OFF){
|
|
x = receiver.nColumn;
|
|
y = receiver.nRow;
|
|
nBright = receiver.nBright;
|
|
Blips[x][y].state = nBright;
|
|
}
|
|
if (player.nBright != BLIP_OFF){
|
|
x = player.nColumn;
|
|
y = player.nRow;
|
|
nBright = player.nBright;
|
|
Blips[x][y].state = nBright;
|
|
}
|
|
if (ball.nBright != BLIP_OFF){
|
|
x = ball.nColumn;
|
|
y = ball.nRow;
|
|
nBright = ball.nBright;
|
|
Blips[x][y].state = nBright;
|
|
}
|
|
}
|
|
// draw the blips field
|
|
for (y = 0; y < BASKETBALL2_BLIP_ROWS; y++){
|
|
for (x = 0; x < BASKETBALL2_BLIP_COLUMNS; x++){
|
|
switch(Blips[x][y].state){
|
|
case BLIP_OFF:
|
|
case BLIP_DIM:
|
|
case BLIP_BRIGHT:
|
|
Basketball2_DrawBlip(Blips[x][y].state, x, y);
|
|
break;
|
|
case BLIP_DIMBLINK:
|
|
if (!bBlink){
|
|
Basketball2_DrawBlip(BLIP_DIM, x, y);
|
|
} else {
|
|
Basketball2_DrawBlip(BLIP_OFF, x, y);
|
|
}
|
|
break;
|
|
case BLIP_BRIGHTBLINK:
|
|
if (!bBlink){
|
|
Basketball2_DrawBlip(BLIP_BRIGHT, x, y);
|
|
} else {
|
|
Basketball2_DrawBlip(BLIP_OFF, x, y);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bBlink = !bBlink;
|
|
}
|
|
|
|
BOOL Basketball2_GetPower()
|
|
{
|
|
return (bPower ? TRUE : FALSE);
|
|
}
|
|
|
|
void Basketball2_PowerOn()
|
|
{
|
|
InitGame();
|
|
bPower = TRUE;
|
|
}
|
|
|
|
void Basketball2_PowerOff()
|
|
{
|
|
bPower = FALSE;
|
|
Basketball2_StopSound();
|
|
}
|
|
|
|
void Basketball2_SetSkill(int i)
|
|
{
|
|
nLevel = i;
|
|
}
|
|
|
|
int Basketball2_GetSkill()
|
|
{
|
|
return nLevel;
|
|
}
|
|
|
|
|
|
void Basketball2_Run(int tu)
|
|
{
|
|
int x, y;
|
|
|
|
// prevent reentrancy
|
|
if (bInFrame){ return; }
|
|
bInFrame = TRUE;
|
|
|
|
// init the blips field
|
|
for (y = 0; y < BASKETBALL2_BLIP_ROWS; y++){
|
|
for (x = 0; x < BASKETBALL2_BLIP_COLUMNS; x++){
|
|
Blips[x][y].state = BLIP_OFF;
|
|
}
|
|
}
|
|
|
|
if (!bPower){
|
|
Basketball2_ClearScreen();
|
|
bInFrame = FALSE;
|
|
return;
|
|
}
|
|
|
|
Platform_StartDraw();
|
|
|
|
(fsmfcn[fsm])();
|
|
|
|
DrawBlips();
|
|
|
|
Platform_EndDraw();
|
|
|
|
bInFrame = FALSE;
|
|
|
|
}
|
|
|
|
static int moveCounterInit()
|
|
{
|
|
int rtn;
|
|
|
|
switch(nLevel) {
|
|
case LVL_COLLAGE:
|
|
rtn = Platform_Random(12);
|
|
break;
|
|
case LVL_ALLSTAR:
|
|
rtn = Platform_Random(8);
|
|
break;
|
|
case LVL_PROFESSIONAL:
|
|
rtn = Platform_Random(4);
|
|
break;
|
|
case LVL_HIGHSCHOOL:
|
|
default:
|
|
rtn = Platform_Random(16);
|
|
break;
|
|
}
|
|
return rtn;
|
|
}
|
|
|
|
static void initDefense()
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i < NUM_DEFENSEPLAYERS; i++) {
|
|
defense[i].nMoveNow = moveCounterInit();
|
|
}
|
|
}
|
|
|
|
static void manDefense()
|
|
{
|
|
static ZONE zone[NUM_DEFENSEPLAYERS] = {
|
|
{1, 0, 3, 2}, {3, 0, 5, 2}, {1, 1, 3, 3}, {3, 1, 5, 3}, {2, 1, 4, 3}
|
|
};
|
|
int i, d = 0;
|
|
|
|
for(i=0; i < NUM_DEFENSEPLAYERS; i++) {
|
|
int nx, ny;
|
|
ZONE *z = &zone[i];
|
|
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
if(defense[i].nMoveNow == 0) {
|
|
if(d < 2 && IN_ZONE(player.nColumn, player.nRow, z)) {
|
|
d++;
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, player.nColumn, player.nRow, &nx, &ny);
|
|
}
|
|
else {
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, player.nColumn, player.nRow, &nx, &ny);
|
|
}
|
|
if(!IN_ZONE(nx,ny,z)) {
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
}
|
|
defense[i].nMoveNow = moveCounterInit();
|
|
}
|
|
else {
|
|
defense[i].nMoveNow--;
|
|
}
|
|
SETPLAYER(defense[i], nx, ny, BLIP_DIM);
|
|
}
|
|
}
|
|
|
|
static void zoneDefense()
|
|
{
|
|
static ZONE zone[NUM_DEFENSEPLAYERS] = {
|
|
{0, 0, 4, 1}, {2, 0, 5, 2}, {0, 0, 2, 4}, {4, 0, 6, 4}, {0, 2, 6, 4}
|
|
};
|
|
int i;
|
|
|
|
for(i=0; i < NUM_DEFENSEPLAYERS; i++) {
|
|
int nx, ny;
|
|
ZONE *z = &zone[i];
|
|
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
if(defense[i].nMoveNow == 0) {
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, player.nColumn, player.nRow, &nx, &ny);
|
|
if(!IN_ZONE(nx, ny, z)) {
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
}
|
|
defense[i].nMoveNow = moveCounterInit();
|
|
}
|
|
else {
|
|
defense[i].nMoveNow--;
|
|
}
|
|
SETPLAYER(defense[i], nx, ny, BLIP_DIM);
|
|
}
|
|
}
|
|
|
|
static void pressDefense()
|
|
{
|
|
static ZONE zone[NUM_DEFENSEPLAYERS] = {
|
|
{1, 0, 3, 3}, {3, 0, 5, 3}, {1, 1, 5, 3}, {1, 1, 5, 3}, {1, 2, 5, 3}
|
|
};
|
|
int i, d = 0;
|
|
|
|
for(i=0; i < NUM_DEFENSEPLAYERS; i++) {
|
|
int nx, ny;
|
|
ZONE *z = &zone[i];
|
|
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
if(defense[i].nMoveNow == 0) {
|
|
if(IN_ZONE(receiver.nColumn, receiver.nRow, z)) {
|
|
d++;
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, receiver.nColumn, receiver.nRow, &nx, &ny);
|
|
}
|
|
else {
|
|
if(d == 0 && i == 4) {
|
|
d++;
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, receiver.nColumn, receiver.nRow, &nx, &ny);
|
|
}
|
|
else {
|
|
MOVEAT(defense[i].nColumn, defense[i].nRow, player.nColumn, player.nRow, &nx, &ny);
|
|
}
|
|
}
|
|
if(!IN_ZONE(nx,ny,z)) {
|
|
nx = defense[i].nColumn;
|
|
ny = defense[i].nRow;
|
|
}
|
|
defense[i].nMoveNow = moveCounterInit();
|
|
}
|
|
else {
|
|
defense[i].nMoveNow--;
|
|
}
|
|
SETPLAYER(defense[i], nx, ny, BLIP_DIM);
|
|
}
|
|
}
|
|
|
|
static void moveReceiver()
|
|
{
|
|
static int objx, objy;
|
|
int nx, ny;
|
|
|
|
nx = receiver.nColumn;
|
|
ny = receiver.nRow;
|
|
|
|
if(receiver.nMoveNow == 0) {
|
|
if((receiver.nColumn == 0 || receiver.nColumn == 6) && receiver.nRow == 4) {
|
|
objx = 3;
|
|
objy = 0;
|
|
}
|
|
else if(receiver.nColumn == objx && receiver.nRow == objy) {
|
|
do {
|
|
objx = Platform_Random(BASKETBALL2_BLIP_COLUMNS);
|
|
objy = Platform_Random(BASKETBALL2_BLIP_ROWS);
|
|
} while(receiver.nColumn == objx && receiver.nRow == objy);
|
|
}
|
|
/*
|
|
trc_x = objx;
|
|
trc_y = objy;
|
|
trc_x1 = receiver.nColumn;
|
|
trc_y1 = receiver.nRow;
|
|
*/
|
|
if(MOVEAT(receiver.nColumn, receiver.nRow, objx, objy, &nx, &ny) != TRUE) {
|
|
int nobjx, nobjy;
|
|
|
|
do {
|
|
nobjx = Platform_Random(BASKETBALL2_BLIP_COLUMNS);
|
|
nobjy = Platform_Random(BASKETBALL2_BLIP_ROWS);
|
|
} while(nobjx == objx && nobjy == objy);
|
|
objx = nobjx;
|
|
objy = nobjy;
|
|
nx = receiver.nColumn;
|
|
ny = receiver.nRow;
|
|
}
|
|
|
|
receiver.nMoveNow = 5 + Platform_Random(TIME_WAITPASSAGE);
|
|
if(IS_SHOOT_POSITION(nx,ny))
|
|
receiver.nMoveNow += 10;
|
|
}
|
|
else {
|
|
receiver.nMoveNow--;
|
|
}
|
|
SETPLAYER(receiver, nx, ny, BLIP_DIMBLINK);
|
|
}
|
|
|
|
// FINITE STATE MACHINE STUFF
|
|
|
|
static void fsmPlayStartWait()
|
|
{
|
|
bShoot = FALSE;
|
|
bPass = FALSE;
|
|
nPlayTime = PLAYTIME;
|
|
n3secTime = -1;
|
|
nTimerTickTimer = TIME_TICKTIMER;
|
|
bDeflect = FALSE;
|
|
nTimerDeflect = 0;
|
|
|
|
// show stats if pressed 'down'
|
|
// else, wait for player to move then advance to next state
|
|
BOOL bChange;
|
|
if (Basketball2_GetInputDOWN(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
fsmShowStats();
|
|
return;
|
|
}
|
|
}
|
|
else if (Basketball2_TestForMovement())
|
|
{
|
|
Platform_IsNewSecond();
|
|
fsmInPlay();
|
|
fsm = FSM_INPLAY;
|
|
return;
|
|
}
|
|
|
|
Basketball2_DrawStat((int)fGameTime);
|
|
}
|
|
|
|
static void fsmShowStats()
|
|
{
|
|
// show formation
|
|
if (!bGameOver)
|
|
{
|
|
show_formation();
|
|
}
|
|
|
|
if (--nTimerStatsDisplay <= 0)
|
|
{
|
|
++nStatsIndex;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
}
|
|
switch(nStatsIndex)
|
|
{
|
|
case 0:
|
|
Basketball2_DrawStat(-1);
|
|
break;
|
|
case 1:
|
|
Basketball2_DrawStat(nVScore);
|
|
break;
|
|
case 2:
|
|
Basketball2_DrawStat(-1);
|
|
break;
|
|
case 3:
|
|
Basketball2_DrawStat(nHScore);
|
|
break;
|
|
case 4:
|
|
Basketball2_DrawStat(-1);
|
|
break;
|
|
default:
|
|
case 5:
|
|
if (bGameOver) {
|
|
fsm = FSM_GAMEOVER;
|
|
}
|
|
else {
|
|
fsm = FSM_DEFENSEWAIT;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void fsmDefenseWait()
|
|
{
|
|
BOOL bChange;
|
|
|
|
show_formation();
|
|
nDefenseMode = -1;
|
|
|
|
if (Basketball2_GetInputUP(&bChange)) {
|
|
if (bChange)
|
|
nDefenseMode = DMODE_MAN;
|
|
}
|
|
else if (Basketball2_GetInputLEFT(&bChange)) {
|
|
if (bChange)
|
|
nDefenseMode = DMODE_ZONE;
|
|
}
|
|
else if (Basketball2_GetInputRIGHT(&bChange)) {
|
|
if (bChange)
|
|
nDefenseMode = DMODE_PRESS;
|
|
}
|
|
else if (Basketball2_GetInputDOWN(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
fsmShowStats();
|
|
return;
|
|
}
|
|
}
|
|
Basketball2_DrawStat((int)fGameTime);
|
|
if (nDefenseMode != -1) {
|
|
/* trace_bug = nDefenseMode; */
|
|
initDefense();
|
|
fsm = FSM_PLAYSTARTWAIT;
|
|
}
|
|
}
|
|
|
|
static void fsmInPlay()
|
|
{
|
|
BOOL bChange;
|
|
|
|
if (Basketball2_GetInputLEFTUP(&bChange)) {
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn > 0) && (player.nRow > 0)
|
|
&& (!ISOCCUPIED(player.nColumn-1, player.nRow-1))){
|
|
MOVEPLAYERLEFTUP(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputLEFTDOWN(&bChange)) {
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn > 0) && (player.nRow < (BASKETBALL2_BLIP_ROWS-1))
|
|
&& (!ISOCCUPIED(player.nColumn-1, player.nRow+1))){
|
|
MOVEPLAYERLEFTDOWN(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputRIGHTUP(&bChange)) {
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn < (BASKETBALL2_BLIP_COLUMNS-1)) && (player.nRow > 0)
|
|
&& (!ISOCCUPIED(player.nColumn+1, player.nRow-1))){
|
|
MOVEPLAYERRIGHTUP(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputRIGHTDOWN(&bChange)) {
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn < (BASKETBALL2_BLIP_COLUMNS-1)) && (player.nRow < (BASKETBALL2_BLIP_ROWS-1))
|
|
&& (!ISOCCUPIED(player.nColumn+1, player.nRow+1))){
|
|
MOVEPLAYERRIGHTDOWN(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputLEFT(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn > 0)
|
|
&& (!ISOCCUPIED(player.nColumn-1, player.nRow))){
|
|
MOVEPLAYERLEFT(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputRIGHT(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if ((player.nColumn < (BASKETBALL2_BLIP_COLUMNS-1))
|
|
&& (!ISOCCUPIED(player.nColumn+1, player.nRow))){
|
|
MOVEPLAYERRIGHT(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputUP(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if ((player.nRow > 0)
|
|
&& (!ISOCCUPIED(player.nColumn, player.nRow-1))){
|
|
MOVEPLAYERUP(player);
|
|
}
|
|
}
|
|
}
|
|
else if (Basketball2_GetInputDOWN(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if ((player.nRow < (BASKETBALL2_BLIP_ROWS-1))
|
|
&& (!ISOCCUPIED(player.nColumn, player.nRow+1))){
|
|
MOVEPLAYERDOWN(player);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nTimerDeflect)
|
|
{
|
|
// still in deflect
|
|
--nTimerDeflect;
|
|
return;
|
|
}
|
|
|
|
if (Basketball2_GetInputSHOOT(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if (!ISPLAYERENABLED(ball))
|
|
{
|
|
// shoot!
|
|
bShoot = TRUE;
|
|
bPassed = FALSE;
|
|
bInPass = FALSE;
|
|
nTimerBallMove = TIME_BALLMOVE;
|
|
SETPLAYERBRIGHTNESS(player, BLIP_DIMBLINK);
|
|
SETPLAYER(ball, player.nColumn, player.nRow, BLIP_BRIGHT);
|
|
nPoints = Blips[player.nColumn][player.nRow].value;
|
|
|
|
if (player.nRow > 0)
|
|
nBallDirectionY = -1;
|
|
else
|
|
nBallDirectionY = 0;
|
|
|
|
if (player.nColumn < 3)
|
|
nBallDirectionX = 1;
|
|
else if(player.nColumn > 3)
|
|
nBallDirectionX = -1;
|
|
else // player.nColumn == 3
|
|
nBallDirectionX = 0;
|
|
|
|
bFoul = ISFOUL();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Basketball2_GetInputPASS(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
if (!ISPLAYERENABLED(ball))
|
|
{
|
|
int x, y;
|
|
|
|
// Pass!
|
|
bPass = TRUE;
|
|
bInPass = TRUE;
|
|
nTimerBallMove = TIME_BALLMOVE;
|
|
SETPLAYERBRIGHTNESS(player, BLIP_DIMBLINK);
|
|
SETPLAYER(ball, player.nColumn, player.nRow, BLIP_BRIGHT);
|
|
|
|
y = player.nRow - receiver.nRow;
|
|
x = player.nColumn - receiver.nColumn;
|
|
|
|
if(x > 0)
|
|
nBallDirectionX = -1;
|
|
else if(x < 0)
|
|
nBallDirectionX = 1;
|
|
else
|
|
nBallDirectionX = 0;
|
|
|
|
if(y > 0)
|
|
nBallDirectionY = -1;
|
|
else if(y < 0)
|
|
nBallDirectionY = 1;
|
|
else
|
|
nBallDirectionY = 0;
|
|
|
|
bPassed = ISAGOODPASS();
|
|
}
|
|
}
|
|
}
|
|
// move the receiver
|
|
moveReceiver();
|
|
|
|
// move defenders
|
|
switch(nDefenseMode) {
|
|
case DMODE_MAN:
|
|
manDefense();
|
|
break;
|
|
case DMODE_ZONE:
|
|
zoneDefense();
|
|
break;
|
|
case DMODE_PRESS:
|
|
pressDefense();
|
|
break;
|
|
}
|
|
|
|
// move the ball
|
|
if (ISPLAYERENABLED(ball))
|
|
{
|
|
n3secTime = -1;
|
|
|
|
// the puck hit a defender last frame - play the sound
|
|
if (ISDEFENSE(ball.nColumn, ball.nRow) && !bDeflect && !bPassed)
|
|
{
|
|
bDeflect = TRUE;
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_BOUNCE, PLAYSOUNDFLAGS_PRIORITY);
|
|
nTimerDeflect = TIME_DEFLECT;
|
|
return;
|
|
}
|
|
|
|
if (--nTimerBallMove <= 0)
|
|
{
|
|
nTimerBallMove = TIME_BALLMOVE;
|
|
if (bFoul) {
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_FOUL, PLAYSOUNDFLAGS_PRIORITY);
|
|
}
|
|
|
|
// check for a basket
|
|
if ((ball.nColumn == 3) && (ball.nRow == 0) && !bInPass
|
|
&& !ISDEFENSE(ball.nColumn, ball.nRow)) // <-- is this right?
|
|
{
|
|
// basket!
|
|
nFreeShoot = (bFoul) ? 1 : 0;
|
|
ball.nRow = -1;
|
|
Basketball2_DrawBasket(TRUE);
|
|
fsm = FSM_DUNK;
|
|
return;
|
|
}
|
|
|
|
// check the foul
|
|
if (bFoul) {
|
|
nFreeShoot = nPoints;
|
|
fsm = FSM_FOUL;
|
|
return;
|
|
}
|
|
|
|
// bounce the ball off the far wall
|
|
if (!ISDEFENSE(ball.nColumn, ball.nRow) && !ISRECEIVER(ball.nColumn, ball.nRow))
|
|
{
|
|
if ((ball.nRow <= 0) && (ball.nColumn >= 2 && ball.nColumn <= 4) && (nBallDirectionY == -1))
|
|
{
|
|
ball.nRow = 0;
|
|
nBallDirectionY = 1;
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_BOUNCE, PLAYSOUNDFLAGS_PRIORITY);
|
|
nTimerDeflect = TIME_DEFLECT;
|
|
bDeflect = FALSE;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// bounce the ball off the defenders
|
|
if (bDeflect)
|
|
{
|
|
nBallDirectionX = Platform_Random(3) - 1;
|
|
nBallDirectionY = 1;
|
|
bDeflect = FALSE;
|
|
}
|
|
|
|
// see if player has regained possession
|
|
if (ISPLAYER(ball.nColumn, ball.nRow) && !bShoot && !bPass)
|
|
{
|
|
UNSETPLAYER(ball);
|
|
SETPLAYERBRIGHTNESS(player, BLIP_BRIGHT);
|
|
}
|
|
else if (ISRECEIVER(ball.nColumn, ball.nRow)) {
|
|
PLAYER tmp;
|
|
|
|
bPassed = FALSE;
|
|
UNSETPLAYER(ball);
|
|
tmp = player;
|
|
player = receiver;
|
|
receiver = tmp;
|
|
SETPLAYERBRIGHTNESS(player, BLIP_BRIGHT);
|
|
}
|
|
else
|
|
{
|
|
// move the ball
|
|
ball.nColumn += nBallDirectionX;
|
|
ball.nRow += nBallDirectionY;
|
|
bShoot = FALSE;
|
|
bPass = FALSE;
|
|
|
|
// see if the ball bounced off the screen
|
|
if (ISPLAYEROFFSCREEN(ball) && ISPLAYERENABLED(ball))
|
|
{
|
|
// off the screen - get rid of it and end the play
|
|
UNSETPLAYER(ball);
|
|
SETPLAYERBRIGHTNESS(player, BLIP_BRIGHT);
|
|
Basketball2_ClearScreen();
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_ENDPLAY, PLAYSOUNDFLAGS_PRIORITY);
|
|
bHomeTeam = !bHomeTeam;
|
|
PlatformSetInput(bHomeTeam);
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3sec time rule
|
|
if(IS_3SEC_ZONE(player.nColumn, player.nRow) && !ISPLAYERENABLED(ball)) {
|
|
if(n3secTime == -1)
|
|
n3secTime = 3;
|
|
}
|
|
else
|
|
n3secTime = -1;
|
|
|
|
// count down the clock
|
|
if (Platform_IsNewSecond()){
|
|
// check for end of quarter
|
|
if (fGameTime > 0.0){
|
|
fGameTime -= (float).1;
|
|
if (fGameTime < 0.1){
|
|
|
|
// end of quarter
|
|
++nQuarter;
|
|
|
|
// Overtime needed if nHScore == nVScore
|
|
if ((nQuarter >= 4) && (nHScore != nVScore))
|
|
{
|
|
// game over
|
|
bGameOver = TRUE;
|
|
|
|
show_formation();
|
|
|
|
Basketball2_ClearScreen();
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_ENDGAME, PLAYSOUNDFLAGS_PRIORITY);
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
return;
|
|
}
|
|
|
|
bHomeTeam = (nQuarter % 2) ? FALSE : TRUE;
|
|
PlatformSetInput(bHomeTeam);
|
|
|
|
fGameTime = (nQuarter < 4) ? GAMETIME : OVERTIME;
|
|
Basketball2_ClearScreen();
|
|
if(fGameTime == GAMETIME)
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_ENDQUARTER, PLAYSOUNDFLAGS_PRIORITY);
|
|
else
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_OVERTIME, PLAYSOUNDFLAGS_PRIORITY);
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
return;
|
|
}
|
|
}
|
|
// check for 3sec time
|
|
if(n3secTime != -1) {
|
|
n3secTime--;
|
|
if(n3secTime == 0) {
|
|
Basketball2_ClearScreen();
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_3SECS, PLAYSOUNDFLAGS_PRIORITY);
|
|
bHomeTeam = !bHomeTeam;
|
|
PlatformSetInput(bHomeTeam);
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// check for end of play timer
|
|
if (--nPlayTime < 0){
|
|
Basketball2_ClearScreen();
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_ENDPLAY, PLAYSOUNDFLAGS_PRIORITY);
|
|
bHomeTeam = !bHomeTeam;
|
|
PlatformSetInput(bHomeTeam);
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
return;
|
|
}
|
|
}
|
|
|
|
Basketball2_DrawStat(nPlayTime);
|
|
|
|
// make tick sounds
|
|
if (fGameTime >= .1){
|
|
if (--nTimerTickTimer <= 0){
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_TICK, PLAYSOUNDFLAGS_ASYNC);
|
|
nTimerTickTimer = TIME_TICKTIMER;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void fsmDunk()
|
|
{
|
|
switch(nPoints) {
|
|
case 1:
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_FREETHROW, PLAYSOUNDFLAGS_PRIORITY);
|
|
break;
|
|
case 3:
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_SCORE3, PLAYSOUNDFLAGS_PRIORITY);
|
|
break;
|
|
default:
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_SCORE, PLAYSOUNDFLAGS_PRIORITY);
|
|
break;
|
|
}
|
|
Basketball2_DrawBasket(FALSE);
|
|
if (bHomeTeam)
|
|
nHScore += nPoints;
|
|
else
|
|
nVScore += nPoints;
|
|
|
|
if(!bFoul) {
|
|
show_formation();
|
|
Platform_IsNewSecond();
|
|
fsm = FSM_INPLAY;
|
|
}
|
|
else {
|
|
fsm = FSM_FOUL;
|
|
}
|
|
}
|
|
|
|
static void fsmFoul()
|
|
{
|
|
Basketball2_ClearScreen();
|
|
freethrow_scheme();
|
|
fsm = FSM_FREETHROW;
|
|
}
|
|
|
|
static void fsmFreeThrow()
|
|
{
|
|
BOOL bChange;
|
|
if (Basketball2_GetInputSHOOT(&bChange)) {
|
|
if (bChange) {
|
|
nFreeShoot--;
|
|
nTimerBallMove = TIME_BALLMOVE;
|
|
SETPLAYERBRIGHTNESS(player, BLIP_DIMBLINK);
|
|
SETPLAYER(ball, player.nColumn, player.nRow, BLIP_BRIGHT);
|
|
}
|
|
}
|
|
|
|
if (--nTimerBallMove <= 0) {
|
|
nTimerBallMove = TIME_BALLMOVE;
|
|
|
|
// check for a basket
|
|
if (ball.nRow == 0) {
|
|
if(nFreeShoot == 0)
|
|
bFoul = 0;
|
|
// basket!
|
|
if(probability(100)) {
|
|
nPoints = 1;
|
|
ball.nRow = -1;
|
|
Basketball2_DrawBasket(TRUE);
|
|
fsm = FSM_DUNK;
|
|
}
|
|
else {
|
|
ball.nRow = 1;
|
|
nBallDirectionY = 1;
|
|
nBallDirectionX = Platform_Random(3) - 1;
|
|
Basketball2_PlaySound(BASKETBALL2_SOUND_BOUNCE, PLAYSOUNDFLAGS_PRIORITY);
|
|
nTimerDeflect = TIME_DEFLECT;
|
|
bDeflect = FALSE;
|
|
nPlayTime = PLAYTIME2;
|
|
Platform_IsNewSecond();
|
|
fsm = FSM_INPLAY;
|
|
}
|
|
return;
|
|
}
|
|
// move the ball
|
|
ball.nRow -= 1;
|
|
}
|
|
}
|
|
|
|
static void fsmGameOver()
|
|
{
|
|
// show stats if pressed 'down'
|
|
BOOL bChange;
|
|
if (Basketball2_GetInputDOWN(&bChange))
|
|
{
|
|
if (bChange)
|
|
{
|
|
nStatsIndex = 0;
|
|
nTimerStatsDisplay = TIME_STATSDISPLAY;
|
|
fsm = FSM_SHOWSTATS;
|
|
fsmShowStats();
|
|
return;
|
|
}
|
|
}
|
|
|
|
Basketball2_DrawStat(0);
|
|
}
|
|
|
|
void Basketball2_Debug(int f)
|
|
{
|
|
|
|
}
|