The-Homebrew-Cloud/ledHeadWii
2
0
Fork 0
mirror of https://github.com/nebiun/ledHeadWii.git synced 2024-06-01 08:08:45 +02:00
Code Issues Packages Projects Releases Wiki Activity
94e2ba84c5
ledHeadWii/source/game/Baseball.c
nebiun 94e2ba84c5 Version 1.1
2020-05-25 18:02:06 +02:00

927 lines
21 KiB
C
Raw Blame History

/*
LEDhead
Copyright 2001, Peter Hirschberg
Author: Peter Hirschberg
The current version of this SOURCE CODE as well as the official
versions of the LEDHEAD APPLICATION are available from my website
at: http://www.peterhirschberg.com
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.
License agreement:
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 2
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 (license.txt); if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Email : peter@peterhirschberg.com
Website : http://www.peterhirschberg.com
*/
#include <string.h>
#include <sys/time.h>
#include "Baseball.h"
#include "Games.h"
// constants
#define FIRSTBASE 3
#define SECONDBASE 6
#define THIRDBASE 9
#define HOMEPLATE 12
#define MAGIC_NUMBER 64 // emperically derived magic number
#define SPEED_BASE (1 + (MAGIC_NUMBER/16))
#define CENTER_FIELD 0
#define LEFT_FIELD 1
#define RIGHT_FIELD 2
// game variables
static BOOL bHomeTeam;
static BOOL bInFrame = FALSE;
static int nHRuns;
static int nVRuns;
static int nInnings;
static int nOuts;
static int nBalls;
static int nStrikes;
static int nTimerPitchWait;
static int nPitchSpeed;
static BOOL bCurveball;
static BOOL bStrike = FALSE;
static int nPitchIndex;
static int nPendingRuns;
static int nTimerEndPlayWait;
static int nTimerRunnerMove;
static int nRunnerSpeed;
static int nTimerFielding;
static int nCurrentRunnerIndex;
static int nDefenseBlip;
static int nBallBlip;
static BOOL bCaught;
static BOOL bDisplayOff;
static int fireWorks;
static int nSwingSlot;
// finite state machine stuff
static void fsmIdle(int tu);
static void fsmPitchWait(int tu);
static void fsmPitching(int tu);
static void fsmEndPlayWait(int tu);
static void fsmRun(int tu);
static void fsmWalk(int tu);
static void fsmOut(int tu);
static void fsmHomeRun(int tu);
static void fsmEndPossession(int tu);
static void fsmGameOver(int tu);
static void fsmGoOut(int tu);
enum FSM {
FSM_IDLE,
FSM_PITCHWAIT,
FSM_PITCHING,
FSM_ENDPLAYWAIT,
FSM_RUN,
FSM_WALK,
FSM_OUT,
FSM_HOMERUN,
FSM_ENDPOSSESSION,
FSM_GAMEOVER,
FSM_GOOUT
};
static enum FSM fsm;
typedef void (*FSMFCN)(int);
static FSMFCN fsmfcn[] = {
fsmIdle,
fsmPitchWait,
fsmPitching,
fsmEndPlayWait,
fsmRun,
fsmWalk,
fsmOut,
fsmHomeRun,
fsmEndPossession,
fsmGameOver,
fsmGoOut
};
typedef struct
{
int baseindex;
BOOL enabled;
} RUNNER;
#define MAX_RUNNERS 4
RUNNER runners[MAX_RUNNERS];
typedef struct {
int seq[3];
int n;
} fireworks_t;
static fireworks_t fw_frames[] = {
{ {DIAMOND(1)}, 1},
{ {DIAMOND(1), DIAMOND(2)}, 2},
{ {DIAMOND(1), DIAMOND(2), DEEP_1ST}, 3},
{ {DIAMOND(2), DEEP_1ST, DIAMOND(4)}, 3},
{ {DEEP_1ST, DIAMOND(4), DIAMOND(5)}, 3},
{ {DIAMOND(4), DIAMOND(5), DEEP_3RD}, 3},
{ {DIAMOND(5), DEEP_3RD, DIAMOND(8)}, 3},
{ {DEEP_3RD, DIAMOND(8), DIAMOND(7)}, 3},
{ {DIAMOND(8), DIAMOND(7), OUT_LEFT}, 3},
{ {DIAMOND(7), OUT_LEFT, OUT_CENTER}, 3},
{ {OUT_LEFT, OUT_CENTER, -1}, 3},
{ {OUT_CENTER, -1, DIAMOND(10)}, 3},
{ {-1, DIAMOND(10), DIAMOND(11)}, 3},
{ {DIAMOND(10), DIAMOND(11), NORMAL_BALL(8)}, 3},
{ {NORMAL_BALL(8), NORMAL_BALL(7)}, 2},
{ {NORMAL_BALL(8), NORMAL_BALL(7), NORMAL_BALL(6)}, 3},
{ {NORMAL_BALL(7), NORMAL_BALL(6), NORMAL_BALL(5)}, 3},
{ {NORMAL_BALL(6), NORMAL_BALL(5), CURVE_BALL(4)}, 3},
{ {NORMAL_BALL(5), CURVE_BALL(3), CURVE_BALL(2)}, 3},
{ {CURVE_BALL(3), CURVE_BALL(2), CURVE_BALL(1)}, 3},
{ {CURVE_BALL(2), CURVE_BALL(1), NORMAL_BALL(1)}, 3},
{ {CURVE_BALL(1), NORMAL_BALL(1), NORMAL_BALL(2)}, 3},
{ {NORMAL_BALL(1), NORMAL_BALL(2), NORMAL_BALL(3)}, 3},
{ {NORMAL_BALL(2), NORMAL_BALL(3), NORMAL_BALL(4)}, 3},
{ {NORMAL_BALL(3), NORMAL_BALL(4)}, 2},
{ {}, 0}
};
static void ClearBlips()
{
int i;
if(fireWorks) {
fireworks_t *fw=&fw_frames[fireWorks-1];
for(i=0; i<fw->n; i++) {
if(fw->seq[i] != -1)
Baseball_DrawBlip(FALSE,fw->seq[i]);
}
}
else {
if(nBallBlip != -1) {
Baseball_DrawBlip(FALSE, nBallBlip);
}
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
Baseball_DrawBlip(FALSE, DIAMOND(runners[i].baseindex));
}
}
if (nDefenseBlip != -1) {
Baseball_DrawBlip(FALSE, nDefenseBlip);
}
}
}
static void DrawBlips()
{
int i;
if(fireWorks > 0) {
fireworks_t *fw=&fw_frames[fireWorks-1];
Baseball_DrawScore(-1, -1); // Clean fireworks
for(i=0; i<fw->n; i++) {
if(fw->seq[i] == -1)
Baseball_DrawFireWorks();
else
Baseball_DrawBlip(TRUE,fw->seq[i]);
}
}
else {
if(nBallBlip != -1) {
Baseball_DrawBlip(TRUE, nBallBlip);
}
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
Baseball_DrawBlip(TRUE, DIAMOND(runners[i].baseindex));
}
}
if (nDefenseBlip != -1) {
if (bCaught) {
static BOOL blink=FALSE;
static int blinkcnt=0;
--blinkcnt;
if (blinkcnt<0) {
blinkcnt = 2;
blink = !blink;
}
if (blink) {
Baseball_DrawBlip(TRUE, nDefenseBlip);
}
}
else
Baseball_DrawBlip(TRUE, nDefenseBlip);
}
}
}
static void InitGame()
{
bHomeTeam = FALSE;
PlatformSetInput(bHomeTeam);
nHRuns = 0;
nVRuns = 0;
nInnings = 0;
nStrikes = 0;
nOuts = 0;
nBalls = 0;
nBallBlip = -1;
nDefenseBlip = -1;
for (int i=0; i<MAX_RUNNERS; i++) {
runners[i].enabled = FALSE;
}
fsm = FSM_IDLE;
}
void Baseball_Run(int tu)
{
// prevent reentrancy
if (bInFrame)
return;
bInFrame = TRUE;
if (Baseball_GetPower() == FALSE) {
InitGame();
// power is off
Platform_StartDraw();
Baseball_DrawScore(-1, -1);
Platform_EndDraw();
bInFrame = FALSE;
return;
}
Platform_StartDraw();
ClearBlips();
// run the game
(fsmfcn[fsm])(tu);
if(!bDisplayOff) {
DrawBlips();
}
else {
Baseball_DrawScore(-1, -1);
}
Platform_EndDraw();
bInFrame = FALSE;
}
static void InsertRunner()
{
for (int i=0; i<MAX_RUNNERS; i++) {
if (!runners[i].enabled) {
runners[i].baseindex = 0;
runners[i].enabled = TRUE;
nCurrentRunnerIndex = i;
return;
}
}
}
// returns TRUE if move resulted in a run
static BOOL MoveRunners()
{
BOOL bRun = FALSE;
for (int i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
runners[i].baseindex++;
if (runners[i].baseindex >= HOMEPLATE) {
// got a run
runners[i].baseindex = -1;
runners[i].enabled = FALSE;
if (i == nCurrentRunnerIndex) {
nCurrentRunnerIndex = -1;
}
bRun=TRUE;
}
}
}
return bRun;
}
static void ResetOffBaseRunners()
{
BOOL bOffBase = FALSE;
for (int i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
if ((runners[i].baseindex != FIRSTBASE)
&& (runners[i].baseindex != SECONDBASE)
&& (runners[i].baseindex != THIRDBASE)
&& (runners[i].baseindex != HOMEPLATE)) {
// yes, there is at least one runner and he is off-base
bOffBase = TRUE;
break;
}
}
}
if (bOffBase) {
//
// The ball has now been fielded and there are
// currently runners off-base -- figure out who
// is out.
//
// If the batter did not make it to first, he is out and
// the remaining runners all move back to the previous base.
// If the batter made it past first, the lead runner is out
// and the remaining runners move either to the next base or
// to the previous base, depending on how far they made it.
//
// see if the batter made it to first
BOOL bFirst=TRUE;
int i;
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
if (runners[i].baseindex < FIRSTBASE) {
// the batter didn't make it to first - he's out
runners[i].enabled = FALSE;
bFirst = FALSE;
break;
}
}
}
if (bFirst) {
// look for the lead runner
int nRunnerOut = -1;
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
if (nRunnerOut == -1) {
nRunnerOut = i;
}
else {
if (runners[i].baseindex > runners[nRunnerOut].baseindex) {
nRunnerOut = i;
}
}
}
}
// mark the lead runner out
if (nRunnerOut != -1) {
runners[nRunnerOut].enabled = FALSE;
}
// figure out if the remaining runners should go to the previous or next base
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
int howfar = (runners[i].baseindex) % 3;
if (howfar <= 1) {
// go back
runners[i].baseindex--;
}
else {
// go forward
runners[i].baseindex++;
}
}
}
}
else {
// the batter is out
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
if (runners[i].baseindex < FIRSTBASE) {
runners[i].enabled = FALSE;
break;
}
}
}
// move the remaining runners back to the previous base
for (i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
runners[i].baseindex -= (runners[i].baseindex) % 3;
}
}
}
}
}
static enum FSM HitBall()
{
// This routine was totally rewritten by Nebiun
//
// There are 3 positions where you can hit the ball:
// - right in front of the plate
// - directly over the plate
// - right behind the plate
//
// In addition, each position is sampled more times related
// to the ball speed (random and depending from game level)
//
// Finally, there are 5 catchers that can field the ball:
// - left and right infield
// - left, center and right outfield
//
// The ball will either be fielded normally or it will be
// a fly out and will be counted as an out. If the ball is
// fielded normally, we pick a random fielding time (1,2 or 3
// beeps), and a random runner speed.
int side, force;
if(nPitchIndex == 5) {
if(Platform_Random(10) == 0) // left-handed batter
side = RIGHT_FIELD;
else
side = LEFT_FIELD;
}
else if(nPitchIndex == 7) {
if(Platform_Random(10) == 0) // left-handed batter
side = LEFT_FIELD;
else
side = RIGHT_FIELD;
}
else {
switch(Platform_Random(5)) {
case 0:
side = LEFT_FIELD;
break;
case 1:
side = RIGHT_FIELD;
break;
default:
side = CENTER_FIELD;
break;
}
}
if((nPitchSpeed <= 1) || (nSwingSlot < nPitchSpeed)) {
force = 1;
}
else {
force = 0;
}
switch(side) {
case LEFT_FIELD:
if((force == 0) || (Platform_Random(5) == 0))
nDefenseBlip = DEEP_3RD;
else
nDefenseBlip = Platform_Random(2) ? DEEP_3RD : OUT_LEFT;
break;
case RIGHT_FIELD:
if((force == 0) || (Platform_Random(5) == 0))
nDefenseBlip = DEEP_1ST;
else
nDefenseBlip = Platform_Random(2) ? DEEP_1ST : OUT_RIGHT;
break;
default:
if((force == 0) || (Platform_Random(5) == 0))
nDefenseBlip = Platform_Random(2) ? OUT_LEFT : OUT_RIGHT;
else
nDefenseBlip = OUT_CENTER;
break;
}
// Out ?
if (Platform_Random(4) == 0) {
bCaught = TRUE;
return FSM_GOOUT;
}
// Homerun
if ((force == 1) &&
(((side == CENTER_FIELD) && (Platform_Random(4) == 0)) || (Platform_Random(25) == 0))) {
nDefenseBlip = -1;
fireWorks = 1;
return FSM_HOMERUN;
}
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
// pick a random fielding speed and play
// the correct number of base tones
int level = Baseball_GetSkill();
int bases = Platform_Random(3)+1;
nTimerFielding = (MAGIC_NUMBER * bases) - (level * Platform_Random(10));
for (int i=0; i<bases; i++) {
Baseball_PlaySound(BASEBALL_SOUND_HIT, PLAYSOUNDFLAGS_PRIORITY);
Platform_Pause(200);
}
// pick a random runner speed:
// slow or medium or fast
nTimerRunnerMove = nRunnerSpeed = SPEED_BASE * (1 + Platform_Random(3));
// insert a runner
InsertRunner();
return FSM_RUN;
}
static long long Baseball_Clock(int f)
{
static struct timeval tv_start;
struct timeval tv, tv_delta;
long long rtn;
if(f == 1) {
gettimeofday(&tv_start, NULL);
return 0;
}
gettimeofday(&tv, NULL);
timersub(&tv, &tv_start, &tv_delta);
rtn = tv_delta.tv_sec * 1000000 + tv_delta.tv_usec;
return rtn;
}
static BOOL run()
{
if (--nTimerRunnerMove <= 0) {
nTimerRunnerMove = nRunnerSpeed;
if (MoveRunners()) {
// record runs
if (bHomeTeam) {
++nHRuns;
}
else {
++nVRuns;
}
// also note the run for later (for the sounds)
++nPendingRuns;
}
return TRUE;
}
return FALSE;
}
static void pendigRunNotify()
{
while(nPendingRuns > 0) {
Baseball_PlaySound(BASEBALL_SOUND_RUN, PLAYSOUNDFLAGS_PRIORITY);
Platform_Pause(200);
--nPendingRuns;
}
bDisplayOff = (nPendingRuns > 0) ? TRUE : FALSE;
}
// FINITE STATE MACHINE STUFF
static void fsmGoOut(int tu)
{
static int delay = 0;
if(delay == 0) {
delay = 1000 * 600;
bDisplayOff = TRUE;
Baseball_PlaySound(BASEBALL_SOUND_OUT, PLAYSOUNDFLAGS_ASYNC|PLAYSOUNDFLAGS_PRIORITY);
Baseball_Clock(1);
}
else if(Baseball_Clock(0) >= delay) {
delay = 0;
bDisplayOff = FALSE;
fsm = FSM_OUT;
}
}
static void fsmOut(int tu)
{
++nOuts;
if (nOuts == 3) {
// end of possession
// but first play any pending run sounds
if(nPendingRuns > 0)
pendigRunNotify();
nOuts = 0;
bHomeTeam = !bHomeTeam;
if (!bHomeTeam) {
++nInnings;
if (nInnings == 5) {
// ************************
// ****** GAME OVER *******
// ************************
Baseball_PlaySound(BASEBALL_SOUND_ENDGAME, PLAYSOUNDFLAGS_ASYNC|PLAYSOUNDFLAGS_PRIORITY);
fsm = FSM_GAMEOVER;
return;
}
}
PlatformSetInput(bHomeTeam);
Baseball_PlaySound(BASEBALL_SOUND_ENDPOSSESSION, PLAYSOUNDFLAGS_PRIORITY|PLAYSOUNDFLAGS_ASYNC);
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
fsm = FSM_ENDPOSSESSION;
}
else {
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
nStrikes = 0;
nBalls = 0;
nTimerEndPlayWait = (nDefenseBlip == -1) ? 1500 : 3000;
Baseball_Clock(1);
fsm = FSM_ENDPLAYWAIT;
}
}
static void fsmIdle(int tu)
{
// play the run sounds
if(nPendingRuns > 0)
pendigRunNotify();
nCurrentRunnerIndex = -1;
nDefenseBlip = -1;
bCaught = FALSE;
nBallBlip = -1;
if (Baseball_GetInputSCORE(NULL)) {
Baseball_DrawScore(nVRuns, nHRuns);
}
else {
Baseball_DrawStats(nInnings+1, nOuts, nBalls, nStrikes, bHomeTeam);
}
// wait for pitch button
if (Baseball_GetInputPITCH(NULL)) {
// delay from 1.5 to 2.5 seconds (according to manual)
// before pitching the ball
nTimerPitchWait = 1000 * (1500 + Platform_Random(1000)); // Microsecs
Baseball_Clock(1);
fsm = FSM_PITCHWAIT;
}
}
static void fsmPitchWait(int tu)
{
Baseball_DrawScore(-1, -1);
if (Baseball_Clock(0) >= nTimerPitchWait) {
int level = Baseball_GetSkill();
// pick a ball speed and throw style
// and pitch the ball
bCurveball = (Platform_Random(3 - level) == 0) ? TRUE : FALSE;
if (bCurveball) {
nPitchSpeed = (3 - level) + Platform_Random(2 - level); // curve balls are a little slower
}
else {
nPitchSpeed = (2 - level) + Platform_Random(3 - level);
}
nSwingSlot = nPitchSpeed;
nPitchIndex = 0;
nBallBlip = (bCurveball) ? CURVE_BALL(nPitchIndex) : NORMAL_BALL(nPitchIndex);
bStrike = FALSE;
fsm = FSM_PITCHING;
}
}
static void fsmPitching(int tu)
{
const int nMissChance = 5;
if(nPitchIndex <= 8) {
if(Baseball_GetInputHIT(NULL)) {
if((nPitchIndex >= 5) && (nPitchIndex <= 7) && (Platform_Random(nMissChance) != 0)) {
fsm = HitBall();
}
else {
bStrike = TRUE;
nPitchIndex = 9;
}
}
else {
if(--nSwingSlot <= 0) {
nSwingSlot = nPitchSpeed;
++nPitchIndex;
}
}
}
else {
// if player didn't swing, randomly pick strike or ball
if (Platform_Random(2) && !bStrike) {
++nBalls;
}
else {
++nStrikes;
}
if (nBalls == 4) {
// walk
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
Baseball_PlaySound(BASEBALL_SOUND_STRIKE, PLAYSOUNDFLAGS_PRIORITY|PLAYSOUNDFLAGS_ASYNC);
nTimerRunnerMove = nRunnerSpeed = 2 * SPEED_BASE; // walk is always a fixed speed
InsertRunner();
fsm = FSM_WALK;
}
else if (nStrikes == 3) {
// struck out
fsm = FSM_GOOUT;
}
else {
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
Baseball_PlaySound(BASEBALL_SOUND_STRIKE, PLAYSOUNDFLAGS_PRIORITY|PLAYSOUNDFLAGS_ASYNC);
nTimerEndPlayWait = 1500;
fsm = FSM_ENDPLAYWAIT;
}
}
if(nPitchIndex <= 8)
nBallBlip = (bCurveball) ? CURVE_BALL(nPitchIndex) : NORMAL_BALL(nPitchIndex);
}
static void fsmEndPlayWait(int tu)
{
static int delay = 0;
if(delay == 0) {
delay = 1000 * nTimerEndPlayWait;
Baseball_Clock(1);
}
else if(Baseball_Clock(0) >= delay) {
delay = 0;
// reset the runners
ResetOffBaseRunners();
fsm = FSM_IDLE;
}
}
static void fsmRun(int tu)
{
// RUN does not take effect until you release HIT
if (Baseball_GetInputRUN(NULL) && !Baseball_GetInputHIT(NULL)) {
run();
}
if (--nTimerFielding <= 0) {
// ball is finished being fielded
// ball has been fielded - see if any runners are off base
BOOL bOffBase = FALSE;
for (int i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
if ((runners[i].baseindex != FIRSTBASE)
&& (runners[i].baseindex != SECONDBASE)
&& (runners[i].baseindex != THIRDBASE)
&& (runners[i].baseindex != HOMEPLATE)) {
bOffBase = TRUE;
break;
}
}
}
if (bOffBase) {
// somebody is out -- go through the 'out' theatrics
fsm = FSM_GOOUT;
}
else {
// all runners are safe
Baseball_DrawStats(-1, -1, nBalls, nStrikes, bHomeTeam);
nBalls=0;
nStrikes=0;
nTimerEndPlayWait = 1500;
fsm = FSM_ENDPLAYWAIT;
}
}
}
static void fsmWalk(int tu)
{
if (Baseball_GetInputRUN(NULL)) {
if(run() == TRUE) {
// when the current runner gets on first, we're done
if (runners[nCurrentRunnerIndex].baseindex == FIRSTBASE) {
// got someone on first - all done
nStrikes = 0;
nBalls = 0;
nTimerEndPlayWait = 1500;
fsm = FSM_ENDPLAYWAIT;
}
}
}
}
static void fsmHomeRun(int tu)
{
static int loop = 0;
if(fireWorks > 0) {
//
// do fireworks display
//
if(fireWorks == 1)
Baseball_PlaySound(BASEBALL_SOUND_RUN, PLAYSOUNDFLAGS_PRIORITY|PLAYSOUNDFLAGS_ASYNC);
Platform_Pause(40);
fireWorks++;
if(fireWorks > 26) {
loop++;
if(loop == 4) {
loop = 0;
fireWorks = 0;
// insert a runner
InsertRunner();
nTimerRunnerMove = nRunnerSpeed = 2 * SPEED_BASE; // fixed run speed
}
else {
fireWorks = 1;
}
}
return;
}
if (Baseball_GetInputRUN(NULL)) {
if (run() == TRUE) {
// see if anyone is still running the bases
BOOL bManOnBase = FALSE;
for (int i=0; i<MAX_RUNNERS; i++) {
if (runners[i].enabled) {
bManOnBase = TRUE;
break;
}
}
if (!bManOnBase) {
// nobody on base - all done
nStrikes = 0;
nBalls = 0;
fsm = FSM_IDLE;
}
}
}
}
static void fsmEndPossession(int tu)
{
// wait for SCORE key
if (Baseball_GetInputSCORE(NULL)) {
nOuts = 0;
nStrikes = 0;
nBalls = 0;
// remove all runners
for (int i=0; i<MAX_RUNNERS; i++) {
runners[i].enabled = FALSE;
}
Baseball_DrawStats(nInnings+1, nOuts, nBalls, nStrikes, bHomeTeam);
fsm = FSM_IDLE;
}
}
static void fsmGameOver(int tu)
{
Baseball_DrawScore(nVRuns, nHRuns);
}
#define LINE_STEP 20
void Baseball_Debug(int f)
{
int w, h;
int y = 0;
Baseball_GetSize(&w, &h);
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "fsm =%d", fsm);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "pitch i=%d s=%d", nPitchIndex, nPitchSpeed);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "pitch w=%d", nTimerPitchWait/1000);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "curve =%d", bCurveball);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "Play tim =%d", nTimerEndPlayWait);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "Field tim =%d", nTimerFielding);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "Swing =%d", nSwingSlot);
y += LINE_STEP;
debugPrintf(realx(w)+10, realy(y), 0xFFFFFFFF, "Speed =%d", nRunnerSpeed);
y += LINE_STEP;
}
Reference in New Issue View Git Blame Copy Permalink