#include "global.h" #include "overworld.h" #include "field_effect.h" #include "random.h" #include "sound.h" #include "main.h" #include "slot_machine.h" #include "string_util.h" #include "decompress.h" #include "trig.h" #include "graphics.h" #include "palette.h" #include "util.h" #include "text.h" #include "menu.h" #include "malloc.h" #include "bg.h" #include "gpu_regs.h" #include "coins.h" #include "strings.h" #include "tv.h" #include "text_window.h" #include "main_menu.h" #include "bg.h" #include "window.h" #include "constants/coins.h" #include "constants/rgb.h" #include "constants/slot_machine.h" #include "constants/songs.h" #define SLOTMACHINE_GFX_TILES 233 #define MAX_BET 3 #define SYMBOLS_PER_REEL 21 #define REEL_SYMBOL_HEIGHT 24 #define REEL_HEIGHT (SYMBOLS_PER_REEL * REEL_SYMBOL_HEIGHT) #define REELTIME_SYMBOLS 6 #define REELTIME_SYMBOL_HEIGHT 20 #define REELTIME_REEL_HEIGHT (REELTIME_SYMBOLS * REELTIME_SYMBOL_HEIGHT) // There are three categories of biases: 7's, ReelTime, Regular // - 7's: BIAS_STRAIGHT_7, BIAS_MIXED_7 // - ReelTime: BIAS_REELTIME // - Regular: everything else // // The 7's and ReelTime biases can be grouped together as 'Special' biases. // // There can be at most two biases at a time. If there are two, one bias will be // ReelTime and the other will be one of the Regular biases. // // A new bias is drawn every round, except during ReelTime. Bias towards 7's // persists across rounds until you match 7's. All other biases are reset after // the round. #define BIAS_REPLAY (1 << 0) #define BIAS_CHERRY (1 << 1) #define BIAS_LOTAD (1 << 2) #define BIAS_AZURILL (1 << 3) #define BIAS_POWER (1 << 4) #define BIAS_REELTIME (1 << 5) #define BIAS_MIXED_7 (1 << 6) #define BIAS_STRAIGHT_7 (1 << 7) #define BIAS_7 (BIAS_STRAIGHT_7 | BIAS_MIXED_7) #define BIAS_SPECIAL (BIAS_7 | BIAS_REELTIME) #define BIAS_REGULAR (BIAS_REPLAY | BIAS_CHERRY | BIAS_LOATAD | BIAS_AZURILL | BIAS_POWER) // The slot machine will try to manipulate the outcome by adding up to 4 extra // turns to the reel after you press stop. // // The only exception is when it is stopping the third reel and it has decided // you will lose. In this case, it adds as many turns as necessary to prevent a // match. #define MAX_EXTRA_TURNS 4 enum { SYMBOL_7_RED, SYMBOL_7_BLUE, SYMBOL_AZURILL, SYMBOL_LOTAD, SYMBOL_CHERRY, SYMBOL_POWER, SYMBOL_REPLAY, }; enum { GFXTAG_7_RED, GFXTAG_7_BLUE, GFXTAG_AZURILL, GFXTAG_LOTAD, GFXTAG_CHERRY, GFXTAG_POWER, GFXTAG_REPLAY, GFXTAG_NUM_0, GFXTAG_NUM_1, GFXTAG_NUM_2, GFXTAG_NUM_3, GFXTAG_NUM_4, GFXTAG_NUM_5, GFXTAG_NUM_6, GFXTAG_NUM_7, GFXTAG_NUM_8, GFXTAG_NUM_9, GFXTAG_REEL_BG, GFXTAG_STOP, GFXTAG_BONUS, GFXTAG_BIG, GFXTAG_REG, }; #define GFXTAG_SYMBOLS_START (GFXTAG_7_RED) #define GFXTAG_NUMBERS_START (GFXTAG_NUM_0) #define REEL_NORMAL_SPEED 8 #define REEL_HALF_SPEED 4 #define REEL_QUARTER_SPEED 2 enum { PALTAG_REEL, PALTAG_REEL_TIME_PIKACHU, PALTAG_REEL_TIME_MISC, PALTAG_REEL_TIME_MACHINE, PALTAG_MISC, PALTAG_EXPLOSION, PALTAG_DIG_DISPLAY, PALTAG_PIKA_AURA, }; enum { MATCH_CHERRY, // Cherry in center of first reel MATCH_TOPBOT_CHERRY, // Cherry in top/bottom of first reel MATCH_REPLAY, MATCH_LOTAD, MATCH_AZURILL, MATCH_POWER, MATCH_MIXED_7, // First two 7's are same color; last is other color MATCH_RED_7, MATCH_BLUE_7, MATCH_NONE, }; enum { MATCH_MIDDLE_ROW, MATCH_TOP_ROW, MATCH_BOTTOM_ROW, MATCH_NWSE_DIAG, MATCH_NESW_DIAG, NUM_MATCH_LINES, }; enum { LEFT_REEL, MIDDLE_REEL, RIGHT_REEL, NUM_REELS, }; enum { SLOTTASK_UNFADE, SLOTTASK_WAIT_FADE, SLOTTASK_READY_NEW_SPIN, SLOTTASK_READY_NEW_RT_SPIN, SLOTTASK_ASK_INSERT_BET, SLOTTASK_BET_INPUT, SLOTTASK_MSG_NEED_3_COINS, SLOTTASK_WAIT_MSG_NEED_3_COINS, SLOTTASK_WAIT_INFO_BOX, SLOTTASK_START_SPIN, SLOTTASK_START_RT_SPIN, SLOTTASK_RESET_BIAS_FAILURE, SLOTTASK_WAIT_REEL_STOP, SLOTTASK_WAIT_ALL_REELS_STOP, SLOTTASK_CHECK_MATCHES, SLOTTASK_WAIT_PAYOUT, SLOTTASK_END_PAYOUT, SLOTTASK_MATCHED_POWER, SLOTTASK_WAIT_RT_ANIM, SLOTTASK_RESET_BET_TILES, SLOTTASK_NO_MATCHES, SLOTTASK_ASK_QUIT, SLOTTASK_HANDLE_QUIT_INPUT, SLOTTASK_MSG_MAX_COINS, SLOTTASK_WAIT_MSG_MAX_COINS, SLOTTASK_MSG_NO_MORE_COINS, SLOTTASK_WAIT_MSG_NO_MORE_COINS, SLOTTASK_END, SLOTTASK_FREE, }; enum { PAYOUT_TASK_INIT, PAYOUT_TASK_GIVE_PAYOUT, PAYOUT_TASK_FREE, }; enum { REEL_TASK_STILL, REEL_TASK_SPIN, REEL_TASK_DECIDE_STOP, REEL_TASK_STOP_MOVE, REEL_TASK_STOP_SHAKE, }; enum { PIKABOLT_TASK_IDLE, PIKABOLT_TASK_ADD_BOLT, PIKABOLT_TASK_WAIT_ANIM, PIKABOLT_TASK_CLEAR_ALL, }; enum { RT_TASK_INIT, RT_TASK_WINDOW_ENTER, RT_TASK_WAIT_START_PIKA, RT_TASK_PIKA_SPEEDUP1, RT_TASK_PIKA_SPEEDUP2, RT_TASK_WAIT_REEL, RT_TASK_CHECK_EXPLODE, RT_TASK_LAND, RT_TASK_PIKA_REACT, RT_TASK_WAIT_CLEAR_POWER, RT_TASK_CLOSE_WINDOW_SUCCESS, RT_TASK_DESTROY_SPRITES, RT_TASK_SET_REEL_SPEED, RT_TASK_END_SUCCESS, RT_TASK_EXPLODE, RT_TASK_WAIT_EXPLODE, RT_TASK_WAIT_SMOKE, RT_TASK_CLOSE_WINDOW_FAILURE, RT_TASK_END_FAILURE, }; #define DIG_SPRITE_DUMMY {255, 0, 0} // Sprite template IDs for the digital display in the right panel enum { DIG_SPRITE_REEL, DIG_SPRITE_TIME, DIG_SPRITE_INSERT, DIG_SPRITE_WIN, DIG_SPRITE_LOSE, DIG_SPRITE_A_BUTTON, DIG_SPRITE_SMOKE, DIG_SPRITE_NUMBER, DIG_SPRITE_POKE_BALL, DIG_SPRITE_D_PAD, DIG_SPRITE_STOP_S, DIG_SPRITE_STOP_T, DIG_SPRITE_STOP_O, DIG_SPRITE_STOP_P, DIG_SPRITE_BONUS_B, DIG_SPRITE_BONUS_O, DIG_SPRITE_BONUS_N, DIG_SPRITE_BONUS_U, DIG_SPRITE_BONUS_S, DIG_SPRITE_BIG_B, DIG_SPRITE_BIG_I, DIG_SPRITE_BIG_G, DIG_SPRITE_REG_R, DIG_SPRITE_REG_E, DIG_SPRITE_REG_G, DIG_SPRITE_EMPTY, NUM_DIG_DISPLAY_SPRITES }; // IDs used by the digital display to set coords and callbacks for its sprites enum { DIG_DISPINFO_INSERT, DIG_DISPINFO_STOP_S, DIG_DISPINFO_STOP_T, DIG_DISPINFO_STOP_O, DIG_DISPINFO_STOP_P, DIG_DISPINFO_A_BUTTON_STOP, DIG_DISPINFO_POKE_BALL_ROCKING, DIG_DISPINFO_WIN, DIG_DISPINFO_LOSE, DIG_DISPINFO_SMOKE_NW, DIG_DISPINFO_SMOKE_NE, DIG_DISPINFO_SMOKE_SW, DIG_DISPINFO_SMOKE_SE, DIG_DISPINFO_REEL, DIG_DISPINFO_TIME, DIG_DISPINFO_NUMBER, DIG_DISPINFO_DPAD, DIG_DISPINFO_POKE_BALL_SHINING, DIG_DISPINFO_REG_R, DIG_DISPINFO_REG_E, DIG_DISPINFO_REG_G, DIG_DISPINFO_REG_BONUS_B, DIG_DISPINFO_REG_BONUS_O, DIG_DISPINFO_REG_BONUS_N, DIG_DISPINFO_REG_BONUS_U, DIG_DISPINFO_REG_BONUS_S, DIG_DISPINFO_BIG_B, DIG_DISPINFO_BIG_I, DIG_DISPINFO_BIG_G, DIG_DISPINFO_BIG_BONUS_B, DIG_DISPINFO_BIG_BONUS_O, DIG_DISPINFO_BIG_BONUS_N, DIG_DISPINFO_BIG_BONUS_U, DIG_DISPINFO_BIG_BONUS_S, DIG_DISPINFO_A_BUTTON_START }; // IDs for digital display "scenes", i.e. each of the screens it can show made up of sprites enum { DIG_DISPLAY_INSERT_BET, DIG_DISPLAY_STOP_REEL, DIG_DISPLAY_WIN, DIG_DISPLAY_LOSE, DIG_DISPLAY_REEL_TIME, DIG_DISPLAY_BONUS_REG, DIG_DISPLAY_BONUS_BIG }; // How ReelTime works // ================== // Entering ReelTime: // - If the bias you draw at the start of the round is BIAS_REELTIME, the // ReelTime lottery begins. // - At the start of the lottery, the game selects how many ReelTime spins you // will get, based on how many Power bolts you've collected and whether it // is a lucky game. // - The lottery machine rolls until it lands on the selected number. If it // selected 0 spins, the lottery machine will mostly likely explode before // landing on 0. // - If you win: // - You receive the selected number of ReelTime spins // - You lose all the Power bolts you've collected thus far // - The lottery window closes and ReelTime officially begins // // During ReelTime: // - You still have to pay coins for bets. // - The slot reels may spin slower than usual in ReelTime. The machine draws a // reel speed at the beginning of each ReelTime spin. The more coins you've // lost to the machine, and the more consecutive ReelTime spins you've done, // the higher your chances of getting a slower reel speed. // - In ReelTime, the reel stops exactly on your input. That is, it won't add // extra turns to manipulate the outcome. // - ReelTime ends early if you win red 7's or blue 7's. // SlotMachine field explanations: // // luckyGame: // Determined at random when you start playing. Some events modify this: // - Blue 7 match: game becomes lucky // - Red 7 match: game becomes normal // // Effectively, a lucky game inreases the odds of getting more ReelTime spins. // If the game is lucky, you have a slightly higher chance of matching Power // bolts (at the expense of Replays). This helps you fill your Power bolt // gauge faster. // // During ReelTime, the more Power bolts you have, the greater your chances // of drawing more ReelTime spins. In a lucky game, you have greater odds of // drawing high yields (3+ RT spins). You also have greater odds of drawing 0 // RT spins. But drawing 0 lets you keep all your Power bolts, allowing you to // fill your gauge further. struct SlotMachine { /*0x00*/ u8 state; /*0x01*/ u8 machineId; /*0x02*/ u8 pikaPowerBolts; /*0x03*/ bool8 luckyGame; /*0x04*/ u8 machineBias; /*0x05*/ u8 reelTimeDraw; /*0x06*/ bool8 didNotFailBias; /*0x07*/ u8 biasSymbol; /*0x08*/ u16 matches; /*0x0A*/ u8 reelTimeSpinsLeft; /*0x0B*/ u8 reelTimeSpinsUsed; /*0x0C*/ s16 coins; /*0x0E*/ s16 payout; /*0x10*/ s16 netCoinLoss; // never negative /*0x12*/ s16 bet; /*0x14*/ s16 reeltimePixelOffset; /*0x16*/ s16 reeltimePosition; /*0x18*/ s16 currentReel; /*0x1A*/ s16 reelSpeed; /*0x1C*/ s16 reelPixelOffsets[NUM_REELS]; /*0x22*/ u16 reelShockOffsets[NUM_REELS]; /*0x28*/ s16 reelPositions[NUM_REELS]; /*0x2E*/ s16 reelExtraTurns[NUM_REELS]; /*0x34*/ s16 winnerRows[NUM_REELS]; /*0x3A*/ u8 slotReelTasks[NUM_REELS]; /*0x3D*/ u8 digDisplayTaskId; /*0x3E*/ u8 pikaPowerBoltTaskId; /*0x3F*/ u8 reelTimePikachuSpriteId; /*0x40*/ u8 reelTimeNumberGapSpriteId; /*0x41*/ u8 reelTimeExplosionSpriteId; /*0x42*/ u8 reelTimeBrokenMachineSpriteId; /*0x43*/ u8 reelTimeSmokeSpriteId; /*0x44*/ u8 flashMatchLineSpriteIds[NUM_MATCH_LINES]; /*0x49*/ u8 reelTimeMachineSpriteIds[2]; /*0x49*/ u8 reelTimeNumberSpriteIds[3]; /*0x4E*/ u8 reelTimeShadowSpriteIds[2]; /*0x50*/ u8 reelTimeBoltSpriteIds[2]; /*0x52*/ u8 reelTimePikachuAuraSpriteIds[2]; /*0x54*/ u8 reelTimeDuckSpriteIds[4]; /*0x58*/ u16 win0h; /*0x5a*/ u16 win0v; /*0x5c*/ u16 winIn; /*0x5e*/ u16 winOut; /*0x60*/ u16 backupMapMusic; /*0x64*/ MainCallback prevMainCb; }; struct DigitalDisplaySprite { /*0x00*/ u8 spriteTemplateId; /*0x01*/ u8 dispInfoId; /*0x02*/ s16 spriteId; }; static void CB2_SlotMachineSetup(void); static void CB2_SlotMachine(void); static void PlaySlotMachine_Internal(u8, MainCallback); static void SlotMachineDummyTask(u8); static void SlotMachineSetup_InitBgsWindows(void); static void SlotMachineSetup_InitVRAM(void); static void SlotMachineSetup_InitOAM(void); static void SlotMachineSetup_InitGpuRegs(void); static void InitSlotMachine(void); static void SlotMachineSetup_InitPalsSpritesTasks(void); static void SlotMachineSetup_InitTilemaps(void); static void SlotMachineSetup_LoadGfxAndTilemaps(void); static void SlotMachineSetup_InitVBlank(void); static void AllocDigitalDisplayGfx(void); static void SetDigitalDisplayImagePtrs(void); static void CreateSlotMachineSprites(void); static void CreateGameplayTasks(void); static void CreateSlotMachineTasks(void); static void DestroyDigitalDisplayScene(void); static void Task_SlotMachine(u8); static bool8 SlotTask_UnfadeScreen(struct Task *); static bool8 SlotTask_WaitUnfade(struct Task *); static bool8 SlotTask_ReadyNewSpin(struct Task *); static bool8 SlotTask_ReadyNewReelTimeSpin(struct Task *); static bool8 SlotTask_AskInsertBet(struct Task *); static bool8 SlotTask_HandleBetInput(struct Task *); static bool8 SlotTask_PrintMsg_Need3Coins(struct Task *); static bool8 SlotTask_WaitMsg_Need3Coins(struct Task *); static bool8 SlotTask_WaitInfoBox(struct Task *); static bool8 SlotTask_StartSpin(struct Task *); static bool8 SlotTask_StartReelTimeSpin(struct Task *); static bool8 SlotTask_ResetBiasFailure(struct Task *); static bool8 SlotTask_WaitReelStop(struct Task *); static bool8 SlotTask_WaitAllReelsStop(struct Task *); static bool8 SlotTask_CheckMatches(struct Task *); static bool8 SlotTask_WaitPayout(struct Task *); static bool8 SlotTask_EndPayout(struct Task *); static bool8 SlotTask_MatchedPower(struct Task *); static bool8 SlotTask_WaitReelTimeAnim(struct Task *); static bool8 SlotTask_ResetBetTiles(struct Task *); static bool8 SlotTask_NoMatches(struct Task *); static bool8 SlotTask_AskQuit(struct Task *); static bool8 SlotTask_HandleQuitInput(struct Task *); static bool8 SlotTask_PrintMsg_MaxCoins(struct Task *); static bool8 SlotTask_WaitMsg_MaxCoins(struct Task *); static bool8 SlotTask_PrintMsg_NoMoreCoins(struct Task *); static bool8 SlotTask_WaitMsg_NoMoreCoins(struct Task *); static bool8 SlotTask_EndGame(struct Task *); static bool8 SlotTask_FreeDataStructures(struct Task *); static void DrawMachineBias(void); static void ResetBiasFailure(void); static bool8 ShouldTrySpecialBias(void); static u8 TrySelectBias_Special(void); static u16 ReelTimeSpeed(void); static u8 TrySelectBias_Regular(void); static void CheckMatch(void); static void CheckMatch_CenterRow(void); static void CheckMatch_TopAndBottom(void); static void CheckMatch_Diagonals(void); static u8 GetMatchFromSymbols(u8, u8, u8); static void AwardPayout(void); static void Task_Payout(u8); static bool8 IsFinalTask_Task_Payout(void); static bool8 PayoutTask_Init(struct Task *); static bool8 PayoutTask_GivePayout(struct Task *); static bool8 PayoutTask_Free(struct Task *); static u8 GetSymbolAtRest(u8, s16); static void CreateReelTasks(void); static void SpinSlotReel(u8); static void StopSlotReel(u8); static bool8 IsSlotReelMoving(u8); static void Task_Reel(u8); static bool8 ReelTask_StayStill(struct Task *); static bool8 ReelTask_Spin(struct Task *); static bool8 ReelTask_DecideStop(struct Task *); static bool8 ReelTask_MoveToStop(struct Task *); static bool8 ReelTask_ShakingStop(struct Task *); static bool8 DecideStop_Bias_Reel1(void); static bool8 DecideStop_Bias_Reel1_Bet1(u8, u8); static bool8 DecideStop_Bias_Reel1_Bet2or3(u8, u8); static bool8 DecideStop_Bias_Reel2(void); static bool8 DecideStop_Bias_Reel2_Bet1or2(void); static bool8 DecideStop_Bias_Reel2_Bet3(void); static bool8 DecideStop_Bias_Reel3(void); static bool8 DecideStop_Bias_Reel3_Bet1or2(u8); static bool8 DecideStop_Bias_Reel3_Bet3(u8); static void DecideStop_NoBias_Reel1(void); static void DecideStop_NoBias_Reel2(void); static void DecideStop_NoBias_Reel2_Bet1(void); static void DecideStop_NoBias_Reel2_Bet2(void); static void DecideStop_NoBias_Reel2_Bet3(void); static void DecideStop_NoBias_Reel3(void); static void DecideStop_NoBias_Reel3_Bet1(void); static void DecideStop_NoBias_Reel3_Bet2(void); static void DecideStop_NoBias_Reel3_Bet3(void); static void PressStopReelButton(u8); static void Task_PressStopReelButton(u8); static void LightenBetTiles(u8); static void StopReelButton_Press(struct Task *, u8); static void StopReelButton_Wait(struct Task *, u8); static void StopReelButton_Unpress(struct Task *, u8); static void DarkenBetTiles(u8); static void CreateInvisibleFlashMatchLineSprites(void); static void FlashMatchLine(u8); static bool8 IsMatchLineDoneFlashingBeforePayout(void); static bool8 TryStopMatchLinesFlashing(void); static bool8 TryStopMatchLineFlashing(u8); static void SpriteCB_FlashMatchingLines(struct Sprite *); static void FlashSlotMachineLights(void); static bool8 TryStopSlotMachineLights(void); static void Task_FlashSlotMachineLights(u8); static void CreatePikaPowerBoltTask(void); static void AddPikaPowerBolt(u8); static bool8 IsPikaPowerBoltAnimating(void); static void Task_CreatePikaPowerBolt(u8); static void PikaPowerBolt_Idle(struct Task *); static void PikaPowerBolt_AddBolt(struct Task *); static void PikaPowerBolt_WaitAnim(struct Task *); static void PikaPowerBolt_ClearAll(struct Task *); static void ResetPikaPowerBoltTask(struct Task *); static void LoadPikaPowerMeter(u8 ); static void BeginReelTime(void); static bool8 IsReelTimeTaskDone(void); static void Task_ReelTime(u8 ); static void ReelTime_Init(struct Task *); static void ReelTime_WindowEnter(struct Task *); static void ReelTime_WaitStartPikachu(struct Task *); static void ReelTime_PikachuSpeedUp1(struct Task *); static void ReelTime_PikachuSpeedUp2(struct Task *); static void ReelTime_WaitReel(struct Task *); static void ReelTime_CheckExplode(struct Task *); static void ReelTime_LandOnOutcome(struct Task *); static void ReelTime_PikachuReact(struct Task *); static void ReelTime_WaitClearPikaPower(struct Task *); static void ReelTime_CloseWindow(struct Task *); static void ReelTime_DestroySprites(struct Task *); static void ReelTime_SetReelSpeed(struct Task *); static void ReelTime_EndSuccess(struct Task *); static void ReelTime_ExplodeMachine(struct Task *); static void ReelTime_WaitExplode(struct Task *); static void ReelTime_WaitSmoke(struct Task *); static void ReelTime_EndFailure(struct Task *); static void LoadReelTimeWindowTilemap(s16, s16); static void ClearReelTimeWindowTilemap(s16); static void OpenInfoBox(u8); static bool8 IsInfoBoxClosed(void); static void Task_InfoBox(u8 ); static void InfoBox_FadeIn(struct Task *); static void InfoBox_WaitFade(struct Task *); static void InfoBox_DrawWindow(struct Task *); static void InfoBox_WaitInput(struct Task *); static void InfoBox_AddText(struct Task *); static void InfoBox_LoadPikaPowerMeter(struct Task *); static void InfoBox_LoadSlotMachineTilemap(struct Task *); static void InfoBox_CreateDigitalDisplay(struct Task *); static void InfoBox_FreeTask(struct Task *); static void CreateDigitalDisplayTask(void); static void CreateDigitalDisplayScene(u8 ); static bool8 IsDigitalDisplayAnimFinished(void); static void DigitalDisplay_Idle(struct Task *); static void Task_DigitalDisplay(u8); static void CreateReelSymbolSprites(void); static void CreateCreditPayoutNumberSprites(void); static void CreateCoinNumberSprite(s16, s16, u8, s16); static void CreateReelBackgroundSprite(void); static void CreateReelTimePikachuSprite(void); static void DestroyReelTimePikachuSprite(void); static void CreateReelTimeMachineSprites(void); static void CreateBrokenReelTimeMachineSprite(void); static void CreateReelTimeNumberSprites(void); static void CreateReelTimeShadowSprites(void); static void CreateReelTimeNumberGapSprite(void); static void DestroyReelTimeMachineSprites(void); static void DestroyReelTimeShadowSprites(void); static void DestroyBrokenReelTimeMachineSprite(void); static void CreateReelTimeBoltSprites(void); static void SetReelTimeBoltDelay(s16); static void DestroyReelTimeBoltSprites(void); static void CreateReelTimePikachuAuraSprites(void); static void SetReelTimePikachuAuraFlashDelay(s16); static void DestroyReelTimePikachuAuraSprites(void); static void CreateReelTimeExplosionSprite(void); static void DestroyReelTimeExplosionSprite(void); static void CreateReelTimeDuckSprites(void); static void DestroyReelTimeDuckSprites(void); static void CreateReelTimeSmokeSprite(void); static bool8 IsReelTimeSmokeAnimFinished(void); static void DestroyReelTimeSmokeSprite(void); static u8 CreatePikaPowerBoltSprite(s16, s16); static void DestroyPikaPowerBoltSprite(u8); static u8 CreateDigitalDisplaySprite(u8, void (*callback)(struct Sprite *), s16, s16, s16); static void LoadSlotMachineGfx(void); static void LoadReelBackground(void); static void LoadMenuGfx(void); static void LoadMenuAndReelOverlayTilemaps(void); static void SetReelButtonTilemap(s16, u16, u16, u16, u16); static void LoadInfoBoxTilemap(void); static void LoadSlotMachineMenuTilemap(void); static void LoadSlotMachineReelOverlay(void); static u8 CreateStdDigitalDisplaySprite(u8, u8, s16); static void SpriteCB_DigitalDisplay_Static(struct Sprite *); static void SpriteCB_DigitalDisplay_Stop(struct Sprite *); static void SpriteCB_DigitalDisplay_AButtonStop(struct Sprite *); static void SpriteCB_DigitalDisplay_PokeballRocking(struct Sprite *); static void SpriteCB_DigitalDisplay_Smoke(struct Sprite *); static void SpriteCB_DigitalDisplay_SmokeNE(struct Sprite *); static void SpriteCB_DigitalDisplay_SmokeSW(struct Sprite *); static void SpriteCB_DigitalDisplay_SmokeSE(struct Sprite *); static void SpriteCB_DigitalDisplay_Reel(struct Sprite *); static void SpriteCB_DigitalDisplay_Time(struct Sprite *); static void SpriteCB_DigitalDisplay_ReelTimeNumber(struct Sprite *); static void SpriteCB_DigitalDisplay_PokeballShining(struct Sprite *); static void SpriteCB_DigitalDisplay_RegBonus(struct Sprite *); static void SpriteCB_DigitalDisplay_BigBonus(struct Sprite *); static void SpriteCB_DigitalDisplay_AButtonStart(struct Sprite *); static void EndDigitalDisplayScene_InsertBet(void); static void EndDigitalDisplayScene_StopReel(void); static void EndDigitalDisplayScene_Win(void); static void EndDigitalDisplayScene_Dummy(void); static void SpriteCB_ReelSymbol(struct Sprite *); static void SpriteCB_CoinNumber(struct Sprite *); static void SpriteCB_ReelTimePikachu(struct Sprite *); static void SpriteCB_ReelTimeNumbers(struct Sprite *); static void SpriteCB_ReelTimeBolt(struct Sprite *); static void SpriteCB_ReelTimePikachuAura(struct Sprite *); static void SpriteCB_ReelTimeExplosion(struct Sprite *); static void SpriteCB_ReelTimeDuck(struct Sprite *); static void SpriteCB_ReelTimeSmoke(struct Sprite *); static void SpriteCB_PikaPowerBolt(struct Sprite *); // Ewram variables static EWRAM_DATA u16 *sMenuGfx = NULL; static EWRAM_DATA u16 *sSelectedPikaPowerTile = NULL; static EWRAM_DATA u16 *sReelOverlay_Tilemap = NULL; static EWRAM_DATA u8 *sDigitalDisplayGfxPtr = NULL; static EWRAM_DATA u8 *sReelTimeGfxPtr = NULL; static EWRAM_DATA u16 *sReelButtonPress_Tilemap = NULL; static EWRAM_DATA u8 *sReelBackground_Gfx = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_ReelTimePikachu = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_ReelTimeMachineAntennae = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_ReelTimeMachine = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_BrokenReelTimeMachine = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Reel = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Time = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Insert = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Stop = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Win = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Lose = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Bonus = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Big = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Reg = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_AButton = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Smoke = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Number = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_Pokeball = NULL; static EWRAM_DATA struct SpriteFrameImage *sImageTable_DigitalDisplay_DPad = NULL; static EWRAM_DATA struct SpriteSheet *sReelBackgroundSpriteSheet = NULL; static EWRAM_DATA struct SpriteSheet *sSlotMachineSpritesheetsPtr = NULL; static EWRAM_DATA struct SlotMachine *sSlotMachine = NULL; // IWRAM bss static struct SpriteFrameImage *sImageTables_DigitalDisplay[NUM_DIG_DISPLAY_SPRITES]; // Const rom data. static const struct DigitalDisplaySprite *const sDigitalDisplayScenes[]; static const u16 sUnkPalette[]; static const u8 sSpecialDrawOdds[NUM_SLOT_MACHINE_IDS][MAX_BET]; static const u8 sBiasSymbols[]; static const u16 sBiasesSpecial[3]; static const u16 sBiasesRegular[5]; static const s16 sDigitalDisplay_SpriteCoords[][2]; static const SpriteCallback sDigitalDisplay_SpriteCallbacks[]; static const struct SpriteTemplate *const sSpriteTemplates_DigitalDisplay[NUM_DIG_DISPLAY_SPRITES]; static const struct SubspriteTable *const sSubspriteTables_DigitalDisplay[NUM_DIG_DISPLAY_SPRITES]; static const struct SpriteTemplate sSpriteTemplate_PikaPowerBolt; static const struct SpriteTemplate sSpriteTemplate_ReelTimeSmoke; static const struct SpriteTemplate sSpriteTemplate_ReelTimeDuck; static const struct SpriteTemplate sSpriteTemplate_ReelTimeExplosion; static const struct SpriteTemplate sSpriteTemplate_ReelTimePikachuAura; static const u16 sReelTimeExplodeProbability[]; static const u16 *const sPokeballShiningPalTable[]; static const u16 sReelTimeSpeed_Probabilities[][2]; static const u16 sQuarterSpeed_ProbabilityBoost[]; static const u16 sSlotMatchFlags[]; static const u16 sSlotPayouts[]; static const u8 *const sReelBackground_Tilemap; static const u32 sReelTimeGfx[]; static const struct SpriteSheet sSlotMachineSpriteSheets[22]; static const struct SpritePalette sSlotMachineSpritePalettes[]; static const u16 *const sDigitalDisplay_Pal; static const s16 sInitialReelPositions[NUM_REELS][2]; static const u8 sBiasProbabilities_Special[][NUM_SLOT_MACHINE_IDS]; static const u8 sBiasProbabilities_Regular[][NUM_SLOT_MACHINE_IDS]; static const u8 sReelTimeProbabilities_NormalGame[][17]; static const u8 sReelTimeProbabilities_LuckyGame[][17]; static const u8 sSymbolToMatch[]; static const u8 sReelTimeSymbols[]; static const u8 sReelSymbols[NUM_REELS][SYMBOLS_PER_REEL]; static const u16 *const sLitMatchLinePalTable[NUM_MATCH_LINES]; static const u16 *const sDarkMatchLinePalTable[NUM_MATCH_LINES]; static const u8 sMatchLinePalOffsets[NUM_MATCH_LINES]; static const u8 sBetToMatchLineIds[MAX_BET][2]; static const u8 sMatchLinesPerBet[MAX_BET]; static const u16 *const sFlashingLightsPalTable[]; static const u16 *const sSlotMachineMenu_Pal; static const u16 sReelTimeWindow_Tilemap[]; static const u16 sEmptyTilemap[]; static void (*const sDigitalDisplaySceneExitCallbacks[])(void); static const struct SpriteTemplate sSpriteTemplate_ReelTimeBolt; static const struct SpriteTemplate sSpriteTemplate_ReelTimeNumberGap; static const struct SpriteTemplate sSpriteTemplate_ReelTimeShadow; static const struct SpriteTemplate sSpriteTemplate_ReelTimeNumbers; static const struct SpriteTemplate sSpriteTemplate_BrokenReelTimeMachine; static const struct SpriteTemplate sSpriteTemplate_ReelTimeMachineAntennae; static const struct SpriteTemplate sSpriteTemplate_ReelTimeMachine; static const struct SpriteTemplate sSpriteTemplate_ReelBackground; static const struct SpriteTemplate sSpriteTemplate_CoinNumber; static const struct SpriteTemplate sSpriteTemplate_ReelSymbol; static const struct SpriteTemplate sSpriteTemplate_ReelTimePikachu; static const struct SubspriteTable sSubspriteTable_ReelTimeNumberGap[]; static const struct SubspriteTable sSubspriteTable_ReelTimeShadow[]; static const struct SubspriteTable sSubspriteTable_BrokenReelTimeMachine[]; static const struct SubspriteTable sSubspriteTable_ReelTimeMachineAntennae[]; static const struct SubspriteTable sSubspriteTable_ReelTimeMachine[]; static const struct SubspriteTable sSubspriteTable_ReelBackground[]; static const struct BgTemplate sBgTemplates[] = { { .bg = 0, .charBaseIndex = 2, .mapBaseIndex = 31, .screenSize = 0, .paletteMode = 0, .priority = 0, .baseTile = 0 }, { .bg = 1, .charBaseIndex = 1, .mapBaseIndex = 28, .screenSize = 0, .paletteMode = 0, .priority = 1, .baseTile = 0 }, { .bg = 2, .charBaseIndex = 1, .mapBaseIndex = 29, .screenSize = 0, .paletteMode = 0, .priority = 2, .baseTile = 0 }, { .bg = 3, .charBaseIndex = 1, .mapBaseIndex = 30, .screenSize = 0, .paletteMode = 0, .priority = 1, .baseTile = 0 }, }; static const struct WindowTemplate sWindowTemplates[] = { { .bg = 0, .tilemapLeft = 2, .tilemapTop = 15, .width = 27, .height = 4, .paletteNum = 15, .baseBlock = 0x194 }, DUMMY_WIN_TEMPLATE }; static const struct WindowTemplate sWindowTemplate_InfoBox = { .bg = 0, .tilemapLeft = 1, .tilemapTop = 3, .width = 20, .height = 13, .paletteNum = 13, .baseBlock = 1 }; static const u8 sColors_ReeltimeHelp[] = {TEXT_COLOR_LIGHT_GRAY, TEXT_COLOR_WHITE, TEXT_COLOR_DARK_GRAY}; static bool8 (*const sSlotTasks[])(struct Task *task) = { [SLOTTASK_UNFADE] = SlotTask_UnfadeScreen, [SLOTTASK_WAIT_FADE] = SlotTask_WaitUnfade, [SLOTTASK_READY_NEW_SPIN] = SlotTask_ReadyNewSpin, [SLOTTASK_READY_NEW_RT_SPIN] = SlotTask_ReadyNewReelTimeSpin, [SLOTTASK_ASK_INSERT_BET] = SlotTask_AskInsertBet, [SLOTTASK_BET_INPUT] = SlotTask_HandleBetInput, [SLOTTASK_MSG_NEED_3_COINS] = SlotTask_PrintMsg_Need3Coins, [SLOTTASK_WAIT_MSG_NEED_3_COINS] = SlotTask_WaitMsg_Need3Coins, [SLOTTASK_WAIT_INFO_BOX] = SlotTask_WaitInfoBox, [SLOTTASK_START_SPIN] = SlotTask_StartSpin, [SLOTTASK_START_RT_SPIN] = SlotTask_StartReelTimeSpin, [SLOTTASK_RESET_BIAS_FAILURE] = SlotTask_ResetBiasFailure, [SLOTTASK_WAIT_REEL_STOP] = SlotTask_WaitReelStop, [SLOTTASK_WAIT_ALL_REELS_STOP] = SlotTask_WaitAllReelsStop, [SLOTTASK_CHECK_MATCHES] = SlotTask_CheckMatches, [SLOTTASK_WAIT_PAYOUT] = SlotTask_WaitPayout, [SLOTTASK_END_PAYOUT] = SlotTask_EndPayout, [SLOTTASK_MATCHED_POWER] = SlotTask_MatchedPower, [SLOTTASK_WAIT_RT_ANIM] = SlotTask_WaitReelTimeAnim, [SLOTTASK_RESET_BET_TILES] = SlotTask_ResetBetTiles, [SLOTTASK_NO_MATCHES] = SlotTask_NoMatches, [SLOTTASK_ASK_QUIT] = SlotTask_AskQuit, [SLOTTASK_HANDLE_QUIT_INPUT] = SlotTask_HandleQuitInput, [SLOTTASK_MSG_MAX_COINS] = SlotTask_PrintMsg_MaxCoins, [SLOTTASK_WAIT_MSG_MAX_COINS] = SlotTask_WaitMsg_MaxCoins, [SLOTTASK_MSG_NO_MORE_COINS] = SlotTask_PrintMsg_NoMoreCoins, [SLOTTASK_WAIT_MSG_NO_MORE_COINS] = SlotTask_WaitMsg_NoMoreCoins, [SLOTTASK_END] = SlotTask_EndGame, [SLOTTASK_FREE] = SlotTask_FreeDataStructures, }; static bool8 (*const sPayoutTasks[])(struct Task *task) = { [PAYOUT_TASK_INIT] = PayoutTask_Init, [PAYOUT_TASK_GIVE_PAYOUT] = PayoutTask_GivePayout, [PAYOUT_TASK_FREE] = PayoutTask_Free, }; static bool8 (*const sReelTasks[])(struct Task *task) = { [REEL_TASK_STILL] = ReelTask_StayStill, [REEL_TASK_SPIN] = ReelTask_Spin, [REEL_TASK_DECIDE_STOP] = ReelTask_DecideStop, [REEL_TASK_STOP_MOVE] = ReelTask_MoveToStop, [REEL_TASK_STOP_SHAKE] = ReelTask_ShakingStop, }; // Returns true if it is possible to match the bias symbol in the reel. // // Modifies the winnerRows and reelExtraTurns to indicate how to match the bias // symbol. static bool8 (*const sDecideStop_Bias[NUM_REELS])(void) = { DecideStop_Bias_Reel1, DecideStop_Bias_Reel2, DecideStop_Bias_Reel3, }; // The player will always lose (barring a few rare circumstances that were not // accounted for in implementation). // // Modifies the winnerRows and reelExtraTurns to indicate how to make the player // lose. static void (*const sDecideStop_NoBias[NUM_REELS])(void) = { DecideStop_NoBias_Reel1, DecideStop_NoBias_Reel2, DecideStop_NoBias_Reel3, }; // The magnitude of the shock depends on how many extra turns are added. static const u16 sReelStopShocks[] = {2, 4, 4, 4, 8}; static bool8 (*const sDecideStop_Bias_Reel1_Bets[MAX_BET])(u8 sym1, u8 sym2) = { DecideStop_Bias_Reel1_Bet1, DecideStop_Bias_Reel1_Bet2or3, DecideStop_Bias_Reel1_Bet2or3, }; static bool8 (*const sDecideStop_Bias_Reel2_Bets[MAX_BET])(void) = { DecideStop_Bias_Reel2_Bet1or2, DecideStop_Bias_Reel2_Bet1or2, DecideStop_Bias_Reel2_Bet3, }; static bool8 (*const sDecideStop_Bias_Reel3_Bets[MAX_BET])(u8 biasSymbol) = { DecideStop_Bias_Reel3_Bet1or2, DecideStop_Bias_Reel3_Bet1or2, DecideStop_Bias_Reel3_Bet3, }; static void (*const sDecideStop_NoBias_Reel2_Bets[MAX_BET])(void) = { DecideStop_NoBias_Reel2_Bet1, DecideStop_NoBias_Reel2_Bet2, DecideStop_NoBias_Reel2_Bet3, }; static void (*const sDecideStop_NoBias_Reel3_Bets[MAX_BET])(void) = { DecideStop_NoBias_Reel3_Bet1, DecideStop_NoBias_Reel3_Bet2, DecideStop_NoBias_Reel3_Bet3, }; static void (*const sReelStopButtonTasks[])(struct Task *task, u8 taskId) = { StopReelButton_Press, StopReelButton_Wait, StopReelButton_Unpress, }; static const s16 sReelButtonOffsets[NUM_REELS] = {5, 10, 15}; static void (*const sPikaPowerBoltTasks[])(struct Task *task) = { PikaPowerBolt_Idle, PikaPowerBolt_AddBolt, PikaPowerBolt_WaitAnim, PikaPowerBolt_ClearAll, }; static const u16 sPikaPowerTileTable[][2] = { {0x9e, 0x6e}, {0x9f, 0x6f}, {0xaf, 0x7f}, }; static void (*const sReelTimeTasks[])(struct Task *task) = { [RT_TASK_INIT] = ReelTime_Init, [RT_TASK_WINDOW_ENTER] = ReelTime_WindowEnter, [RT_TASK_WAIT_START_PIKA] = ReelTime_WaitStartPikachu, [RT_TASK_PIKA_SPEEDUP1] = ReelTime_PikachuSpeedUp1, [RT_TASK_PIKA_SPEEDUP2] = ReelTime_PikachuSpeedUp2, [RT_TASK_WAIT_REEL] = ReelTime_WaitReel, [RT_TASK_CHECK_EXPLODE] = ReelTime_CheckExplode, [RT_TASK_LAND] = ReelTime_LandOnOutcome, [RT_TASK_PIKA_REACT] = ReelTime_PikachuReact, [RT_TASK_WAIT_CLEAR_POWER] = ReelTime_WaitClearPikaPower, [RT_TASK_CLOSE_WINDOW_SUCCESS] = ReelTime_CloseWindow, [RT_TASK_DESTROY_SPRITES] = ReelTime_DestroySprites, [RT_TASK_SET_REEL_SPEED] = ReelTime_SetReelSpeed, [RT_TASK_END_SUCCESS] = ReelTime_EndSuccess, [RT_TASK_EXPLODE] = ReelTime_ExplodeMachine, [RT_TASK_WAIT_EXPLODE] = ReelTime_WaitExplode, [RT_TASK_WAIT_SMOKE] = ReelTime_WaitSmoke, [RT_TASK_CLOSE_WINDOW_FAILURE] = ReelTime_CloseWindow, [RT_TASK_END_FAILURE] = ReelTime_EndFailure, }; static const u8 sReelTimePikachuAnimIds[] = {1, 1, 2, 2}; static const s16 sReelTimeBoltDelays[] = {64, 48, 24, 8}; static const s16 sPikachuAuraFlashDelays[] = {10, 8, 6, 4}; static void (*const sInfoBoxTasks[])(struct Task *task) = { // Go to Info screen InfoBox_FadeIn, InfoBox_WaitFade, InfoBox_DrawWindow, InfoBox_WaitFade, InfoBox_AddText, InfoBox_WaitFade, // On Info screen InfoBox_WaitInput, // Exit Info screen InfoBox_WaitFade, InfoBox_LoadSlotMachineTilemap, InfoBox_WaitFade, InfoBox_CreateDigitalDisplay, InfoBox_WaitFade, InfoBox_LoadPikaPowerMeter, InfoBox_WaitFade, InfoBox_FreeTask, }; // Just idles, digital display is handled by CreateDigitalDisplayScene and sprite callbacks static void (*const sDigitalDisplayTasks[])(struct Task *task) = { DigitalDisplay_Idle, }; #define tState data[0] static void Task_FadeToSlotMachine(u8 taskId) { switch (gTasks[taskId].tState) { case 0: BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 0x10, RGB_BLACK); gTasks[taskId].tState++; break; case 1: if (!gPaletteFade.active) { SetMainCallback2(CB2_SlotMachineSetup); DestroyTask(taskId); } break; } } void PlaySlotMachine(u8 machineId, MainCallback exitCallback) { u8 taskId; sSlotMachine = AllocZeroed(sizeof(*sSlotMachine)); PlaySlotMachine_Internal(machineId, exitCallback); taskId = CreateTask(Task_FadeToSlotMachine, 0); gTasks[taskId].tState = 0; } #undef tState static void CB2_SlotMachineSetup(void) { switch (gMain.state) { case 0: SlotMachineSetup_InitBgsWindows(); InitSlotMachine(); gMain.state++; break; case 1: SlotMachineSetup_InitVRAM(); gMain.state++; break; case 2: SlotMachineSetup_InitOAM(); SlotMachineSetup_InitGpuRegs(); gMain.state++; break; case 3: SlotMachineSetup_InitPalsSpritesTasks(); gMain.state++; break; case 4: SlotMachineSetup_InitTilemaps(); gMain.state++; break; case 5: SlotMachineSetup_LoadGfxAndTilemaps(); gMain.state++; break; case 6: SlotMachineSetup_InitVBlank(); gMain.state++; break; case 7: BeginNormalPaletteFade(-1, 0, 0x10, 0, RGB_BLACK); ShowBg(0); ShowBg(1); ShowBg(2); ShowBg(3); gMain.state++; break; case 8: AllocDigitalDisplayGfx(); gMain.state++; break; case 9: SetDigitalDisplayImagePtrs(); gMain.state++; break; case 10: CreateSlotMachineSprites(); CreateGameplayTasks(); gMain.state++; break; case 11: SetMainCallback2(CB2_SlotMachine); break; } } static void CB2_SlotMachine(void) { RunTasks(); AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); } static void SlotMachine_VBlankCB(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); SetGpuReg(REG_OFFSET_WIN0H, sSlotMachine->win0h); SetGpuReg(REG_OFFSET_WIN0V, sSlotMachine->win0v); SetGpuReg(REG_OFFSET_WININ, sSlotMachine->winIn); SetGpuReg(REG_OFFSET_WINOUT, sSlotMachine->winOut); } #define tMachineId data[0] #define tExitCallback data[1] static void PlaySlotMachine_Internal(u8 machineId, MainCallback exitCallback) { struct Task *task = &gTasks[CreateTask(SlotMachineDummyTask, 0xFF)]; task->tMachineId = machineId; StoreWordInTwoHalfwords(&task->tExitCallback, (intptr_t)exitCallback); } // Extracts and assigns machineId and exit callback from task. static void SlotMachine_InitFromTask(void) { struct Task *task = &gTasks[FindTaskIdByFunc(SlotMachineDummyTask)]; sSlotMachine->machineId = task->tMachineId; LoadWordFromTwoHalfwords((u16 *)&task->tExitCallback, (u32 *)&sSlotMachine->prevMainCb); } static void SlotMachineDummyTask(u8 taskId) { } #undef tMachineId #undef tExitCallback static void SlotMachineSetup_InitBgsWindows(void) { SetVBlankCallback(NULL); SetHBlankCallback(NULL); CpuFill32(0, (void *)VRAM, VRAM_SIZE); ResetBgsAndClearDma3BusyFlags(0); InitBgsFromTemplates(0, sBgTemplates, ARRAY_COUNT(sBgTemplates)); InitWindows(sWindowTemplates); DeactivateAllTextPrinters(); } static void SlotMachineSetup_InitVBlank(void) { SetVBlankCallback(SlotMachine_VBlankCB); EnableInterrupts(INTR_FLAG_VBLANK); SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON); } static void SlotMachineSetup_InitVRAM(void) { DmaClearLarge16(3, (u16 *)(BG_VRAM), BG_VRAM_SIZE, 0x1000); } static void SlotMachineSetup_InitOAM(void) { DmaClear16(3, (u16 *)OAM, OAM_SIZE); } static void SlotMachineSetup_InitGpuRegs(void) { SetGpuReg(REG_OFFSET_BG0CNT, 0); SetGpuReg(REG_OFFSET_BG1CNT, 0); SetGpuReg(REG_OFFSET_BG2CNT, 0); SetGpuReg(REG_OFFSET_BG3CNT, 0); SetGpuReg(REG_OFFSET_BG0HOFS, 0); SetGpuReg(REG_OFFSET_BG0VOFS, 0); SetGpuReg(REG_OFFSET_BG1HOFS, 0); SetGpuReg(REG_OFFSET_BG1VOFS, 0); SetGpuReg(REG_OFFSET_BG2HOFS, 0); SetGpuReg(REG_OFFSET_BG2VOFS, 0); SetGpuReg(REG_OFFSET_BG3HOFS, 0); SetGpuReg(REG_OFFSET_BG3VOFS, 0); SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR); SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR); SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_OBJ); SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(9, 8)); } // Set up initial state of slot machine static void InitSlotMachine(void) { u8 i; SlotMachine_InitFromTask(); sSlotMachine->state = SLOTTASK_UNFADE; sSlotMachine->pikaPowerBolts = 0; sSlotMachine->luckyGame = Random() & 1; sSlotMachine->machineBias = 0; sSlotMachine->matches = 0; sSlotMachine->reelTimeSpinsLeft = 0; sSlotMachine->reelTimeSpinsUsed = 0; sSlotMachine->coins = GetCoins(); sSlotMachine->payout = 0; sSlotMachine->netCoinLoss = 0; sSlotMachine->bet = 0; sSlotMachine->currentReel = LEFT_REEL; sSlotMachine->reelSpeed = REEL_NORMAL_SPEED; sSlotMachine->win0h = DISPLAY_WIDTH; sSlotMachine->win0v = DISPLAY_HEIGHT; sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR; sSlotMachine->winOut = WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR; sSlotMachine->backupMapMusic = GetCurrentMapMusic(); for (i = 0; i < NUM_REELS; i++) { sSlotMachine->reelShockOffsets[i] = 0; sSlotMachine->reelPositions[i] = sInitialReelPositions[i][sSlotMachine->luckyGame] % SYMBOLS_PER_REEL; sSlotMachine->reelPixelOffsets[i] = REEL_HEIGHT - sSlotMachine->reelPositions[i] * REEL_SYMBOL_HEIGHT; sSlotMachine->reelPixelOffsets[i] %= REEL_HEIGHT; } AlertTVThatPlayerPlayedSlotMachine(GetCoins()); } static void SlotMachineSetup_InitPalsSpritesTasks(void) { ResetPaletteFade(); ResetSpriteData(); gOamLimit = 0x80; FreeAllSpritePalettes(); ResetTasks(); } static void SlotMachineSetup_InitTilemaps(void) { sSelectedPikaPowerTile = Alloc(8); sReelOverlay_Tilemap = AllocZeroed(14); sReelButtonPress_Tilemap = AllocZeroed(8); // several of these are 1 bit off from each other sReelOverlay_Tilemap[0] = 0x2051; sReelOverlay_Tilemap[1] = 0x2851; sReelOverlay_Tilemap[2] = 0x2061; sReelOverlay_Tilemap[3] = 0x2861; sReelOverlay_Tilemap[4] = 0x20BE; sReelOverlay_Tilemap[5] = 0x28BE; sReelOverlay_Tilemap[6] = 0x20BF; } static void SlotMachineSetup_LoadGfxAndTilemaps(void) { LoadMenuGfx(); LoadMenuAndReelOverlayTilemaps(); LoadSlotMachineGfx(); LoadMessageBoxGfx(0, 0x200, BG_PLTT_ID(15)); LoadUserWindowBorderGfx(0, 0x214, BG_PLTT_ID(14)); PutWindowTilemap(0); } static void CreateSlotMachineSprites(void) { CreateReelSymbolSprites(); CreateCreditPayoutNumberSprites(); CreateInvisibleFlashMatchLineSprites(); CreateReelBackgroundSprite(); } static void CreateGameplayTasks(void) { CreatePikaPowerBoltTask(); CreateReelTasks(); CreateDigitalDisplayTask(); CreateSlotMachineTasks(); } static void CreateSlotMachineTasks(void) { Task_SlotMachine(CreateTask(Task_SlotMachine, 0)); } static void Task_SlotMachine(u8 taskId) { while (sSlotTasks[sSlotMachine->state](&gTasks[taskId])) ; } #define tTimer data[0] #define tTimer2 data[1] // SLOTTASK_UNFADE static bool8 SlotTask_UnfadeScreen(struct Task *task) { BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB(0, 0, 0)); LoadPikaPowerMeter(sSlotMachine->pikaPowerBolts); sSlotMachine->state++; // SLOTTASK_WAIT_FADE return FALSE; } // SLOTTASK_WAIT_FADE static bool8 SlotTask_WaitUnfade(struct Task *task) { if (!gPaletteFade.active) sSlotMachine->state++; return FALSE; } // SLOTTASK_READY_NEW_SPIN static bool8 SlotTask_ReadyNewSpin(struct Task *task) { sSlotMachine->payout = 0; sSlotMachine->bet = 0; sSlotMachine->currentReel = LEFT_REEL; sSlotMachine->machineBias &= (BIAS_STRAIGHT_7 | BIAS_MIXED_7); sSlotMachine->state = SLOTTASK_ASK_INSERT_BET; if (sSlotMachine->coins <= 0) { sSlotMachine->state = SLOTTASK_MSG_NO_MORE_COINS; } else if (sSlotMachine->reelTimeSpinsLeft) { sSlotMachine->state = SLOTTASK_READY_NEW_RT_SPIN; CreateDigitalDisplayScene(DIG_DISPLAY_REEL_TIME); } return TRUE; } // SLOTTASK_READY_NEW_RT_SPIN static bool8 SlotTask_ReadyNewReelTimeSpin(struct Task *task) { if (IsDigitalDisplayAnimFinished()) sSlotMachine->state = SLOTTASK_ASK_INSERT_BET; return FALSE; } // SLOTTASK_ASK_INSERT_BET static bool8 SlotTask_AskInsertBet(struct Task *task) { CreateDigitalDisplayScene(DIG_DISPLAY_INSERT_BET); sSlotMachine->state = SLOTTASK_BET_INPUT; if (sSlotMachine->coins >= MAX_COINS) sSlotMachine->state = SLOTTASK_MSG_MAX_COINS; return TRUE; } // SLOTTASK_BET_INPUT static bool8 SlotTask_HandleBetInput(struct Task *task) { s16 i; if (JOY_NEW(SELECT_BUTTON)) { OpenInfoBox(DIG_DISPLAY_INSERT_BET); sSlotMachine->state = SLOTTASK_WAIT_INFO_BOX; } // Try to bet the max amount else if (JOY_NEW(R_BUTTON)) { if (sSlotMachine->coins - (MAX_BET - sSlotMachine->bet) >= 0) { for (i = sSlotMachine->bet; i < MAX_BET; i++) LightenBetTiles(i); sSlotMachine->coins -= (MAX_BET - sSlotMachine->bet); sSlotMachine->bet = MAX_BET; sSlotMachine->state = SLOTTASK_START_SPIN; PlaySE(SE_SHOP); } // Not enough coins else { sSlotMachine->state = SLOTTASK_MSG_NEED_3_COINS; } } else { // Increase bet if (JOY_NEW(DPAD_DOWN) && sSlotMachine->coins != 0) { PlaySE(SE_SHOP); LightenBetTiles(sSlotMachine->bet); sSlotMachine->coins--; sSlotMachine->bet++; } // Maxed bet or finished betting if (sSlotMachine->bet >= MAX_BET || (sSlotMachine->bet != 0 && JOY_NEW(A_BUTTON))) sSlotMachine->state = SLOTTASK_START_SPIN; // Quit prompt if (JOY_NEW(B_BUTTON)) sSlotMachine->state = SLOTTASK_ASK_QUIT; } return FALSE; } // SLOTTASK_MSG_NEED_3_COINS static bool8 SlotTask_PrintMsg_Need3Coins(struct Task *task) { DrawDialogueFrame(0, FALSE); AddTextPrinterParameterized(0, FONT_NORMAL, gText_YouDontHaveThreeCoins, 0, 1, 0, 0); CopyWindowToVram(0, COPYWIN_FULL); sSlotMachine->state = SLOTTASK_WAIT_MSG_NEED_3_COINS; return FALSE; } // SLOTTASK_WAIT_MSG_NEED_3_COINS static bool8 SlotTask_WaitMsg_Need3Coins(struct Task *task) { if (JOY_NEW(A_BUTTON | B_BUTTON)) { ClearDialogWindowAndFrame(0, TRUE); sSlotMachine->state = SLOTTASK_BET_INPUT; } return FALSE; } // SLOTTASK_WAIT_INFO_BOX static bool8 SlotTask_WaitInfoBox(struct Task *task) { if (IsInfoBoxClosed()) sSlotMachine->state = SLOTTASK_BET_INPUT; return FALSE; } // SLOTTASK_START_SPIN static bool8 SlotTask_StartSpin(struct Task *task) { DrawMachineBias(); DestroyDigitalDisplayScene(); SpinSlotReel(LEFT_REEL); SpinSlotReel(MIDDLE_REEL); SpinSlotReel(RIGHT_REEL); IncrementDailySlotsUses(); task->tTimer = 0; if (sSlotMachine->machineBias & BIAS_REELTIME) { BeginReelTime(); sSlotMachine->state = SLOTTASK_START_RT_SPIN; } else { CreateDigitalDisplayScene(DIG_DISPLAY_STOP_REEL); sSlotMachine->state = SLOTTASK_RESET_BIAS_FAILURE; } sSlotMachine->reelSpeed = REEL_NORMAL_SPEED; if (sSlotMachine->reelTimeSpinsLeft) sSlotMachine->reelSpeed = ReelTimeSpeed(); return FALSE; } // SLOTTASK_START_RT_SPIN static bool8 SlotTask_StartReelTimeSpin(struct Task *task) { if (IsReelTimeTaskDone()) { CreateDigitalDisplayScene(DIG_DISPLAY_STOP_REEL); sSlotMachine->machineBias &= ~BIAS_REELTIME; sSlotMachine->state = SLOTTASK_RESET_BIAS_FAILURE; } return FALSE; } // SLOTTASK_RESET_BIAS_FAILURE static bool8 SlotTask_ResetBiasFailure(struct Task *task) { if (++task->tTimer >= 30) { ResetBiasFailure(); sSlotMachine->state = SLOTTASK_WAIT_REEL_STOP; } return FALSE; } // SLOTTASK_WAIT_REEL_STOP static bool8 SlotTask_WaitReelStop(struct Task *task) { if (JOY_NEW(A_BUTTON)) { PlaySE(SE_CONTEST_PLACE); StopSlotReel(sSlotMachine->currentReel); PressStopReelButton(sSlotMachine->currentReel); sSlotMachine->state = SLOTTASK_WAIT_ALL_REELS_STOP; } return FALSE; } // SLOTTASK_WAIT_ALL_REELS_STOP static bool8 SlotTask_WaitAllReelsStop(struct Task *task) { if (!IsSlotReelMoving(sSlotMachine->currentReel)) { sSlotMachine->currentReel++; sSlotMachine->state = SLOTTASK_WAIT_REEL_STOP; if (sSlotMachine->currentReel >= NUM_REELS) { sSlotMachine->state = SLOTTASK_CHECK_MATCHES; } return TRUE; } return FALSE; } // SLOTTASK_CHECK_MATCHES static bool8 SlotTask_CheckMatches(struct Task *task) { sSlotMachine->machineBias &= (BIAS_STRAIGHT_7 | BIAS_MIXED_7); CheckMatch(); if (sSlotMachine->reelTimeSpinsLeft) { sSlotMachine->reelTimeSpinsLeft--; sSlotMachine->reelTimeSpinsUsed++; } if (sSlotMachine->matches) { sSlotMachine->state = SLOTTASK_WAIT_PAYOUT; AwardPayout(); FlashSlotMachineLights(); if ((sSlotMachine->netCoinLoss -= sSlotMachine->payout) < 0) { sSlotMachine->netCoinLoss = 0; } if (sSlotMachine->matches & ((1 << MATCH_BLUE_7) | (1 << MATCH_RED_7))) { PlayFanfare(MUS_SLOTS_JACKPOT); CreateDigitalDisplayScene(DIG_DISPLAY_BONUS_BIG); } else if (sSlotMachine->matches & (1 << MATCH_MIXED_7)) { PlayFanfare(MUS_SLOTS_JACKPOT); CreateDigitalDisplayScene(DIG_DISPLAY_BONUS_REG); } else { PlayFanfare(MUS_SLOTS_WIN); CreateDigitalDisplayScene(DIG_DISPLAY_WIN); } if (sSlotMachine->matches & ((1 << MATCH_MIXED_7) | (1 << MATCH_BLUE_7) | (1 << MATCH_RED_7))) { sSlotMachine->machineBias &= ~(BIAS_STRAIGHT_7 | BIAS_MIXED_7); if (sSlotMachine->matches & ((1 << MATCH_BLUE_7) | (1 << MATCH_RED_7))) { // ReelTime ends if it was ongoing sSlotMachine->reelTimeSpinsLeft = 0; sSlotMachine->reelTimeSpinsUsed = 0; sSlotMachine->luckyGame = FALSE; if (sSlotMachine->matches & (1 << MATCH_BLUE_7)) sSlotMachine->luckyGame = TRUE; } } if (sSlotMachine->matches & (1 << MATCH_POWER) && sSlotMachine->pikaPowerBolts < 16) { sSlotMachine->pikaPowerBolts++; AddPikaPowerBolt(sSlotMachine->pikaPowerBolts); } } else { CreateDigitalDisplayScene(DIG_DISPLAY_LOSE); sSlotMachine->state = SLOTTASK_NO_MATCHES; if ((sSlotMachine->netCoinLoss += sSlotMachine->bet) > MAX_COINS) sSlotMachine->netCoinLoss = MAX_COINS; } return FALSE; } // SLOTTASK_WAIT_PAYOUT static bool8 SlotTask_WaitPayout(struct Task *task) { if (IsFinalTask_Task_Payout()) sSlotMachine->state = SLOTTASK_END_PAYOUT; return FALSE; } // SLOTTASK_END_PAYOUT static bool8 SlotTask_EndPayout(struct Task *task) { if (TryStopSlotMachineLights()) { sSlotMachine->state = SLOTTASK_RESET_BET_TILES; if (sSlotMachine->matches & ((1 << MATCH_RED_7) | (1 << MATCH_BLUE_7))) IncrementGameStat(GAME_STAT_SLOT_JACKPOTS); if (sSlotMachine->matches & (1 << MATCH_REPLAY)) { sSlotMachine->currentReel = LEFT_REEL; sSlotMachine->state = SLOTTASK_START_SPIN; } if (sSlotMachine->matches & (1 << MATCH_POWER)) sSlotMachine->state = SLOTTASK_MATCHED_POWER; if (sSlotMachine->reelTimeSpinsLeft && sSlotMachine->matches & (1 << MATCH_REPLAY)) { CreateDigitalDisplayScene(DIG_DISPLAY_REEL_TIME); sSlotMachine->state = SLOTTASK_WAIT_RT_ANIM; } } return FALSE; } // SLOTTASK_MATCHED_POWER static bool8 SlotTask_MatchedPower(struct Task *task) { if (!IsPikaPowerBoltAnimating()) { sSlotMachine->state = SLOTTASK_RESET_BET_TILES; if (sSlotMachine->matches & (1 << MATCH_REPLAY)) { sSlotMachine->state = SLOTTASK_START_SPIN; if (sSlotMachine->reelTimeSpinsLeft) { CreateDigitalDisplayScene(DIG_DISPLAY_REEL_TIME); sSlotMachine->state = SLOTTASK_WAIT_RT_ANIM; } } } return FALSE; } // SLOTTASK_WAIT_RT_ANIM static bool8 SlotTask_WaitReelTimeAnim(struct Task *task) { if (IsDigitalDisplayAnimFinished()) { sSlotMachine->state = SLOTTASK_RESET_BET_TILES; if (sSlotMachine->matches & (1 << MATCH_REPLAY)) { sSlotMachine->state = SLOTTASK_START_SPIN; } } return FALSE; } // SLOTTASK_RESET_BET_TILES static bool8 SlotTask_ResetBetTiles(struct Task *task) { DarkenBetTiles(0); DarkenBetTiles(1); DarkenBetTiles(2); sSlotMachine->state = SLOTTASK_READY_NEW_SPIN; return FALSE; } // SLOTTASK_NO_MATCHES static bool8 SlotTask_NoMatches(struct Task *task) { if (++task->tTimer2 > 64) { task->tTimer2 = 0; sSlotMachine->state = SLOTTASK_RESET_BET_TILES; } return FALSE; } // SLOTTASK_ASK_QUIT static bool8 SlotTask_AskQuit(struct Task *task) { DrawDialogueFrame(0, FALSE); AddTextPrinterParameterized(0, FONT_NORMAL, gText_QuitTheGame, 0, 1, 0, 0); CopyWindowToVram(0, COPYWIN_FULL); CreateYesNoMenuParameterized(0x15, 7, 0x214, 0x180, 0xE, 0xF); sSlotMachine->state = SLOTTASK_HANDLE_QUIT_INPUT; return FALSE; } // SLOTTASK_HANDLE_QUIT_INPUT static bool8 SlotTask_HandleQuitInput(struct Task *task) { s8 input = Menu_ProcessInputNoWrapClearOnChoose(); if (input == 0) // Chose to quit { ClearDialogWindowAndFrame(0, TRUE); DarkenBetTiles(0); DarkenBetTiles(1); DarkenBetTiles(2); sSlotMachine->coins += sSlotMachine->bet; sSlotMachine->state = SLOTTASK_END; } else if (input == 1 || input == -1) // Chose not to quit { ClearDialogWindowAndFrame(0, TRUE); sSlotMachine->state = SLOTTASK_BET_INPUT; } return FALSE; } // SLOTTASK_MSG_MAX_COINS static bool8 SlotTask_PrintMsg_MaxCoins(struct Task *task) { DrawDialogueFrame(0, FALSE); AddTextPrinterParameterized(0, FONT_NORMAL, gText_YouveGot9999Coins, 0, 1, 0, 0); CopyWindowToVram(0, COPYWIN_FULL); sSlotMachine->state = SLOTTASK_WAIT_MSG_MAX_COINS; return FALSE; } // SLOTTASK_WAIT_MSG_MAX_COINS static bool8 SlotTask_WaitMsg_MaxCoins(struct Task *task) { if (JOY_NEW(A_BUTTON | B_BUTTON)) { ClearDialogWindowAndFrame(0, TRUE); sSlotMachine->state = SLOTTASK_BET_INPUT; } return FALSE; } // SLOTTASK_MSG_NO_MORE_COINS static bool8 SlotTask_PrintMsg_NoMoreCoins(struct Task *task) { DrawDialogueFrame(0, FALSE); AddTextPrinterParameterized(0, FONT_NORMAL, gText_YouveRunOutOfCoins, 0, 1, 0, 0); CopyWindowToVram(0, COPYWIN_FULL); sSlotMachine->state = SLOTTASK_WAIT_MSG_NO_MORE_COINS; return FALSE; } // SLOTTASK_WAIT_MSG_NO_MORE_COINS static bool8 SlotTask_WaitMsg_NoMoreCoins(struct Task *task) { if (JOY_NEW(A_BUTTON | B_BUTTON)) { ClearDialogWindowAndFrame(0, TRUE); sSlotMachine->state = SLOTTASK_END; } return FALSE; } // SLOTTASK_END static bool8 SlotTask_EndGame(struct Task *task) { SetCoins(sSlotMachine->coins); TryPutFindThatGamerOnAir(GetCoins()); BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB(0, 0, 0)); sSlotMachine->state++; // SLOTTASK_FREE return FALSE; } // SLOTTASK_FREE static bool8 SlotTask_FreeDataStructures(struct Task *task) { if (!gPaletteFade.active) { SetMainCallback2(sSlotMachine->prevMainCb); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Reel); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Time); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Insert); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Stop); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Win); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Lose); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Bonus); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Big); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Reg); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_AButton); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Smoke); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Number); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_Pokeball); FREE_AND_SET_NULL(sImageTable_DigitalDisplay_DPad); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimePikachu); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimeMachineAntennae); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimeMachine); TRY_FREE_AND_SET_NULL(sImageTable_BrokenReelTimeMachine); FREE_AND_SET_NULL(sMenuGfx); FREE_AND_SET_NULL(sSelectedPikaPowerTile); FREE_AND_SET_NULL(sReelOverlay_Tilemap); FREE_AND_SET_NULL(sDigitalDisplayGfxPtr); FREE_AND_SET_NULL(sReelTimeGfxPtr); FREE_AND_SET_NULL(sReelButtonPress_Tilemap); FREE_AND_SET_NULL(sReelBackground_Gfx); FREE_AND_SET_NULL(sReelBackgroundSpriteSheet); FREE_AND_SET_NULL(sSlotMachineSpritesheetsPtr); FREE_AND_SET_NULL(sSlotMachine); } return FALSE; } # undef tTimer # undef tTimer2 // Determine the biases for this round. There can be at most two biases, one of // which would need to be a ReelTime bias. // // HOW IT WORKS: // If the machine is already biased toward 7's, keep this bias. // // Otherwise, there are up to three draws. You first draw to see if you'll get // to draw a Special bias. If so, then you draw for the Special bias (and can // still potentially miss). // // If you didn't get to draw a Special bias, missed a Special bias, or drew a // ReelTime bias, then you can still try to draw a Regular bias. static void DrawMachineBias(void) { u8 whichBias; if (sSlotMachine->reelTimeSpinsLeft == 0) { if (!(sSlotMachine->machineBias & (BIAS_STRAIGHT_7 | BIAS_MIXED_7))) { if (ShouldTrySpecialBias()) { whichBias = TrySelectBias_Special(); if (whichBias != ARRAY_COUNT(sBiasesSpecial)) // A bias was selected { sSlotMachine->machineBias |= sBiasesSpecial[whichBias]; // ReelTime was not selected; don't add other biases if (whichBias != 1) return; } } whichBias = TrySelectBias_Regular(); if (whichBias != ARRAY_COUNT(sBiasesRegular)) // A bias was selected sSlotMachine->machineBias |= sBiasesRegular[whichBias]; } } } // Reset `didNotFailBias` to match `machineBias`. static void ResetBiasFailure(void) { sSlotMachine->didNotFailBias = FALSE; if (sSlotMachine->machineBias) sSlotMachine->didNotFailBias = TRUE; } // See sBiasSymbols for each bias's corresponding symbol. static u8 GetBiasSymbol(u8 machineBias) { u8 i; for (i = 0; i < 8; i++) { if (machineBias & 1) return sBiasSymbols[i]; machineBias >>= 1; } return 0; } // Decides whether you will be given the opportunity to draw for a Special bias. // Depends on your bet and the machine you're using. // // The probability of getting to draw a Special is miniscule if you don't bet 3 // coins: barely 1% even on the luckiest machine. // // The odds increase to roughly ~5% if you bet 3 coins. static bool8 ShouldTrySpecialBias(void) { u8 rval = Random(); if (sSpecialDrawOdds[sSlotMachine->machineId][sSlotMachine->bet - 1] > rval) return TRUE; return FALSE; } // Draws for a Special bias. Note that even when you're given the opportunity to // draw a Special bias, you can still miss. // // On the luckiest machine, there's a 61% chance of drawing no Special bias. On // the unluckiest, a 73% chance. static u8 TrySelectBias_Special(void) { s16 whichBias; for (whichBias = 0; whichBias < (int)ARRAY_COUNT(sBiasesSpecial); whichBias++) { s16 rval = Random() & 0xff; s16 value = sBiasProbabilities_Special[whichBias][sSlotMachine->machineId]; if (value > rval) break; } return whichBias; } static u8 TrySelectBias_Regular(void) { s16 whichBias; for (whichBias = 0; whichBias < (int)ARRAY_COUNT(sBiasesRegular); whichBias++) { s16 rval = Random() & 0xff; s16 value = sBiasProbabilities_Regular[whichBias][sSlotMachine->machineId]; // Boost odds of BIAS_POWER if it's a lucky game. if (whichBias == 0 && sSlotMachine->luckyGame == TRUE) { value += 10; if (value > 0x100) value = 0x100; } // Reduce odds of BIAS_REPLAY if it's a lucky game else if (whichBias == 4 && sSlotMachine->luckyGame == TRUE) { value -= 10; if (value < 0) value = 0; } if (value > rval) break; } return whichBias; } // Return the probability of drawing the given number of ReelTime spins. // // This depends on whether it is a lucky game and the number of Power bolts you // have collected. static u8 GetReelTimeSpinProbability(u8 spins) { if (sSlotMachine->luckyGame == FALSE) return sReelTimeProbabilities_NormalGame[spins][sSlotMachine->pikaPowerBolts]; else return sReelTimeProbabilities_LuckyGame[spins][sSlotMachine->pikaPowerBolts]; } // The way this is computed skews the odds much more toward drawing a 0 than // intended. It initially checks whether you draw a 0 (using the intended // probability). It then tries to draw positive values, but if these draws all // miss, you'll still draw a 0. // // As a result, even when the power gauge is maxed out, you still have a ~30% // chance of drawing 0 spins. See sReelTimeProbabilities for more details. // // Drawing a random number via a cumulative pdf would have prevented this. static void GetReelTimeDraw(void) { u8 rval; s16 spins; sSlotMachine->reelTimeDraw = 0; rval = Random(); if (rval < GetReelTimeSpinProbability(0)) return; for (spins = 5; spins > 0; spins--) { rval = Random(); if (rval < GetReelTimeSpinProbability(spins)) break; } sSlotMachine->reelTimeDraw = spins; } // Returns true if the ReelTime machine should explode. Each time we check, // the odds of explosion increase. static bool8 ShouldReelTimeMachineExplode(u16 check) { u16 rval = Random() & 0xff; if (rval < sReelTimeExplodeProbability[check]) return TRUE; else return FALSE; } static u16 ReelTimeSpeed(void) { u8 i = 0; u8 rval; u8 value; if (sSlotMachine->netCoinLoss >= 300) i = 4; else if (sSlotMachine->netCoinLoss >= 250) i = 3; else if (sSlotMachine->netCoinLoss >= 200) i = 2; else if (sSlotMachine->netCoinLoss >= 150) i = 1; rval = Random() % 100; value = sReelTimeSpeed_Probabilities[i][0]; if (rval < value) return REEL_HALF_SPEED; rval = Random() % 100; value = sReelTimeSpeed_Probabilities[i][1] + sQuarterSpeed_ProbabilityBoost[sSlotMachine->reelTimeSpinsUsed]; if (rval < value) return REEL_QUARTER_SPEED; return REEL_NORMAL_SPEED; } static void CheckMatch(void) { sSlotMachine->matches = 0; CheckMatch_CenterRow(); if (sSlotMachine->bet > 1) CheckMatch_TopAndBottom(); if (sSlotMachine->bet > 2) CheckMatch_Diagonals(); } static void CheckMatch_CenterRow(void) { u8 sym1, sym2, sym3, match; sym1 = GetSymbolAtRest(LEFT_REEL, 2); sym2 = GetSymbolAtRest(MIDDLE_REEL, 2); sym3 = GetSymbolAtRest(RIGHT_REEL, 2); match = GetMatchFromSymbols(sym1, sym2, sym3); if (match != MATCH_NONE) { sSlotMachine->payout += sSlotPayouts[match]; sSlotMachine->matches |= sSlotMatchFlags[match]; FlashMatchLine(MATCH_MIDDLE_ROW); } } static void CheckMatch_TopAndBottom(void) { u8 sym1, sym2, sym3, match; sym1 = GetSymbolAtRest(LEFT_REEL, 1); sym2 = GetSymbolAtRest(MIDDLE_REEL, 1); sym3 = GetSymbolAtRest(RIGHT_REEL, 1); match = GetMatchFromSymbols(sym1, sym2, sym3); if (match != MATCH_NONE) { if (match == MATCH_CHERRY) match = MATCH_TOPBOT_CHERRY; sSlotMachine->payout += sSlotPayouts[match]; sSlotMachine->matches |= sSlotMatchFlags[match]; FlashMatchLine(MATCH_TOP_ROW); } sym1 = GetSymbolAtRest(LEFT_REEL, 3); sym2 = GetSymbolAtRest(MIDDLE_REEL, 3); sym3 = GetSymbolAtRest(RIGHT_REEL, 3); match = GetMatchFromSymbols(sym1, sym2, sym3); if (match != MATCH_NONE) { if (match == MATCH_CHERRY) match = MATCH_TOPBOT_CHERRY; sSlotMachine->payout += sSlotPayouts[match]; sSlotMachine->matches |= sSlotMatchFlags[match]; FlashMatchLine(MATCH_BOTTOM_ROW); } } static void CheckMatch_Diagonals(void) { u8 sym1, sym2, sym3, match; sym1 = GetSymbolAtRest(LEFT_REEL, 1); sym2 = GetSymbolAtRest(MIDDLE_REEL, 2); sym3 = GetSymbolAtRest(RIGHT_REEL, 3); match = GetMatchFromSymbols(sym1, sym2, sym3); if (match != MATCH_NONE) { // Don't add payout for cherry, since it's already counted in // CheckMatch_TopAndBottom(). if (match != MATCH_CHERRY) { sSlotMachine->payout += sSlotPayouts[match]; sSlotMachine->matches |= sSlotMatchFlags[match]; } FlashMatchLine(MATCH_NWSE_DIAG); } sym1 = GetSymbolAtRest(LEFT_REEL, 3); sym2 = GetSymbolAtRest(MIDDLE_REEL, 2); sym3 = GetSymbolAtRest(RIGHT_REEL, 1); match = GetMatchFromSymbols(sym1, sym2, sym3); if (match != MATCH_NONE) { // Don't add payout for cherry, since it's already counted in // CheckMatch_TopAndBottom(). if (match != MATCH_CHERRY) { sSlotMachine->payout += sSlotPayouts[match]; sSlotMachine->matches |= sSlotMatchFlags[match]; } FlashMatchLine(MATCH_NESW_DIAG); } } static u8 GetMatchFromSymbols(u8 sym1, u8 sym2, u8 sym3) { if (sym1 == sym2 && sym1 == sym3) return sSymbolToMatch[sym1]; if (sym1 == SYMBOL_7_RED && sym2 == SYMBOL_7_RED && sym3 == SYMBOL_7_BLUE) return MATCH_MIXED_7; if (sym1 == SYMBOL_7_BLUE && sym2 == SYMBOL_7_BLUE && sym3 == SYMBOL_7_RED) return MATCH_MIXED_7; if (sym1 == SYMBOL_CHERRY) return MATCH_CHERRY; return MATCH_NONE; } static void AwardPayout(void) { Task_Payout(CreateTask(Task_Payout, 4)); } static bool8 IsFinalTask_Task_Payout(void) { if (FindTaskIdByFunc(Task_Payout) == TAIL_SENTINEL) return TRUE; else return FALSE; } static void Task_Payout(u8 taskId) { while (sPayoutTasks[gTasks[taskId].data[0]](&gTasks[taskId])) ; } #define tState data[0] #define tTimer data[1] static bool8 PayoutTask_Init(struct Task *task) { if (IsMatchLineDoneFlashingBeforePayout()) { task->tState++; // PAYOUT_TASK_GIVE_PAYOUT if (sSlotMachine->payout == 0) { task->tState = PAYOUT_TASK_FREE; return TRUE; } } return FALSE; } static bool8 PayoutTask_GivePayout(struct Task *task) { if (!task->tTimer--) { if (IsFanfareTaskInactive()) PlaySE(SE_PIN); sSlotMachine->payout--; if (sSlotMachine->coins < MAX_COINS) sSlotMachine->coins++; task->tTimer = 8; if (JOY_HELD(A_BUTTON)) task->tTimer = 4; } if (IsFanfareTaskInactive() && JOY_NEW(START_BUTTON)) { PlaySE(SE_PIN); sSlotMachine->coins += sSlotMachine->payout; if (sSlotMachine->coins > MAX_COINS) sSlotMachine->coins = MAX_COINS; sSlotMachine->payout = 0; } if (sSlotMachine->payout == 0) task->tState++; // PAYOUT_TASK_FREE return FALSE; } static bool8 PayoutTask_Free(struct Task *task) { if (TryStopMatchLinesFlashing()) DestroyTask(FindTaskIdByFunc(Task_Payout)); return FALSE; } #undef tState #undef tTimer // Get the symbol at position `offset` below the top of the reel's tape. Note // that if `offset` is negative, it wraps around to the bottom of the tape. // .-----------------. // | [ ] | [ ] | [ ] | <- offset = 0 // /-----|-----|-----\ // screen -> | [ ] | [ ] | [ ] | <- offset = 1 // | [ ] | [ ] | [ ] | <- offset = 2 // | [ ] | [ ] | [ ] | <- offset = 3 // \-----|-----|-----/ // | ... | ... | ... | // | [ ] | [ ] | [ ] | <- offset = 20 // .-----------------. static u8 GetSymbolAtRest(u8 reel, s16 offset) { s16 pos = (sSlotMachine->reelPositions[reel] + offset) % SYMBOLS_PER_REEL; if (pos < 0) pos += SYMBOLS_PER_REEL; return sReelSymbols[reel][pos]; } // Calculates GetSymbolAtRest as if the reel were snapped downwards into place. static u8 GetSymbol(u8 reel, s16 offset) { s16 inc = 0; s16 pixelOffset = sSlotMachine->reelPixelOffsets[reel] % REEL_SYMBOL_HEIGHT; if (pixelOffset != 0) inc = -1; return GetSymbolAtRest(reel, offset + inc); } static u8 GetReelTimeSymbol(s16 offset) { s16 newPosition = (sSlotMachine->reeltimePosition + offset) % REELTIME_SYMBOLS; if (newPosition < 0) newPosition += REELTIME_SYMBOLS; return sReelTimeSymbols[newPosition]; } static void AdvanceSlotReel(u8 reelIndex, s16 value) { sSlotMachine->reelPixelOffsets[reelIndex] += value; sSlotMachine->reelPixelOffsets[reelIndex] %= REEL_HEIGHT; sSlotMachine->reelPositions[reelIndex] = SYMBOLS_PER_REEL - sSlotMachine->reelPixelOffsets[reelIndex] / REEL_SYMBOL_HEIGHT; } // Advances the reel no further than the next symbol. Returns the remaining // pixels until the next symbol. s16 AdvanceSlotReelToNextSymbol(u8 reelIndex, s16 value) { s16 offset = sSlotMachine->reelPixelOffsets[reelIndex] % REEL_SYMBOL_HEIGHT; if (offset != 0) { if (offset < value) value = offset; AdvanceSlotReel(reelIndex, value); offset = sSlotMachine->reelPixelOffsets[reelIndex] % REEL_SYMBOL_HEIGHT; } return offset; } static void AdvanceReeltimeReel(s16 value) { sSlotMachine->reeltimePixelOffset += value; sSlotMachine->reeltimePixelOffset %= REELTIME_REEL_HEIGHT; sSlotMachine->reeltimePosition = REELTIME_SYMBOLS - sSlotMachine->reeltimePixelOffset / REELTIME_SYMBOL_HEIGHT; } // Advances the reel no further than the next symbol. Returns the remaining // pixels until the next symbol. s16 AdvanceReeltimeReelToNextSymbol(s16 value) { s16 offset = sSlotMachine->reeltimePixelOffset % REELTIME_SYMBOL_HEIGHT; if (offset != 0) { if (offset < value) value = offset; AdvanceReeltimeReel(value); offset = sSlotMachine->reeltimePixelOffset % REELTIME_SYMBOL_HEIGHT; } return offset; } #define tState data[0] #define tExtraTurns data[1] #define tShockMagnitude data[1] #define tTimer data[2] #define tMoving data[14] #define tReelId data[15] static void CreateReelTasks(void) { u8 i; for (i = 0; i < NUM_REELS; i++) { u8 taskId = CreateTask(Task_Reel, 2); gTasks[taskId].tReelId = i; sSlotMachine->slotReelTasks[i] = taskId; Task_Reel(taskId); } } static void SpinSlotReel(u8 reelIndex) { gTasks[sSlotMachine->slotReelTasks[reelIndex]].tState = REEL_TASK_SPIN; gTasks[sSlotMachine->slotReelTasks[reelIndex]].tMoving = TRUE; } static void StopSlotReel(u8 reelIndex) { gTasks[sSlotMachine->slotReelTasks[reelIndex]].tState = REEL_TASK_DECIDE_STOP; } static bool8 IsSlotReelMoving(u8 reelIndex) { return gTasks[sSlotMachine->slotReelTasks[reelIndex]].tMoving; } static void Task_Reel(u8 taskId) { while (sReelTasks[gTasks[taskId].tState](&gTasks[taskId])) ; } static bool8 ReelTask_StayStill(struct Task *task) { return FALSE; } static bool8 ReelTask_Spin(struct Task *task) { AdvanceSlotReel(task->tReelId, sSlotMachine->reelSpeed); return FALSE; } // In ReelTime, the reel stops immediately. Otherwise, the game may manipulate // the results by stopping after at most 4 extra turns. The exact behavior // differs depending on whether the machine has a bias. // // If the machine has a bias, it will try to match the bias symbol in each reel. // // Otherwise, if the machine doesn't have a bias or it could not line up the // bias symbol in any of the previous reels, it will perform the NoBias stopping // routine, which manipulates the outcome so the player loses. static bool8 ReelTask_DecideStop(struct Task *task) { task->tState++; // REEL_TASK_STOP_MOVE sSlotMachine->winnerRows[task->tReelId] = 0; sSlotMachine->reelExtraTurns[task->tReelId] = 0; if (sSlotMachine->reelTimeSpinsLeft == 0) { if (sSlotMachine->machineBias == 0 || !sSlotMachine->didNotFailBias || !sDecideStop_Bias[task->tReelId]()) { sSlotMachine->didNotFailBias = FALSE; sDecideStop_NoBias[task->tReelId](); } } task->tExtraTurns = sSlotMachine->reelExtraTurns[task->tReelId]; return TRUE; } // Go to the next symbol, then add any extra turns. static bool8 ReelTask_MoveToStop(struct Task *task) { u16 reelStopShocks[ARRAY_COUNT(sReelStopShocks)]; s16 reelPixelPos; memcpy(reelStopShocks, sReelStopShocks, sizeof(sReelStopShocks)); reelPixelPos = sSlotMachine->reelPixelOffsets[task->tReelId] % REEL_SYMBOL_HEIGHT; if (reelPixelPos != 0) reelPixelPos = AdvanceSlotReelToNextSymbol(task->tReelId, sSlotMachine->reelSpeed); else if (sSlotMachine->reelExtraTurns[task->tReelId]) { sSlotMachine->reelExtraTurns[task->tReelId]--; AdvanceSlotReel(task->tReelId, sSlotMachine->reelSpeed); reelPixelPos = sSlotMachine->reelPixelOffsets[task->tReelId] % REEL_SYMBOL_HEIGHT; } if (reelPixelPos == 0 && sSlotMachine->reelExtraTurns[task->tReelId] == 0) { task->tState++; // REEL_TASK_STOP_SHAKE task->tShockMagnitude = reelStopShocks[task->tExtraTurns]; task->tTimer = 0; } return FALSE; } // The reel shakes a little at the selected symbol before settling. static bool8 ReelTask_ShakingStop(struct Task *task) { sSlotMachine->reelShockOffsets[task->tReelId] = task->tShockMagnitude; task->tShockMagnitude = -task->tShockMagnitude; task->tTimer++; if ((task->tTimer & 0x3) == 0) task->tShockMagnitude >>= 1; if (task->tShockMagnitude == 0) { task->tState = 0; task->tMoving = FALSE; sSlotMachine->reelShockOffsets[task->tReelId] = 0; } return FALSE; } #undef tState #undef tExtraTurns #undef tShockMagnitude #undef tTimer #undef tMoving #undef tReelId // We pass along two symbols to bias toward. If the machine is biased toward // 7's, we pass both the 7 symbols. Otherwise, we just pass the bias symbol // twice. static bool8 DecideStop_Bias_Reel1(void) { u8 sym2 = GetBiasSymbol(sSlotMachine->machineBias); u8 sym1 = sym2; if (sSlotMachine->machineBias & (BIAS_STRAIGHT_7 | BIAS_MIXED_7)) { sym1 = SYMBOL_7_RED; sym2 = SYMBOL_7_BLUE; } return sDecideStop_Bias_Reel1_Bets[sSlotMachine->bet - 1](sym1, sym2); } // The biasSymbol for subsequent reels is determined based on which of the bias // symbols can be found in reel 1. This really only matters when the machine is // biased toward 7's. It will try to match a 7 of the same color as reel 1. static bool8 EitherSymbolAtPos_Reel1(s16 pos, u8 sym1, u8 sym2) { u8 sym = GetSymbol(LEFT_REEL, pos); if (sym == sym1 || sym == sym2) { sSlotMachine->biasSymbol = sym; return TRUE; } return FALSE; } // Returns true if there are cherries on screen in reel 1 after the given number // of turns. static bool8 AreCherriesOnScreen_Reel1(s16 turns) { if (GetSymbol(LEFT_REEL, 1 - turns) == SYMBOL_CHERRY || GetSymbol(LEFT_REEL, 2 - turns) == SYMBOL_CHERRY || GetSymbol(LEFT_REEL, 3 - turns) == SYMBOL_CHERRY) return TRUE; else return FALSE; } static bool8 BiasedTowardCherryOr7s(void) { if (sSlotMachine->machineBias & (BIAS_STRAIGHT_7 | BIAS_MIXED_7 | BIAS_CHERRY)) return TRUE; else return FALSE; } // If a bias symbol appears in the center of reel 1 within the next 4 turns, // stop there. That symbol becomes the biasSymbol for the subsequent reels. static bool8 DecideStop_Bias_Reel1_Bet1(u8 sym1, u8 sym2) { s16 i; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (EitherSymbolAtPos_Reel1(2 - i, sym1, sym2)) { sSlotMachine->winnerRows[LEFT_REEL] = 2; sSlotMachine->reelExtraTurns[LEFT_REEL] = i; return TRUE; } } return FALSE; } // There is slightly different behavior depending on the machine's bias. // // Bias toward cherry or 7s: // - Check if a cherry or 7 is currently on screen. If so, stop immediately. // - Roll up to 4 extra turns to see if a cherry or 7 enters the screen: // - If it enters after 1 turn, stop the reel when it gets the bottom row. // - Otherwise, if it enters before the 4th turn, stop the reel when it gets // to the middle row. // - If it enters on the 4th turn, stop here. It will be in the top row. // // Other bias: // - This is very similar, except the game is checking for the bias symbol // rather than cherries / 7s. // // However, the game adds an additional constraint: it will not stop if there // will be any cherries on screen. Presumably, this ensures that you will not // get any matches if you fail to line up the bias symbol in the remaining // reels. // // This is programmed in such a way that it excludes more options than // necessary. If there are cherries in the two positions below the bias symbol, // it will skip over this option, even if those cherries would not have ended // up on screen. static bool8 DecideStop_Bias_Reel1_Bet2or3(u8 sym1, u8 sym2) { s16 i; bool8 cherry7Bias = BiasedTowardCherryOr7s(); if (cherry7Bias || !AreCherriesOnScreen_Reel1(0)) { // Check the current screen for (i = 1; i <= 3; i++) { if (EitherSymbolAtPos_Reel1(i, sym1, sym2)) { sSlotMachine->winnerRows[0] = i; sSlotMachine->reelExtraTurns[0] = 0; return TRUE; } } } // Check the next 4 turns for (i = 1; i <= MAX_EXTRA_TURNS; i++) { bool8 cherry7BiasCopy = cherry7Bias; // redundant if (cherry7BiasCopy || !AreCherriesOnScreen_Reel1(i)) { if (EitherSymbolAtPos_Reel1(1 - i, sym1, sym2)) { if (i == 1 && (cherry7BiasCopy || !AreCherriesOnScreen_Reel1(3))) { sSlotMachine->winnerRows[0] = 3; sSlotMachine->reelExtraTurns[0] = 3; return TRUE; } if (i <= 3 && (cherry7BiasCopy || !AreCherriesOnScreen_Reel1(i + 1))) { sSlotMachine->winnerRows[0] = 2; sSlotMachine->reelExtraTurns[0] = i + 1; return TRUE; } sSlotMachine->winnerRows[0] = 1; sSlotMachine->reelExtraTurns[0] = i; return TRUE; } } } return FALSE; } static bool8 DecideStop_Bias_Reel2(void) { return sDecideStop_Bias_Reel2_Bets[sSlotMachine->bet - 1](); } // Turn at most 4 extra turns to try to line up the bias symbol in the same row // as reel 1. static bool8 DecideStop_Bias_Reel2_Bet1or2(void) { s16 i; s16 reel1BiasRow = sSlotMachine->winnerRows[0]; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (GetSymbol(MIDDLE_REEL, reel1BiasRow - i) == sSlotMachine->biasSymbol) { sSlotMachine->winnerRows[1] = reel1BiasRow; sSlotMachine->reelExtraTurns[1] = i; return TRUE; } } return FALSE; } // Checks whether it can match the bias symbol diagonally, and sometimes skews // toward this type of match rather than a match straight across. // // The behavior is different depending on where the bias symbol landed in // reel 1: // // Landed in middle row: // A diagonal match is impossible. Just try to match the bias symbol in the // middle row of reel 2 within 4 turns. // // Landed in top/bottom row: // - If it would take 2 or 3 turns to get the bias symbol into the same row as // reel 1, force a diagonal match by stopping it in the middle row instead. // - Check if the bias symbol is already in the same row as reel 1, or if it // takes 1 or 4 turns to get it there. If so, stop when it reaches that row. // - Otherwise, check if the bias symbol is already in the middle row of // reel 2. If so, stop here. // // So in how many more cases would betting 3 coins let you win compared to // betting 2? // Not many. Most of the time, the game would have matched the symbol in the // same row as reel 1 if you had bet 2 coins. Betting 3 effectively adds // coverage for only two additional cases: // - Bias symbol is in top row of reel 1 and bias symbol is currently in // middle row of reel 2. // - Bias symbol is in bottom row of reel 1 and bias symbol could get to the // middle row of reel 2 in 4 turns. // // Assuming this is the implementation Game Freak intended, the game effectively // turns straight matches into diagonal matches with 2/5 probability. // Presumably, this makes the player feel fortunate that they bet 3 coins rather // than 2, even though most times the game would have still forced a match with // only 2 coins. static bool8 DecideStop_Bias_Reel2_Bet3(void) { s16 i; // If you can line up the bias symbol in the same row as reel 1 within 4 // turns if (DecideStop_Bias_Reel2_Bet1or2()) { // If bias symbol is not in the middle row of reel 1 and it takes either // 2 or 3 turns to get it in the same row for reel 2 if (sSlotMachine->winnerRows[0] != 2 && sSlotMachine->reelExtraTurns[1] > 1 && sSlotMachine->reelExtraTurns[1] != 4) { // Try turning this into a diagonal match by lining up the bias // symbol in the middle row of reel 2 within 4 turns. for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (GetSymbol(MIDDLE_REEL, 2 - i) == sSlotMachine->biasSymbol) { sSlotMachine->winnerRows[1] = 2; sSlotMachine->reelExtraTurns[1] = i; break; } } } return TRUE; } // If you can't line up the bias symbol in the same row in 4 turns, and the // bias symbol is not in the middle row of reel 1 if (sSlotMachine->winnerRows[0] != 2) { // Try to match the bias symbol in middle row of reel 2 within 4 turns. // Adds coverage for the two cases mentioned above. for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (GetSymbol(MIDDLE_REEL, 2 - i) == sSlotMachine->biasSymbol) { sSlotMachine->winnerRows[1] = 2; sSlotMachine->reelExtraTurns[1] = i; return TRUE; } } } return FALSE; } // If the machine is biased toward mixed 7's, swap the color of the bias symbol // from red 7 to blue 7, or vice versa. static bool8 DecideStop_Bias_Reel3(void) { u8 biasSymbol = sSlotMachine->biasSymbol; if (sSlotMachine->machineBias & BIAS_MIXED_7) { biasSymbol = SYMBOL_7_RED; if (sSlotMachine->biasSymbol == SYMBOL_7_RED) { biasSymbol = SYMBOL_7_BLUE; } } return sDecideStop_Bias_Reel3_Bets[sSlotMachine->bet - 1](biasSymbol); } // Turn at most 4 extra turns to try to line up the bias symbol in the same // row as reel 2. static bool8 DecideStop_Bias_Reel3_Bet1or2(u8 biasSymbol) { s16 i; s16 reel2BiasRow = sSlotMachine->winnerRows[1]; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (GetSymbol(RIGHT_REEL, reel2BiasRow - i) == biasSymbol) { sSlotMachine->winnerRows[2] = reel2BiasRow; sSlotMachine->reelExtraTurns[2] = i; return TRUE; } } return FALSE; } // Try to complete a match in reel 3 by lining up a bias symbol with the bias // symbols from the first two reels. static bool8 DecideStop_Bias_Reel3_Bet3(u8 biasSymbol) { s16 i; s16 biasRow; // First two bias symbols in the same row. Try to line up bias symbol in // same the row here too if (sSlotMachine->winnerRows[0] == sSlotMachine->winnerRows[1]) return DecideStop_Bias_Reel3_Bet1or2(biasSymbol); // Otherwise, try to line up the bias symbol diagonally if (sSlotMachine->winnerRows[0] == 1) biasRow = 3; else biasRow = 1; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (GetSymbol(RIGHT_REEL, biasRow - i) == biasSymbol) { sSlotMachine->reelExtraTurns[2] = i; sSlotMachine->winnerRows[2] = biasRow; return TRUE; } } return FALSE; } // Advance as many turns as needed until there are no cherries on screen in // reel 1, as cherries would cause a match. // // Based on the distribution of reel 1, this will add at most 3 extra turns. static void DecideStop_NoBias_Reel1(void) { s16 i = 0; while (AreCherriesOnScreen_Reel1(i) != 0) i++; sSlotMachine->reelExtraTurns[0] = i; } // If the bias symbol is one of the 7's, switch to the opposite color and return // true. Otherwise, return false. static bool8 IfSymbol7_SwitchColor(u8 *symbol) { if (*symbol == SYMBOL_7_RED) { *symbol = SYMBOL_7_BLUE; return TRUE; } if (*symbol == SYMBOL_7_BLUE) { *symbol = SYMBOL_7_RED; return TRUE; } return FALSE; } // If the machine doesn't have a bias, the reel stops immediately. // // Otherwise, the machine tries to taunt the player if it is biased toward // straight 7's. This would only happen if the player did not stop near the // correct-color 7, so the machine couldn't force a match. // // Instead, the machine now tries to line up the opposite-color 7, which is not // a valid match. static void DecideStop_NoBias_Reel2(void) { sDecideStop_NoBias_Reel2_Bets[sSlotMachine->bet - 1](); } // If the machine has no bias, stop immediately. // // Otherwise, the machine manipulates the results if all the following // conditions are met: // If // - The machine is biased toward straight 7's // - The machine managed to match a 7 in the middle of reel 1 // - The machine could not line up a 7 of the same color in reel 2 // Then // The machine will try to line up a 7 of the opposite color in reel 2 static void DecideStop_NoBias_Reel2_Bet1(void) { if (sSlotMachine->winnerRows[0] != 0 && sSlotMachine->machineBias & BIAS_STRAIGHT_7) { // Note here and in other NoBias functions, reelExtraTurns is 0 if it // corresponds to a previous reel. That reel has already stopped and any // extra turns were applied. u8 reel1MiddleSym = GetSymbol(LEFT_REEL, 2 - sSlotMachine->reelExtraTurns[0]); if (IfSymbol7_SwitchColor(&reel1MiddleSym)) { s16 i; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (reel1MiddleSym == GetSymbol(MIDDLE_REEL, 2 - i)) { sSlotMachine->winnerRows[1] = 2; sSlotMachine->reelExtraTurns[1] = i; break; } } } } } // If the machine has no bias, stop immediately. // // Otherwise, the machine manipulates the results if all the following // conditions are met: // If // - The machine is biased toward straight 7's // - The machine managed to match a 7 anywhere in reel 1 // - The machine could not line up a 7 of the same color in reel 2 // Then // The machine will try to line up a 7 of the opposite color in reel 2 static void DecideStop_NoBias_Reel2_Bet2(void) { if (sSlotMachine->winnerRows[0] != 0 && sSlotMachine->machineBias & BIAS_STRAIGHT_7) { u8 reel1BiasSym = GetSymbol(LEFT_REEL, sSlotMachine->winnerRows[0] - sSlotMachine->reelExtraTurns[0]); if (IfSymbol7_SwitchColor(&reel1BiasSym)) { s16 i; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (reel1BiasSym == GetSymbol(MIDDLE_REEL, sSlotMachine->winnerRows[0] - i)) { sSlotMachine->winnerRows[1] = sSlotMachine->winnerRows[0]; sSlotMachine->reelExtraTurns[1] = i; break; } } } } } // If the machine has no bias, stop immediately. // // Otherwise, the machine manipulates the results if all the following // conditions are met: // If // - The machine is biased toward straight 7's // - The machine managed to match a 7 anywhere in reel 1 // - The machine could not line up a 7 of the same color in reel 2 // Then // The machine will try to line up a 7 of the opposite color in reel 2 // // The way it tries to line up an opposite-color 7 differs depending on where // the 7 is in reel 1: // // Middle row: // Try to line up an opposite-color 7 in the middle of reel 2 within 4 turns. // // Top row: // - First check for an opposite-color 7 in the top and middle rows of the // current screen. If found, stop immediately. // - Otherwise, check if an opposite-color 7 will enter the top row within 4 // turns. // - If one enters in 1 or 2 turns, stop the reel when it gets to the middle // row. // - If one enters in 3 or 4 turns, stop the reel when it gets to the top // row. // // Bottom row: // - First check for an opposite-color 7 in the middle and bottom rows of the // current screen. If found, stop immediately. // - Otherwise, check if an opposite-color 7 will enter the bottom row within 4 // turns. // - If one enters in 1 or 2 turns, stop the reel when it gets to the bottom // row. // - If one enters in 3 or 4 turns, stop the reel when it gets to the middle // row. // // BUG: This procedure misses an opportunity to line up an opposite-color 7 in // one scenario, when: // - There is a 7 in the bottom row of reel 1 // - And, you can get an opposite-color 7 in the middle row of reel 2 in 4 // turns static void DecideStop_NoBias_Reel2_Bet3(void) { s16 i; s16 j; u8 reel1BiasSym; if (sSlotMachine->winnerRows[0] != 0 && sSlotMachine->machineBias & BIAS_STRAIGHT_7) { // Lined up 7 in middle of reel 1 if (sSlotMachine->winnerRows[0] == 2) { DecideStop_NoBias_Reel2_Bet2(); return; } reel1BiasSym = GetSymbol(LEFT_REEL, sSlotMachine->winnerRows[0] - sSlotMachine->reelExtraTurns[0]); if (IfSymbol7_SwitchColor(&reel1BiasSym)) { // Check current screen to see if there is already an opposite-color // 7 lined up for a match. j = 2; if (sSlotMachine->winnerRows[0] == 3) j = 3; for (i = 0; i < 2; i++, j--) { if (reel1BiasSym == GetSymbol(MIDDLE_REEL, j)) { sSlotMachine->winnerRows[1] = j; sSlotMachine->reelExtraTurns[1] = 0; return; } } // Check if opposite-color 7 will appear in same row as reel 1 in // over the next 4 turns for (j = 1; j <= MAX_EXTRA_TURNS; j++) { if (reel1BiasSym == GetSymbol(MIDDLE_REEL, sSlotMachine->winnerRows[0] - j)) { // If 7 appeared in top row of reel 1 if (sSlotMachine->winnerRows[0] == 1) { if (j <= 2) { sSlotMachine->winnerRows[1] = 2; sSlotMachine->reelExtraTurns[1] = j + 1; } else { sSlotMachine->winnerRows[1] = 1; sSlotMachine->reelExtraTurns[1] = j; } } // If 7 appeared in bottom row of reel 1 else { if (j <= 2) { sSlotMachine->winnerRows[1] = 3; sSlotMachine->reelExtraTurns[1] = j; } else { sSlotMachine->winnerRows[1] = 2; sSlotMachine->reelExtraTurns[1] = j - 1; } } return; } } } } } // Returns true if the reel 1 and reel 2 symbols are opposite-color 7's. // // Note that if true, this does not constitue a MATCH_MIXED_7, as the first two // reels are not the same color. static bool8 MismatchedSyms_77(u8 sym1, u8 sym2) { if ((sym1 == SYMBOL_7_RED && sym2 == SYMBOL_7_BLUE) || (sym1 == SYMBOL_7_BLUE && sym2 == SYMBOL_7_RED)) return TRUE; else return FALSE; } // Returns true if the reel 1, reel 2 and reel 3 symbolss form a 7 mismatch, // i.e. {7R, 7B, 7R} or {7B, 7R, 7B}. static bool8 MismatchedSyms_777(u8 sym1, u8 sym2, u8 sym3) { if ((sym1 == SYMBOL_7_RED && sym2 == SYMBOL_7_BLUE && sym3 == SYMBOL_7_RED) || (sym1 == SYMBOL_7_BLUE && sym2 == SYMBOL_7_RED && sym3 == SYMBOL_7_BLUE)) return TRUE; else return FALSE; } // Returns false if either: // - The symbols form a match (including MATCH_MIXED_7) // - Or, the symbols form a 7 mismatch (i.e., {7R, 7B, 7R} or {7B, 7R, 7B}) // // Note, this does not account for cherry matches. static bool8 NeitherMatchNor7Mismatch(u8 sym1, u8 sym2, u8 sym3) { if ((sym1 == SYMBOL_7_RED && sym2 == SYMBOL_7_BLUE && sym3 == SYMBOL_7_RED) || (sym1 == SYMBOL_7_BLUE && sym2 == SYMBOL_7_RED && sym3 == SYMBOL_7_BLUE) || (sym1 == SYMBOL_7_RED && sym2 == SYMBOL_7_RED && sym3 == SYMBOL_7_BLUE) || (sym1 == SYMBOL_7_BLUE && sym2 == SYMBOL_7_BLUE && sym3 == SYMBOL_7_RED) || (sym1 == sym2 && sym1 == sym3)) { return FALSE; } return TRUE; } // Spin until there's no match, or try to taunt the player with a 7 mismatch if // they failed the straight 7 bias. static void DecideStop_NoBias_Reel3(void) { sDecideStop_NoBias_Reel3_Bets[sSlotMachine->bet - 1](); } // Spin until there is no match in reel 3. Additionally, if the player failed a // straight 7 bias, try to taunt them with a 7 mismatch. // // The way this plays out depends on the first two matched symbols. // // If first two symbols are the same: // Spin until you get a symbol that won't complete a match. // // Otherwise, if the first two symbols are opposite-color 7's: // - If the machine is biased toward straight 7's, then the player must have // failed with this bias. The machine tries to taunt the player by turning // up to 4 turns to complete a 7 mismatch (i.e., {7R, 7B, 7R} or // {7B, 7R, 7B}). // - Otherwise, spin until you get a symbol that won't complete a match. static void DecideStop_NoBias_Reel3_Bet1(void) { s16 i = 0; u8 sym1 = GetSymbol(LEFT_REEL, 2 - sSlotMachine->reelExtraTurns[0]); u8 sym2 = GetSymbol(MIDDLE_REEL, 2 - sSlotMachine->reelExtraTurns[1]); // If first two symbols match, spin until you get a non-matching symbol if (sym1 == sym2) { while (TRUE) { u8 sym3; if (!((sym1 == (sym3 = GetSymbol(RIGHT_REEL, 2 - i))) || (sym1 == SYMBOL_7_RED && sym3 == SYMBOL_7_BLUE) || (sym1 == SYMBOL_7_BLUE && sym3 == SYMBOL_7_RED))) break; i++; } } // First two symbols are opposite-color 7's else if (MismatchedSyms_77(sym1, sym2)) { // If biased toward straight 7's, try to complete the 7 mismatch in 4 // turns if (sSlotMachine->machineBias & BIAS_STRAIGHT_7) { for (i = 0; i <= MAX_EXTRA_TURNS; i++) { if (sym1 == GetSymbol(RIGHT_REEL, 2 - i)) { sSlotMachine->reelExtraTurns[2] = i; return; } } } // Otherwise, just spin until you get a non-matching symbol i = 0; while (TRUE) { if (sym1 != GetSymbol(RIGHT_REEL, 2 - i)) break; i++; } } sSlotMachine->reelExtraTurns[2] = i; } // Spin until there is no match in reel 3. Additionally, if the player failed a // straight 7 bias, try to taunt them with a 7 mismatch. // // There are up to two stages, depending on the first two matched symbols: // // 1. [Optional] If first two symbols are opposite-color 7's in the same row and // the machine is biased toward straight 7's: // Check if a 7 with the same color as reel 1 appears in the same row // within 4 turns. If so, initially advance to that position. // // 2. Check rows. Keep advancing the reel a turn at a time as long as: // - There is a match in any row // - Or, there is a 7 mismatch in any row and the machine isn't biased // toward straight 7's // // Note, stage 2 is not limited to 4 turns. The reel keeps spinning until you // lose. static void DecideStop_NoBias_Reel3_Bet2(void) { s16 extraTurns = 0; s16 i; u8 sym1; u8 sym2; u8 sym3; // Effectively, if you lined up two 7's in the same row if (sSlotMachine->winnerRows[1] != 0 && sSlotMachine->winnerRows[0] == sSlotMachine->winnerRows[1] && sSlotMachine->machineBias & BIAS_STRAIGHT_7) { sym1 = GetSymbol(LEFT_REEL, sSlotMachine->winnerRows[0] - sSlotMachine->reelExtraTurns[0]); sym2 = GetSymbol(MIDDLE_REEL, sSlotMachine->winnerRows[1] - sSlotMachine->reelExtraTurns[1]); // If the first two 7's are opposite colors, see if you can line up a 7 // mismatch in the same row. If so, advance initially to that position. // More turns may be added further below. if (MismatchedSyms_77(sym1, sym2)) { // Iterate over the next 4 turns for (i = 0; i <= MAX_EXTRA_TURNS; i++) { sym3 = GetSymbol(RIGHT_REEL, sSlotMachine->winnerRows[1] - i); if (sym1 == sym3) { extraTurns = i; break; } } } } while (TRUE) { s16 numMatches; // Iterate over the rows of the screen after `extraTurns` turns for (i = 1, numMatches = 0; i <= 3; i++) { sym1 = GetSymbol(LEFT_REEL, i - sSlotMachine->reelExtraTurns[0]); sym2 = GetSymbol(MIDDLE_REEL, i - sSlotMachine->reelExtraTurns[1]); sym3 = GetSymbol(RIGHT_REEL, i - extraTurns); // This boils down to: // If there's a match on screen, keep spinning. Otherwise, if // there's a 7 mismatch on screen, keep spinning if the machine // isn't biased toward straight 7's. if (!NeitherMatchNor7Mismatch(sym1, sym2, sym3) && !(MismatchedSyms_777(sym1, sym2, sym3) && (sSlotMachine->machineBias & BIAS_STRAIGHT_7))) { numMatches++; break; } } // If no matches were found, stop here. Otherwise, add an extra spin and // check again. if (numMatches == 0) break; extraTurns++; } sSlotMachine->reelExtraTurns[2] = extraTurns; } // Try to spin until there is no match in reel 3. Additionally, if the player // failed a straight 7 bias, try to taunt them with a 7 mismatch. // // There are up to four stages: // // 1. Advance the reel as if 2 coins were bet: to mildly oversimplify, spin // until there's no matches straight across in any rows. // // 2. [Optional] If you've lined up two opposite-color 7's diagonally and the // machine is biased toward straight 7's: // Check if a 7 with the same color as reel 1 appears in the final diagonal // position within 4 turns. If so, advance to that position. // // 3. Check NWSE diagonal. Keep advancing the reel a turn at a time as long as: // - There is a match in the diagonal // - Or, there is a 7 mismatch in the diagonal and the machine isn't // biased toward straight 7's // // 3. Check NESW diagonal. Keep advancing the reel a turn at a time as long as: // - There is a match in the diagonal // - Or, there is a 7 mismatch in the diagonal and the machine isn't // biased toward straight 7's // // Note that stages 3 and 4 are not limited to 4 turns. // // Also, note that it actually is possible to win a match here. After stage 1, // the game never again checks whether it will be matching any rows straight // across. So any extra turns added in stages 2-4 could result in a match // occurring straight across. static void DecideStop_NoBias_Reel3_Bet3(void) { u8 sym1; u8 sym2; u8 sym3; s16 row; s16 i; // Spin until there's no matches in any row straight across, potentially // skewing toward a 7 mismatch. Consider this the new starting position for // this function. DecideStop_NoBias_Reel3_Bet2(); // Essentially, if you lined up two 7's diagonally if (sSlotMachine->winnerRows[1] != 0 && sSlotMachine->winnerRows[0] != sSlotMachine->winnerRows[1] && sSlotMachine->machineBias & BIAS_STRAIGHT_7) { sym1 = GetSymbol(LEFT_REEL, sSlotMachine->winnerRows[0] - sSlotMachine->reelExtraTurns[0]); sym2 = GetSymbol(MIDDLE_REEL, sSlotMachine->winnerRows[1] - sSlotMachine->reelExtraTurns[1]); // If the first two 7's are opposite colors, try advancing up to 4 // additional turns to line up a diagonal 7 mismatch. More turns may be // added further below. if (MismatchedSyms_77(sym1, sym2)) { row = 1; if (sSlotMachine->winnerRows[0] == 1) row = 3; for (i = 0; i <= MAX_EXTRA_TURNS; i++) { sym3 = GetSymbol(RIGHT_REEL, row - (sSlotMachine->reelExtraTurns[2] + i)); if (sym1 == sym3) { sSlotMachine->reelExtraTurns[2] += i; break; } } } } while (TRUE) { // Check NWSE diagonal sym1 = GetSymbol(LEFT_REEL, 1 - sSlotMachine->reelExtraTurns[0]); sym2 = GetSymbol(MIDDLE_REEL, 2 - sSlotMachine->reelExtraTurns[1]); sym3 = GetSymbol(RIGHT_REEL, 3 - sSlotMachine->reelExtraTurns[2]); if (NeitherMatchNor7Mismatch(sym1, sym2, sym3) || (MismatchedSyms_777(sym1, sym2, sym3) && sSlotMachine->machineBias & BIAS_STRAIGHT_7)) break; sSlotMachine->reelExtraTurns[2]++; } while (TRUE) { // Check NESW diagonal sym1 = GetSymbol(LEFT_REEL, 3 - sSlotMachine->reelExtraTurns[0]); sym2 = GetSymbol(MIDDLE_REEL, 2 - sSlotMachine->reelExtraTurns[1]); sym3 = GetSymbol(RIGHT_REEL, 1 - sSlotMachine->reelExtraTurns[2]); if (NeitherMatchNor7Mismatch(sym1, sym2, sym3) || (MismatchedSyms_777(sym1, sym2, sym3) && sSlotMachine->machineBias & BIAS_STRAIGHT_7)) break; sSlotMachine->reelExtraTurns[2]++; } } static void PressStopReelButton(u8 reelNum) { u8 taskId = CreateTask(Task_PressStopReelButton, 5); gTasks[taskId].data[15] = reelNum; Task_PressStopReelButton(taskId); } static void Task_PressStopReelButton(u8 taskId) { sReelStopButtonTasks[gTasks[taskId].data[0]](&gTasks[taskId], taskId); } static void StopReelButton_Press(struct Task *task, u8 taskId) { SetReelButtonTilemap(sReelButtonOffsets[task->data[15]], 0x62, 0x63, 0x72, 0x73); task->data[0]++; } static void StopReelButton_Wait(struct Task *task, u8 taskId) { if (++task->data[1] > 11) task->data[0]++; } static void StopReelButton_Unpress(struct Task *task, u8 taskId) { SetReelButtonTilemap(sReelButtonOffsets[task->data[15]], 0x42, 0x43, 0x52, 0x53); DestroyTask(taskId); } static void LightenMatchLine(u8 matchLineId) { LoadPalette(sLitMatchLinePalTable[matchLineId], sMatchLinePalOffsets[matchLineId], PLTT_SIZEOF(1)); } static void DarkenMatchLine(u8 matchLineId) { LoadPalette(sDarkMatchLinePalTable[matchLineId], sMatchLinePalOffsets[matchLineId], PLTT_SIZEOF(1)); } // light up the match line for each bet by the player static void LightenBetTiles(u8 betVal) { u8 i; for (i = 0; i < sMatchLinesPerBet[betVal]; i++) LightenMatchLine(sBetToMatchLineIds[betVal][i]); } static void DarkenBetTiles(u8 betVal) { u8 i; for (i = 0; i < sMatchLinesPerBet[betVal]; i++) DarkenMatchLine(sBetToMatchLineIds[betVal][i]); } #define sMatchLineId data[0] #define sFlashing data[1] #define sNumFullFlashes data[2] #define sDelayTimer data[3] #define sColor data[4] #define sColorIncr data[5] #define sAtOriginalColor data[7] // Creates invisible sprites that flash the bet lines/numbers where a match occurs // 5 are created, 1 for each possible match line (3 rows, 2 diagonals) static void CreateInvisibleFlashMatchLineSprites(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->flashMatchLineSpriteIds); i++) { u8 spriteId = CreateInvisibleSprite(SpriteCB_FlashMatchingLines); gSprites[spriteId].sMatchLineId = i; sSlotMachine->flashMatchLineSpriteIds[i] = spriteId; } } static void FlashMatchLine(u8 matchLineId) { struct Sprite *sprite = &gSprites[sSlotMachine->flashMatchLineSpriteIds[matchLineId]]; sprite->sFlashing = TRUE; sprite->sNumFullFlashes = 4; sprite->sDelayTimer = 0; sprite->sColor = 0; sprite->sColorIncr = 2; sprite->sAtOriginalColor = FALSE; } // Match line flashes 4 times before the payout begins // After this it does half-brightness flashes until the payout finishes static bool8 IsMatchLineDoneFlashingBeforePayout(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->flashMatchLineSpriteIds); i++) { struct Sprite *sprite = &gSprites[sSlotMachine->flashMatchLineSpriteIds[i]]; if (sprite->sFlashing && sprite->sNumFullFlashes) return FALSE; } return TRUE; } // When payout is finished, stop lines flashing (but not if they're in the middle of a flash) static bool8 TryStopMatchLinesFlashing(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->flashMatchLineSpriteIds); i++) { if (!TryStopMatchLineFlashing(sSlotMachine->flashMatchLineSpriteIds[i])) return FALSE; } return TRUE; } static bool8 TryStopMatchLineFlashing(u8 spriteId) { struct Sprite *sprite = &gSprites[spriteId]; if (!sprite->sFlashing) return TRUE; if (sprite->sAtOriginalColor) sprite->sFlashing = FALSE; return sprite->sAtOriginalColor; } static void SpriteCB_FlashMatchingLines(struct Sprite *sprite) { s16 maxColorChange; if (sprite->sFlashing) { if (!sprite->sDelayTimer--) { sprite->sAtOriginalColor = FALSE; sprite->sDelayTimer = 1; sprite->sColor += sprite->sColorIncr; maxColorChange = 4; if (sprite->sNumFullFlashes) maxColorChange = 8; if (sprite->sColor <= 0) { // Returned to original color, reverse sprite->sAtOriginalColor = TRUE; sprite->sColorIncr = -sprite->sColorIncr; if (sprite->sNumFullFlashes) sprite->sNumFullFlashes--; } else if (sprite->sColor >= maxColorChange) { // Reached peak darkness, reverse sprite->sColorIncr = -sprite->sColorIncr; } if (sprite->sNumFullFlashes) sprite->sDelayTimer <<= 1; } MultiplyPaletteRGBComponents(sMatchLinePalOffsets[sprite->sMatchLineId], sprite->sColor, sprite->sColor, sprite->sColor); } } #undef sMatchLineId #undef sFlashing #undef sNumFullFlashes #undef sDelayTimer #undef sColor #undef sColorIncr #undef sAtOriginalColor #define sDelayTimer data[1] #define sFlashState data[2] #define sFlashDir data[3] static void FlashSlotMachineLights(void) { u8 taskId = CreateTask(Task_FlashSlotMachineLights, 6); gTasks[taskId].sFlashDir = 1; Task_FlashSlotMachineLights(taskId); } static bool8 TryStopSlotMachineLights(void) { u8 taskId = FindTaskIdByFunc(Task_FlashSlotMachineLights); if (gTasks[taskId].sFlashState == 0) { DestroyTask(taskId); LoadPalette(sSlotMachineMenu_Pal, BG_PLTT_ID(1), PLTT_SIZE_4BPP); return TRUE; } return FALSE; } static void Task_FlashSlotMachineLights(u8 taskId) { struct Task *task = &gTasks[taskId]; if (!task->sDelayTimer--) { task->sDelayTimer = 4; task->sFlashState += task->sFlashDir; if (task->sFlashState == 0 || task->sFlashState == 2) task->sFlashDir = -task->sFlashDir; } LoadPalette(sFlashingLightsPalTable[task->sFlashState], BG_PLTT_ID(1), PLTT_SIZE_4BPP); } #undef sDelayTimer #undef sFlashState #undef sFlashDir #define tState data[0] #define tNumBolts data[1] #define tSpriteId data[2] #define tTimer data[2] // re-used #define tAnimating data[15] static void CreatePikaPowerBoltTask(void) { sSlotMachine->pikaPowerBoltTaskId = CreateTask(Task_CreatePikaPowerBolt, 8); } static void AddPikaPowerBolt(u8 bolts) { struct Task *task = &gTasks[sSlotMachine->pikaPowerBoltTaskId]; ResetPikaPowerBoltTask(task); task->tState = PIKABOLT_TASK_ADD_BOLT; task->tNumBolts++; task->tAnimating = TRUE; } static void ResetPikaPowerBolts(void) { struct Task *task = &gTasks[sSlotMachine->pikaPowerBoltTaskId]; ResetPikaPowerBoltTask(task); task->tState = PIKABOLT_TASK_CLEAR_ALL; task->tAnimating = TRUE; } static bool8 IsPikaPowerBoltAnimating(void) { return gTasks[sSlotMachine->pikaPowerBoltTaskId].tAnimating; } static void Task_CreatePikaPowerBolt(u8 taskId) { sPikaPowerBoltTasks[gTasks[taskId].tState](&gTasks[taskId]); } static void PikaPowerBolt_Idle(struct Task *task) { } static void PikaPowerBolt_AddBolt(struct Task *task) { task->tSpriteId = CreatePikaPowerBoltSprite((task->tNumBolts << 3) + 20, 20); task->tState++; // PIKABOLT_TASK_WAIT_ANIM } // The bolt sprite spins around as it appears // Once the anim is done, destroy the sprite and set the bolt in the tilemap instead static void PikaPowerBolt_WaitAnim(struct Task *task) { if (gSprites[task->tSpriteId].data[7]) { s16 r5 = task->tNumBolts + 2; s16 r3 = 0; s16 r2 = 0; if (task->tNumBolts == 1) r3 = 1, r2 = 1; else if (task->tNumBolts == 16) r3 = 2, r2 = 2; sSelectedPikaPowerTile[r2] = sPikaPowerTileTable[r3][0]; LoadBgTilemap(2, &sSelectedPikaPowerTile[r2], 2, r5 + 0x40); DestroyPikaPowerBoltSprite(task->tSpriteId); task->tState = PIKABOLT_TASK_IDLE; task->tAnimating = 0; } } static void PikaPowerBolt_ClearAll(struct Task *task) { s16 r5 = task->tNumBolts + 2; s16 r3 = 0; s16 r2 = 3; if (task->tNumBolts == 1) r3 = 1, r2 = 1; else if (task->tNumBolts == 16) r3 = 2, r2 = 2; if (task->tTimer == 0) { sSelectedPikaPowerTile[r2] = sPikaPowerTileTable[r3][1]; LoadBgTilemap(2, &sSelectedPikaPowerTile[r2], 2, r5 + 0x40); task->tNumBolts--; } if (++task->tTimer >= 20) task->tTimer = 0; if (task->tNumBolts == 0) { task->tState = PIKABOLT_TASK_IDLE; task->tAnimating = 0; } } static void ResetPikaPowerBoltTask(struct Task *task) { u8 i; for (i = 2; i < NUM_TASK_DATA; i++) task->data[i] = 0; } static void LoadPikaPowerMeter(u8 bolts) { s16 i; s16 r3 = 0, r1 = 0; s16 r4 = 3; for (i = 0; i < bolts; i++, r4++) { r3 = 0, r1 = 0; if (i == 0) r3 = 1, r1 = 1; else if (i == 15) // meter is full r3 = 2, r1 = 2; sSelectedPikaPowerTile[r1] = sPikaPowerTileTable[r3][0]; LoadBgTilemap(2, &sSelectedPikaPowerTile[r1], 2, r4 + 0x40); } for (; i < 16; i++, r4++) { r3 = 0, r1 = 3; if (i == 0) r3 = 1, r1 = 1; else if (i == 15) r3 = 2, r1 = 2; sSelectedPikaPowerTile[r1] = sPikaPowerTileTable[r3][1]; LoadBgTilemap(2, &sSelectedPikaPowerTile[r1], 2, r4 + 0x40); } gTasks[sSlotMachine->pikaPowerBoltTaskId].data[1] = bolts; } #undef tState #undef tNumBolts #undef tSpriteId #undef tTimer #undef tAnimating #define tState data[0] #define tReelSpeed data[1] #define tTimer3 data[2] #define tRtReelSpeed data[4] #define tTimer2 data[4] #define tTimer1 data[5] #define tExplodeChecks data[6] static void BeginReelTime(void) { u8 taskId = CreateTask(Task_ReelTime, 7); Task_ReelTime(taskId); } static bool8 IsReelTimeTaskDone(void) { if (FindTaskIdByFunc(Task_ReelTime) == TAIL_SENTINEL) return TRUE; return FALSE; } static void Task_ReelTime(u8 taskId) { sReelTimeTasks[gTasks[taskId].tState](&gTasks[taskId]); } static void ReelTime_Init(struct Task *task) { sSlotMachine->reelTimeSpinsLeft = 0; sSlotMachine->reeltimePixelOffset = 0; sSlotMachine->reeltimePosition = 0; task->tState++; // RT_TASK_WINDOW_ENTER task->data[1] = 0; task->data[2] = 30; task->tRtReelSpeed = 1280; gSpriteCoordOffsetX = 0; gSpriteCoordOffsetY = 0; SetGpuReg(REG_OFFSET_BG1HOFS, 0); SetGpuReg(REG_OFFSET_BG1VOFS, 0); LoadReelTimeWindowTilemap(REG_OFFSET_BG3VOFS, 0); CreateReelTimeMachineSprites(); CreateReelTimePikachuSprite(); CreateReelTimeNumberSprites(); CreateReelTimeShadowSprites(); CreateReelTimeNumberGapSprite(); GetReelTimeDraw(); StopMapMusic(); PlayNewMapMusic(MUS_ROULETTE); } static void ReelTime_WindowEnter(struct Task *task) { s16 r3; gSpriteCoordOffsetX -= 8; task->data[1] += 8; r3 = ((task->data[1] + 240) & 0xff) >> 3; SetGpuReg(REG_OFFSET_BG1HOFS, task->data[1] & 0x1ff); if (r3 != task->data[2] && task->data[3] <= 18) { task->data[2] = r3; task->data[3] = task->data[1] >> 3; LoadReelTimeWindowTilemap(r3, task->data[3]); } if (task->data[1] >= 200) { task->tState++; // RT_TASK_WAIT_START_PIKA task->data[3] = 0; } AdvanceReeltimeReel(task->tRtReelSpeed >> 8); } static void ReelTime_WaitStartPikachu(struct Task *task) { AdvanceReeltimeReel(task->tRtReelSpeed >> 8); if (++task->tTimer1 >= 60) { task->tState++; // RT_TASK_PIKA_SPEEDUP1 CreateReelTimeBoltSprites(); CreateReelTimePikachuAuraSprites(); } } static void ReelTime_PikachuSpeedUp1(struct Task *task) { int i; u8 pikachuAnimIds[ARRAY_COUNT(sReelTimePikachuAnimIds)]; s16 reelTimeBoltDelays[ARRAY_COUNT(sReelTimeBoltDelays)]; s16 pikachuAuraFlashDelays[ARRAY_COUNT(sPikachuAuraFlashDelays)]; memcpy(pikachuAnimIds, sReelTimePikachuAnimIds, sizeof(sReelTimePikachuAnimIds)); memcpy(reelTimeBoltDelays, sReelTimeBoltDelays, sizeof(sReelTimeBoltDelays)); memcpy(pikachuAuraFlashDelays, sPikachuAuraFlashDelays, sizeof(sPikachuAuraFlashDelays)); AdvanceReeltimeReel(task->tRtReelSpeed >> 8); // gradually slow down the reel task->tRtReelSpeed -= 4; i = 4 - (task->tRtReelSpeed >> 8); SetReelTimeBoltDelay(reelTimeBoltDelays[i]); SetReelTimePikachuAuraFlashDelay(pikachuAuraFlashDelays[i]); StartSpriteAnimIfDifferent(&gSprites[sSlotMachine->reelTimePikachuSpriteId], pikachuAnimIds[i]); // once speed goes below 256, go to next ReelTime task and keep the speed level if (task->tRtReelSpeed <= 0x100) { task->tState++; // RT_TASK_PIKA_SPEEDUP2 task->tRtReelSpeed = 0x100; task->tTimer1 = 0; } } static void ReelTime_PikachuSpeedUp2(struct Task *task) { AdvanceReeltimeReel(task->tRtReelSpeed >> 8); if (++task->tTimer1 >= 80) { task->tState++; // RT_TASK_WAIT_REEL task->tTimer1 = 0; SetReelTimePikachuAuraFlashDelay(2); StartSpriteAnimIfDifferent(&gSprites[sSlotMachine->reelTimePikachuSpriteId], 3); } } static void ReelTime_WaitReel(struct Task *task) { AdvanceReeltimeReel(task->tRtReelSpeed >> 8); task->tRtReelSpeed = (u8)task->tRtReelSpeed + 0x80; if (++task->tTimer1 >= 80) { task->tState++; // RT_TASK_CHECK_EXPLODE task->tTimer1 = 0; } } // Check whether the ReelTime machine should explode. // // The ReelTime machine displays 0 when this task starts. If there is a positive // ReelTime draw, the machine keeps spinning until it lands on that number. // // Otherwise, it checks every 40 frames whether it should explode. If so, it // explodes immediately. After 4 checks, the machine won't explode but continues // to spin until it lands on 0. static void ReelTime_CheckExplode(struct Task *task) { AdvanceReeltimeReel(task->tRtReelSpeed >> 8); task->tRtReelSpeed = (u8)task->tRtReelSpeed + 0x40; if (++task->tTimer1 >= 40) { task->tTimer1 = 0; if (sSlotMachine->reelTimeDraw) { if (sSlotMachine->reelTimeSpinsLeft <= task->tExplodeChecks) task->tState++; // RT_TASK_LAND } else if (task->tExplodeChecks > 3) { task->tState++; // RT_TASK_LAND } else if (ShouldReelTimeMachineExplode(task->tExplodeChecks)) { task->tState = RT_TASK_EXPLODE; } task->tExplodeChecks++; } } // Reel spins until it lands on the selected outcome. static void ReelTime_LandOnOutcome(struct Task *task) { s16 reeltimePixelOffset = sSlotMachine->reeltimePixelOffset % 20; if (reeltimePixelOffset) { reeltimePixelOffset = AdvanceReeltimeReelToNextSymbol(task->tRtReelSpeed >> 8); task->tRtReelSpeed = (u8)task->tRtReelSpeed + 0x40; } else if (GetReelTimeSymbol(1) != sSlotMachine->reelTimeDraw) { AdvanceReeltimeReel(task->tRtReelSpeed >> 8); reeltimePixelOffset = sSlotMachine->reeltimePixelOffset % 20; task->tRtReelSpeed = (u8)task->tRtReelSpeed + 0x40; } if (reeltimePixelOffset == 0 && GetReelTimeSymbol(1) == sSlotMachine->reelTimeDraw) { task->tRtReelSpeed = 0; // Also initializes task->tTimer2 task->tState++; // RT_TASK_PIKA_REACT } } // Animate Pikachu reaction. Clear any power bolts the player may have won if // they got a positive ReelTime draw. static void ReelTime_PikachuReact(struct Task *task) { if (++task->tTimer2 >= 60) { StopMapMusic(); DestroyReelTimeBoltSprites(); DestroyReelTimePikachuAuraSprites(); task->tState++; // RT_TASK_WAIT_CLEAR_POWER if(sSlotMachine->reelTimeDraw == 0) { task->tTimer2 = 0xa0; StartSpriteAnimIfDifferent(&gSprites[sSlotMachine->reelTimePikachuSpriteId], 5); PlayFanfare(MUS_TOO_BAD); } else { task->tTimer2 = 0xc0; StartSpriteAnimIfDifferent(&gSprites[sSlotMachine->reelTimePikachuSpriteId], 4); gSprites[sSlotMachine->reelTimePikachuSpriteId].animCmdIndex = 0; if (sSlotMachine->pikaPowerBolts) { ResetPikaPowerBolts(); sSlotMachine->pikaPowerBolts = 0; } PlayFanfare(MUS_SLOTS_WIN); } } } static void ReelTime_WaitClearPikaPower(struct Task *task) { if ((task->tTimer2 == 0 || --task->tTimer2 == 0) && !IsPikaPowerBoltAnimating()) task->tState++; // RT_TASK_CLOSE_WINDOW_SUCCESS } static void ReelTime_CloseWindow(struct Task *task) { s16 r4; gSpriteCoordOffsetX -= 8; task->data[1] += 8; task->data[3] += 8; r4 = ((task->data[1] - 8) & 0xff) >> 3; SetGpuReg(REG_OFFSET_BG1HOFS, task->data[1] & 0x1ff); if (task->data[3] >> 3 <= 25) ClearReelTimeWindowTilemap(r4); else task->tState++; // RT_TASK_DESTROY_SPRITES } // Destroy sprites and wrap up the ReelTime task. // // If the player got a positive ReelTime draw, select the speed that the slot // reels will initially move at. static void ReelTime_DestroySprites(struct Task *task) { sSlotMachine->reelTimeSpinsUsed = 0; sSlotMachine->reelTimeSpinsLeft = sSlotMachine->reelTimeDraw; gSpriteCoordOffsetX = 0; SetGpuReg(REG_OFFSET_BG1HOFS, 0); sSlotMachine->reelSpeed = REEL_NORMAL_SPEED; DestroyReelTimePikachuSprite(); DestroyReelTimeMachineSprites(); DestroyReelTimeShadowSprites(); PlayNewMapMusic(sSlotMachine->backupMapMusic); if (sSlotMachine->reelTimeSpinsLeft == 0) { DestroyTask(FindTaskIdByFunc(Task_ReelTime)); } else { CreateDigitalDisplayScene(DIG_DISPLAY_REEL_TIME); task->tReelSpeed = ReelTimeSpeed(); task->tTimer3 = 0; task->data[3] = 0; task->tState++; // RT_TASK_SET_REEL_SPEED } } // Slow the slot reels down until they match the selected speed. static void ReelTime_SetReelSpeed(struct Task *task) { if (sSlotMachine->reelSpeed == task->tReelSpeed) task->tState++; // RT_TASK_END_SUCCESS else if (sSlotMachine->reelPixelOffsets[0] % REEL_SYMBOL_HEIGHT == 0 && (++task->tTimer3 & 0x07) == 0) sSlotMachine->reelSpeed >>= 1; } static void ReelTime_EndSuccess(struct Task *task) { if (IsDigitalDisplayAnimFinished()) DestroyTask(FindTaskIdByFunc(Task_ReelTime)); } static void ReelTime_ExplodeMachine(struct Task *task) { DestroyReelTimeMachineSprites(); DestroyReelTimeBoltSprites(); DestroyReelTimePikachuAuraSprites(); CreateReelTimeExplosionSprite(); gSprites[sSlotMachine->reelTimeShadowSpriteIds[0]].invisible = TRUE; StartSpriteAnimIfDifferent(&gSprites[sSlotMachine->reelTimePikachuSpriteId], 5); task->tState++; // RT_TASK_WAIT_EXPLODE task->data[4] = 4; task->tTimer1 = 0; StopMapMusic(); PlayFanfare(MUS_TOO_BAD); PlaySE(SE_M_EXPLOSION); } static void ReelTime_WaitExplode(struct Task *task) { gSpriteCoordOffsetY = task->data[4]; SetGpuReg(REG_OFFSET_BG1VOFS, task->data[4]); if (task->tTimer1 & 0x01) task->data[4] = -task->data[4]; if ((++task->tTimer1 & 0x1f) == 0) task->data[4] >>= 1; if (task->data[4] == 0) { DestroyReelTimeExplosionSprite(); CreateReelTimeDuckSprites(); CreateBrokenReelTimeMachineSprite(); CreateReelTimeSmokeSprite(); gSprites[sSlotMachine->reelTimeShadowSpriteIds[0]].invisible = FALSE; task->tState++; // RT_TASK_WAIT_SMOKE task->tTimer1 = 0; } } static void ReelTime_WaitSmoke(struct Task *task) { gSpriteCoordOffsetY = 0; SetGpuReg(REG_OFFSET_BG1VOFS, 0); if (IsReelTimeSmokeAnimFinished()) { task->tState++; // RT_TASK_CLOSE_WINDOW_FAILURE DestroyReelTimeSmokeSprite(); } } static void ReelTime_EndFailure(struct Task *task) { gSpriteCoordOffsetX = 0; SetGpuReg(REG_OFFSET_BG1HOFS, 0); PlayNewMapMusic(sSlotMachine->backupMapMusic); DestroyReelTimePikachuSprite(); DestroyBrokenReelTimeMachineSprite(); DestroyReelTimeShadowSprites(); DestroyReelTimeDuckSprites(); DestroyTask(FindTaskIdByFunc(Task_ReelTime)); } static void LoadReelTimeWindowTilemap(s16 a0, s16 a1) { s16 i; for (i = 4; i < 15; i++) LoadBgTilemap(1, &sReelTimeWindow_Tilemap[a1 + (i - 4) * 20], 2, 32 * i + a0); } static void ClearReelTimeWindowTilemap(s16 a0) { u8 i; for (i = 4; i < 15; i++) LoadBgTilemap(1, sEmptyTilemap, 2, 32 * i + a0); } #undef tState #undef tReelSpeed #undef tRtReelSpeed #undef tTimer2 #undef tTimer1 #undef tExplodeChecks #define tState data[0] // Info Box is the screen shown when Select is pressed static void OpenInfoBox(u8 digDisplayId) { u8 taskId = CreateTask(Task_InfoBox, 1); gTasks[taskId].data[1] = digDisplayId; Task_InfoBox(taskId); } static bool8 IsInfoBoxClosed(void) { if (FindTaskIdByFunc(Task_InfoBox) == TASK_NONE) return TRUE; else return FALSE; } static void Task_InfoBox(u8 taskId) { sInfoBoxTasks[gTasks[taskId].tState](&gTasks[taskId]); } static void InfoBox_FadeIn(struct Task *task) { BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB(0, 0, 0)); task->tState++; } static void InfoBox_WaitFade(struct Task *task) { if (!gPaletteFade.active) task->tState++; } static void InfoBox_DrawWindow(struct Task *task) { DestroyDigitalDisplayScene(); LoadInfoBoxTilemap(); AddWindow(&sWindowTemplate_InfoBox); PutWindowTilemap(1); FillWindowPixelBuffer(1, PIXEL_FILL(0)); task->tState++; } static void InfoBox_AddText(struct Task *task) { AddTextPrinterParameterized3(1, FONT_NORMAL, 2, 5, sColors_ReeltimeHelp, 0, gText_ReelTimeHelp); CopyWindowToVram(1, COPYWIN_FULL); BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB(0, 0, 0)); task->tState++; } static void InfoBox_WaitInput(struct Task *task) { if (JOY_NEW(B_BUTTON | SELECT_BUTTON)) { FillWindowPixelBuffer(1, PIXEL_FILL(0)); ClearWindowTilemap(1); CopyWindowToVram(1, COPYWIN_MAP); RemoveWindow(1); BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB(0, 0, 0)); task->tState++; } } static void InfoBox_LoadSlotMachineTilemap(struct Task *task) { LoadSlotMachineMenuTilemap(); ShowBg(3); task->tState++; } static void InfoBox_CreateDigitalDisplay(struct Task *task) { CreateDigitalDisplayScene(task->data[1]); task->tState++; } static void InfoBox_LoadPikaPowerMeter(struct Task *task) { LoadPikaPowerMeter(sSlotMachine->pikaPowerBolts); BeginNormalPaletteFade(PALETTES_ALL, 0, 16, 0, RGB(0, 0, 0)); task->tState++; } static void InfoBox_FreeTask(struct Task *task) { DestroyTask(FindTaskIdByFunc(Task_InfoBox)); } #undef tState #define sWaitForAnim data[7] static void CreateDigitalDisplayTask(void) { u8 i; struct Task *task; i = CreateTask(Task_DigitalDisplay, 3); sSlotMachine->digDisplayTaskId = i; task = &gTasks[i]; task->data[1] = -1; for (i = 4; i < NUM_TASK_DATA; i++) task->data[i] = MAX_SPRITES; } // For the panel on the right side of the slot screen static void CreateDigitalDisplayScene(u8 id) { u8 i; struct Task *task; DestroyDigitalDisplayScene(); task = &gTasks[sSlotMachine->digDisplayTaskId]; task->data[1] = id; for (i = 0; sDigitalDisplayScenes[id][i].spriteTemplateId != 255; i++) { u8 spriteId; spriteId = CreateStdDigitalDisplaySprite( sDigitalDisplayScenes[id][i].spriteTemplateId, sDigitalDisplayScenes[id][i].dispInfoId, sDigitalDisplayScenes[id][i].spriteId ); task->data[4 + i] = spriteId; } } static void AddDigitalDisplaySprite(u8 templateIdx, SpriteCallback callback, s16 x, s16 y, s16 spriteId) { u8 i; struct Task *task = &gTasks[sSlotMachine->digDisplayTaskId]; for (i = 4; i < NUM_TASK_DATA; i++) { if (task->data[i] == MAX_SPRITES) { task->data[i] = CreateDigitalDisplaySprite(templateIdx, callback, x, y, spriteId); break; } } } static void DestroyDigitalDisplayScene(void) { u8 i; struct Task *task = &gTasks[sSlotMachine->digDisplayTaskId]; if ((u16)task->data[1] != 0xFFFF) sDigitalDisplaySceneExitCallbacks[task->data[1]](); for (i = 4; i < NUM_TASK_DATA; i++) { if (task->data[i] != MAX_SPRITES) { DestroySprite(&gSprites[task->data[i]]); task->data[i] = MAX_SPRITES; } } } static bool8 IsDigitalDisplayAnimFinished(void) { u8 i; struct Task *task = &gTasks[sSlotMachine->digDisplayTaskId]; for (i = 4; i < NUM_TASK_DATA; i++) { if (task->data[i] != MAX_SPRITES) { if (gSprites[task->data[i]].sWaitForAnim) return FALSE; } } return TRUE; } static void Task_DigitalDisplay(u8 taskId) { sDigitalDisplayTasks[gTasks[taskId].data[0]](&gTasks[taskId]); } static void DigitalDisplay_Idle(struct Task *task) { } static void CreateReelSymbolSprites(void) { s16 i; s16 j; s16 x; for (i = 0, x = 0x30; i < 3; i++, x += 0x28) { for (j = 0; j < 120; j += 24) { struct Sprite *sprite = gSprites + CreateSprite(&sSpriteTemplate_ReelSymbol, x, 0, 14); sprite->oam.priority = 3; sprite->data[0] = i; sprite->data[1] = j; sprite->data[3] = -1; } } } static void SpriteCB_ReelSymbol(struct Sprite *sprite) { sprite->data[2] = sSlotMachine->reelPixelOffsets[sprite->data[0]] + sprite->data[1]; sprite->data[2] %= 120; sprite->y = sSlotMachine->reelShockOffsets[sprite->data[0]] + 28 + sprite->data[2]; sprite->sheetTileStart = GetSpriteTileStartByTag(GetSymbolAtRest(sprite->data[0], sprite->data[2] / 24)); SetSpriteSheetFrameTileNum(sprite); } static void CreateCreditPayoutNumberSprites(void) { s16 i; s16 x; // Credit number sprite for (x = 203, i = 1; i <= MAX_COINS; i *= 10, x -= 7) CreateCoinNumberSprite(x, 23, FALSE, i); // Payout number sprite for (x = 235, i = 1; i <= MAX_COINS; i *= 10, x -= 7) CreateCoinNumberSprite(x, 23, TRUE, i); } #define sIsPayout data[0] #define sDigitMin data[1] #define sDigitMax data[2] #define sCurNum data[3] // Only used to determine whether the sprite has already been updated to show the correct digit static void CreateCoinNumberSprite(s16 x, s16 y, bool8 isPayout, s16 digitMult) { struct Sprite *sprite = &gSprites[CreateSprite(&sSpriteTemplate_CoinNumber, x, y, 13)]; sprite->oam.priority = 2; sprite->sIsPayout = isPayout; sprite->sDigitMin = digitMult; sprite->sDigitMax = digitMult * 10; sprite->sCurNum = -1; } static void SpriteCB_CoinNumber(struct Sprite *sprite) { u16 tag = sSlotMachine->coins; if (sprite->sIsPayout) tag = sSlotMachine->payout; if (sprite->sCurNum != tag) { // Convert total to current digit sprite->sCurNum = tag; tag %= (u16)sprite->sDigitMax; tag /= (u16)sprite->sDigitMin; tag += GFXTAG_NUM_0; sprite->sheetTileStart = GetSpriteTileStartByTag(tag); SetSpriteSheetFrameTileNum(sprite); } } #undef sIsPayout #undef sDigitMin #undef sDigitMax #undef sCurNum static void CreateReelBackgroundSprite(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelBackground, 88, 72, 15); gSprites[spriteId].oam.priority = 3; SetSubspriteTables(&gSprites[spriteId], sSubspriteTable_ReelBackground); } static void CreateReelTimePikachuSprite(void) { struct SpriteTemplate spriteTemplate; u8 spriteId; if (sImageTable_ReelTimePikachu == NULL) sImageTable_ReelTimePikachu = AllocZeroed(sizeof(struct SpriteFrameImage) * 5); sImageTable_ReelTimePikachu[0].data = sReelTimeGfxPtr + (0 * 0x800); sImageTable_ReelTimePikachu[0].size = 0x800; sImageTable_ReelTimePikachu[1].data = sReelTimeGfxPtr + (1 * 0x800); sImageTable_ReelTimePikachu[1].size = 0x800; sImageTable_ReelTimePikachu[2].data = sReelTimeGfxPtr + (2 * 0x800); sImageTable_ReelTimePikachu[2].size = 0x800; sImageTable_ReelTimePikachu[3].data = sReelTimeGfxPtr + (3 * 0x800); sImageTable_ReelTimePikachu[3].size = 0x800; sImageTable_ReelTimePikachu[4].data = sReelTimeGfxPtr + (4 * 0x800); sImageTable_ReelTimePikachu[4].size = 0x800; spriteTemplate = sSpriteTemplate_ReelTimePikachu; spriteTemplate.images = sImageTable_ReelTimePikachu; spriteId = CreateSprite(&spriteTemplate, 280, 80, 1); gSprites[spriteId].oam.priority = 1; gSprites[spriteId].coordOffsetEnabled = TRUE; sSlotMachine->reelTimePikachuSpriteId = spriteId; } static void DestroyReelTimePikachuSprite(void) { DestroySprite(&gSprites[sSlotMachine->reelTimePikachuSpriteId]); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimePikachu); } static void SpriteCB_ReelTimePikachu(struct Sprite *sprite) { sprite->y2 = sprite->x2 = 0; if (sprite->animNum == 4) { sprite->y2 = sprite->x2 = 8; if ((sprite->animCmdIndex != 0 && sprite->animDelayCounter != 0) || (sprite->animCmdIndex == 0 && sprite->animDelayCounter == 0)) sprite->y2 = -8; } } static void CreateReelTimeMachineSprites(void) { struct SpriteTemplate spriteTemplate; u8 spriteId; struct Sprite *sprite; if (sImageTable_ReelTimeMachineAntennae == NULL) sImageTable_ReelTimeMachineAntennae = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_ReelTimeMachineAntennae[0].data = sReelTimeGfxPtr + 0x2800; sImageTable_ReelTimeMachineAntennae[0].size = 0x300; spriteTemplate = sSpriteTemplate_ReelTimeMachineAntennae; spriteTemplate.images = sImageTable_ReelTimeMachineAntennae; spriteId = CreateSprite(&spriteTemplate, 368, 52, 7); sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->coordOffsetEnabled = TRUE; SetSubspriteTables(sprite, sSubspriteTable_ReelTimeMachineAntennae); sSlotMachine->reelTimeMachineSpriteIds[0] = spriteId; if (sImageTable_ReelTimeMachine == NULL) sImageTable_ReelTimeMachine = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_ReelTimeMachine[0].data = sReelTimeGfxPtr + 0x2800 + 0x300; sImageTable_ReelTimeMachine[0].size = 0x500; spriteTemplate = sSpriteTemplate_ReelTimeMachine; spriteTemplate.images = sImageTable_ReelTimeMachine; spriteId = CreateSprite(&spriteTemplate, 368, 84, 7); sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->coordOffsetEnabled = TRUE; SetSubspriteTables(sprite, sSubspriteTable_ReelTimeMachine); sSlotMachine->reelTimeMachineSpriteIds[1] = spriteId; } static void CreateBrokenReelTimeMachineSprite(void) { struct SpriteTemplate spriteTemplate; u8 spriteId; struct Sprite *sprite; if (sImageTable_BrokenReelTimeMachine == NULL) sImageTable_BrokenReelTimeMachine = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_BrokenReelTimeMachine[0].data = sReelTimeGfxPtr + 0x3000; sImageTable_BrokenReelTimeMachine[0].size = 0x600; spriteTemplate = sSpriteTemplate_BrokenReelTimeMachine; spriteTemplate.images = sImageTable_BrokenReelTimeMachine; spriteId = CreateSprite(&spriteTemplate, 168 - gSpriteCoordOffsetX, 80, 7); sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->coordOffsetEnabled = TRUE; SetSubspriteTables(sprite, sSubspriteTable_BrokenReelTimeMachine); sSlotMachine->reelTimeBrokenMachineSpriteId = spriteId; } static void CreateReelTimeNumberSprites(void) { u8 i; s16 r5; for (i = 0, r5 = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeNumberSpriteIds); i++, r5 += 20) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeNumbers, 368, 0, 10); struct Sprite *sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->coordOffsetEnabled = TRUE; sprite->data[7] = r5; sSlotMachine->reelTimeNumberSpriteIds[i] = spriteId; } } static void SpriteCB_ReelTimeNumbers(struct Sprite *sprite) { s16 r0 = (u16)(sSlotMachine->reeltimePixelOffset + sprite->data[7]); r0 %= 40; sprite->y = r0 + 59; StartSpriteAnimIfDifferent(sprite, GetReelTimeSymbol(r0 / 20)); } static void CreateReelTimeShadowSprites(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeShadow, 368, 100, 9); struct Sprite *sprite = &gSprites[spriteId]; sprite->coordOffsetEnabled = TRUE; sprite->oam.priority = 1; SetSubspriteTables(sprite, sSubspriteTable_ReelTimeShadow); sSlotMachine->reelTimeShadowSpriteIds[0] = spriteId; spriteId = CreateSprite(&sSpriteTemplate_ReelTimeShadow, 288, 104, 4); sprite = &gSprites[spriteId]; sprite->coordOffsetEnabled = TRUE; sprite->oam.priority = 1; SetSubspriteTables(sprite, sSubspriteTable_ReelTimeShadow); sSlotMachine->reelTimeShadowSpriteIds[1] = spriteId; } // Creates a small black bar on the Reel Time machine to fill the gap between the numbers static void CreateReelTimeNumberGapSprite(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeNumberGap, 368, 76, 11); struct Sprite *sprite = &gSprites[spriteId]; sprite->coordOffsetEnabled = TRUE; sprite->oam.priority = 1; SetSubspriteTables(sprite, sSubspriteTable_ReelTimeNumberGap); sSlotMachine->reelTimeNumberGapSpriteId = spriteId; } static void DestroyReelTimeMachineSprites(void) { u8 i; DestroySprite(&gSprites[sSlotMachine->reelTimeNumberGapSpriteId]); for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeMachineSpriteIds); i++) DestroySprite(&gSprites[sSlotMachine->reelTimeMachineSpriteIds[i]]); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimeMachineAntennae); TRY_FREE_AND_SET_NULL(sImageTable_ReelTimeMachine); for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeNumberSpriteIds); i++) DestroySprite(&gSprites[sSlotMachine->reelTimeNumberSpriteIds[i]]); } static void DestroyReelTimeShadowSprites(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeShadowSpriteIds); i++) DestroySprite(&gSprites[sSlotMachine->reelTimeShadowSpriteIds[i]]); } static void DestroyBrokenReelTimeMachineSprite(void) { DestroySprite(&gSprites[sSlotMachine->reelTimeBrokenMachineSpriteId]); TRY_FREE_AND_SET_NULL(sImageTable_BrokenReelTimeMachine); } #define sDelayTimer data[0] #define sXDir data[1] #define sYDir data[2] #define sCounter data[3] #define sDelay data[7] static void CreateReelTimeBoltSprites(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeBolt, 152, 32, 5); struct Sprite *sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->hFlip = TRUE; sSlotMachine->reelTimeBoltSpriteIds[0] = spriteId; sprite->sDelayTimer = 8; sprite->sXDir = -1; sprite->sYDir = -1; sprite->sDelay = 32; spriteId = CreateSprite(&sSpriteTemplate_ReelTimeBolt, 184, 32, 5); sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sSlotMachine->reelTimeBoltSpriteIds[1] = spriteId; sprite->sXDir = 1; sprite->sYDir = -1; sprite->sDelay = 32; } static void SpriteCB_ReelTimeBolt(struct Sprite *sprite) { if (sprite->sDelayTimer != 0) { sprite->sDelayTimer--; sprite->x2 = 0; sprite->y2 = 0; sprite->invisible = TRUE; } else { sprite->invisible = FALSE; sprite->x2 += sprite->sXDir; sprite->y2 += sprite->sYDir; if (++sprite->sCounter >= 8) { sprite->sDelayTimer = sprite->sDelay; sprite->sCounter = 0; } } } static void SetReelTimeBoltDelay(s16 delay) { gSprites[sSlotMachine->reelTimeBoltSpriteIds[0]].sDelay = delay; gSprites[sSlotMachine->reelTimeBoltSpriteIds[1]].sDelay = delay; } static void DestroyReelTimeBoltSprites(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeBoltSpriteIds); i++) DestroySprite(&gSprites[sSlotMachine->reelTimeBoltSpriteIds[i]]); } #undef sDelayTimer #undef sXDir #undef sYDir #undef sCounter #undef sDelay #define sFlashPal data[0] #define sColorIdx data[5] #define sDelayTimer data[6] #define sDelay data[7] static void CreateReelTimePikachuAuraSprites(void) { // Left half of electricity orb u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimePikachuAura, 72, 80, 3); gSprites[spriteId].oam.priority = 1; gSprites[spriteId].sFlashPal = TRUE; // Only one of them needs to do the flashing, they share the palette gSprites[spriteId].sColorIdx = 0; gSprites[spriteId].sDelayTimer = 16; gSprites[spriteId].sDelay = 8; sSlotMachine->reelTimePikachuAuraSpriteIds[0] = spriteId; // Right half spriteId = CreateSprite(&sSpriteTemplate_ReelTimePikachuAura, 104, 80, 3); gSprites[spriteId].oam.priority = 1; gSprites[spriteId].hFlip = TRUE; sSlotMachine->reelTimePikachuAuraSpriteIds[1] = spriteId; } static void SpriteCB_ReelTimePikachuAura(struct Sprite *sprite) { u8 colors[] = {16, 0}; if (sprite->sFlashPal && --sprite->sDelayTimer <= 0) { MultiplyInvertedPaletteRGBComponents(OBJ_PLTT_ID(IndexOfSpritePaletteTag(PALTAG_PIKA_AURA)) + 3, colors[sprite->sColorIdx], colors[sprite->sColorIdx], colors[sprite->sColorIdx]); ++sprite->sColorIdx; sprite->sColorIdx &= 1; sprite->sDelayTimer = sprite->sDelay; } } static void SetReelTimePikachuAuraFlashDelay(s16 delay) { gSprites[sSlotMachine->reelTimePikachuAuraSpriteIds[0]].sDelay = delay; } static void DestroyReelTimePikachuAuraSprites(void) { u8 i; MultiplyInvertedPaletteRGBComponents(OBJ_PLTT_ID(IndexOfSpritePaletteTag(PALTAG_PIKA_AURA)) + 3, 0, 0, 0); for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimePikachuAuraSpriteIds); i++) DestroySprite(&gSprites[sSlotMachine->reelTimePikachuAuraSpriteIds[i]]); } #undef sFlashPal #undef sColorIdx #undef sDelayTimer #undef sDelay static void CreateReelTimeExplosionSprite(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeExplosion, 168, 80, 6); gSprites[spriteId].oam.priority = 1; sSlotMachine->reelTimeExplosionSpriteId = spriteId; } static void SpriteCB_ReelTimeExplosion(struct Sprite *sprite) { sprite->y2 = gSpriteCoordOffsetY; } static void DestroyReelTimeExplosionSprite(void) { DestroySprite(&gSprites[sSlotMachine->reelTimeExplosionSpriteId]); } // The "confusion" ducks that circle Pikachu if the Reel Time machine explodes static void CreateReelTimeDuckSprites(void) { u8 i; u16 sp[] = {0x0, 0x40, 0x80, 0xC0}; for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeDuckSpriteIds); i++) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeDuck, 80 - gSpriteCoordOffsetX, 68, 0); struct Sprite *sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->coordOffsetEnabled = TRUE; sprite->data[0] = sp[i]; sSlotMachine->reelTimeDuckSpriteIds[i] = spriteId; } } static void SpriteCB_ReelTimeDuck(struct Sprite *sprite) { sprite->data[0] -= 2; sprite->data[0] &= 0xff; sprite->x2 = Cos(sprite->data[0], 20); sprite->y2 = Sin(sprite->data[0], 6); sprite->subpriority = 0; if (sprite->data[0] >= 0x80) { sprite->subpriority = 2; } if (++sprite->data[1] >= 16) { sprite->hFlip ^= 1; sprite->data[1] = 0; } } static void DestroyReelTimeDuckSprites(void) { u8 i; for (i = 0; i < ARRAY_COUNT(sSlotMachine->reelTimeDuckSpriteIds); i++) { DestroySprite(&gSprites[sSlotMachine->reelTimeDuckSpriteIds[i]]); } } #define sState data[0] #define sMoveY data[1] #define sTimer data[2] #define sAnimFinished data[7] static void CreateReelTimeSmokeSprite(void) { u8 spriteId = CreateSprite(&sSpriteTemplate_ReelTimeSmoke, 168, 60, 8); struct Sprite *sprite = &gSprites[spriteId]; sprite->oam.priority = 1; sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; InitSpriteAffineAnim(sprite); sSlotMachine->reelTimeSmokeSpriteId = spriteId; } static void SpriteCB_ReelTimeSmoke(struct Sprite *sprite) { if (sprite->sState == 0) { if (sprite->affineAnimEnded) sprite->sState++; } else if (sprite->sState == 1) { sprite->invisible ^= 1; if (++sprite->sTimer >= 24) { sprite->sState++; sprite->sTimer = 0; } } else { sprite->invisible = TRUE; if (++sprite->sTimer >= 16) sprite->sAnimFinished = TRUE; } sprite->sMoveY &= 0xff; sprite->sMoveY += 16; sprite->y2 -= (sprite->sMoveY >> 8); } static u8 IsReelTimeSmokeAnimFinished(void) { return gSprites[sSlotMachine->reelTimeSmokeSpriteId].sAnimFinished; } static void DestroyReelTimeSmokeSprite(void) { struct Sprite *sprite = &gSprites[sSlotMachine->reelTimeSmokeSpriteId]; FreeOamMatrix(sprite->oam.matrixNum); DestroySprite(sprite); } #undef sState #undef sMoveY #undef sTimer #undef sAnimFinished static u8 CreatePikaPowerBoltSprite(s16 x, s16 y) { u8 spriteId = CreateSprite(&sSpriteTemplate_PikaPowerBolt, x, y, 12); struct Sprite *sprite = &gSprites[spriteId]; sprite->oam.priority = 2; sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; InitSpriteAffineAnim(sprite); return spriteId; } static void SpriteCB_PikaPowerBolt(struct Sprite *sprite) { if (sprite->affineAnimEnded) sprite->data[7] = TRUE; } static void DestroyPikaPowerBoltSprite(u8 spriteId) { struct Sprite *sprite = &gSprites[spriteId]; FreeOamMatrix(sprite->oam.matrixNum); DestroySprite(sprite); } static u8 CreateStdDigitalDisplaySprite(u8 templateIdx, u8 dispInfoId, s16 spriteId) { return CreateDigitalDisplaySprite(templateIdx, sDigitalDisplay_SpriteCallbacks[dispInfoId], sDigitalDisplay_SpriteCoords[dispInfoId][0], sDigitalDisplay_SpriteCoords[dispInfoId][1], spriteId); } #define sState data[0] #define sCounter data[1] #define sSpriteId data[6] static u8 CreateDigitalDisplaySprite(u8 templateIdx, SpriteCallback callback, s16 x, s16 y, s16 internalSpriteId) { struct SpriteTemplate spriteTemplate; u8 spriteId; struct Sprite *sprite; spriteTemplate = *sSpriteTemplates_DigitalDisplay[templateIdx]; spriteTemplate.images = sImageTables_DigitalDisplay[templateIdx]; spriteId = CreateSprite(&spriteTemplate, x, y, 16); sprite = &gSprites[spriteId]; sprite->oam.priority = 3; sprite->callback = callback; sprite->sSpriteId = internalSpriteId; sprite->sWaitForAnim = TRUE; if (sSubspriteTables_DigitalDisplay[templateIdx]) SetSubspriteTables(sprite, sSubspriteTables_DigitalDisplay[templateIdx]); return spriteId; } static void SpriteCB_DigitalDisplay_Static(struct Sprite *sprite) { sprite->sWaitForAnim = FALSE; } static void SpriteCB_DigitalDisplay_Smoke(struct Sprite *sprite) { s16 targetX[] = {4, -4, 4, -4}; s16 targetY[] = {4, 4, -4, -4}; if (sprite->sCounter++ >= 16) { sprite->subspriteTableNum ^= 1; sprite->sCounter = 0; } sprite->x2 = 0; sprite->y2 = 0; if (sprite->subspriteTableNum != 0) { sprite->x2 = targetX[sprite->sSpriteId]; sprite->y2 = targetY[sprite->sSpriteId]; } } static void SpriteCB_DigitalDisplay_SmokeNE(struct Sprite *sprite) { sprite->hFlip = TRUE; SpriteCB_DigitalDisplay_Smoke(sprite); } static void SpriteCB_DigitalDisplay_SmokeSW(struct Sprite *sprite) { sprite->vFlip = TRUE; SpriteCB_DigitalDisplay_Smoke(sprite); } static void SpriteCB_DigitalDisplay_SmokeSE(struct Sprite *sprite) { sprite->hFlip = TRUE; sprite->vFlip = TRUE; SpriteCB_DigitalDisplay_Smoke(sprite); } // The word "Reel" in Reel Time static void SpriteCB_DigitalDisplay_Reel(struct Sprite *sprite) { switch (sprite->sState) { case 0: sprite->x += 4; if (sprite->x >= 0xd0) { sprite->x = 0xd0; sprite->sState++; } break; case 1: if (++sprite->sCounter > 90) sprite->sState++; break; case 2: sprite->x += 4; if (sprite->x >= 0x110) sprite->sState++; break; case 3: sprite->sWaitForAnim = FALSE; break; } } // The word "Time" in Reel Time static void SpriteCB_DigitalDisplay_Time(struct Sprite *sprite) { switch (sprite->sState) { case 0: sprite->x -= 4; if (sprite->x <= 0xd0) { sprite->x = 0xd0; sprite->sState++; } break; case 1: if (++sprite->sCounter > 90) sprite->sState++; break; case 2: sprite->x -= 4; if (sprite->x <= 0x90) sprite->sState++; break; case 3: sprite->sWaitForAnim = FALSE; break; } } static void SpriteCB_DigitalDisplay_ReelTimeNumber(struct Sprite *sprite) { switch (sprite->sState) { case 0: StartSpriteAnim(sprite, sSlotMachine->reelTimeSpinsLeft - 1); sprite->sState++; // fallthrough case 1: if (++sprite->sCounter >= 4) { sprite->sState++; sprite->sCounter = 0; } break; case 2: sprite->x += 4; if (sprite->x >= 0xd0) { sprite->x = 0xd0; sprite->sState++; } break; case 3: if (++sprite->sCounter > 90) sprite->sState++; break; case 4: sprite->x += 4; if (sprite->x >= 0xf8) sprite->sState++; break; case 5: sprite->sWaitForAnim = FALSE; break; } } static void SpriteCB_DigitalDisplay_PokeballRocking(struct Sprite *sprite) { switch (sprite->sState) { case 0: sprite->animPaused = TRUE; sprite->sState++; // fallthrough case 1: sprite->y += 8; if (sprite->y >= 0x70) { sprite->y = 0x70; sprite->sCounter = 16; sprite->sState++; } break; case 2: if (sprite->data[2] == 0) { sprite->y -= sprite->sCounter; sprite->sCounter = -sprite->sCounter; if (++sprite->data[3] >= 2) { sprite->sCounter >>= 2; sprite->data[3] = 0; if (sprite->sCounter == 0) { sprite->sState++; sprite->sWaitForAnim = FALSE; sprite->animPaused = FALSE; } } } sprite->data[2]++; sprite->data[2] &= 0x07; break; } } static void SpriteCB_DigitalDisplay_Stop(struct Sprite *sprite) { switch (sprite->sState) { case 0: if (++sprite->sCounter > 8) sprite->sState++; break; case 1: sprite->y += 2; if (sprite->y >= 0x30) { sprite->y = 0x30; sprite->sState++; sprite->sWaitForAnim = FALSE; } break; } } static void SpriteCB_DigitalDisplay_AButtonStop(struct Sprite *sprite) { switch (sprite->sState) { case 0: sprite->invisible = TRUE; if (++sprite->sCounter > 0x20) { sprite->sState++; sprite->sCounter = 5; sprite->oam.mosaic = TRUE; sprite->invisible = FALSE; StartSpriteAnim(sprite, 1); SetGpuReg(REG_OFFSET_MOSAIC, ((sprite->sCounter << 4) | sprite->sCounter) << 8); } break; case 1: sprite->sCounter -= (sprite->data[2] >> 8); if (sprite->sCounter < 0) sprite->sCounter = 0; SetGpuReg(REG_OFFSET_MOSAIC, ((sprite->sCounter << 4) | sprite->sCounter) << 8); sprite->data[2] &= 0xff; sprite->data[2] += 0x80; if (sprite->sCounter == 0) { sprite->sState++; sprite->sWaitForAnim = FALSE; sprite->oam.mosaic = FALSE; StartSpriteAnim(sprite, 0); } break; } } static void SpriteCB_DigitalDisplay_PokeballShining(struct Sprite *sprite) { if (sprite->sCounter < 3) { LoadPalette(sPokeballShiningPalTable[sprite->sCounter], OBJ_PLTT_ID(IndexOfSpritePaletteTag(PALTAG_DIG_DISPLAY)), PLTT_SIZE_4BPP); if (++sprite->data[2] >= 4) { sprite->data[1]++; sprite->data[2] = 0; } } else { LoadPalette(sPokeballShiningPalTable[sprite->sCounter], OBJ_PLTT_ID(IndexOfSpritePaletteTag(PALTAG_DIG_DISPLAY)), PLTT_SIZE_4BPP); if (++sprite->data[2] >= 25) { sprite->sCounter = 0; sprite->data[2] = 0; } } StartSpriteAnimIfDifferent(sprite, 1); sprite->sWaitForAnim = FALSE; } static void SpriteCB_DigitalDisplay_RegBonus(struct Sprite *sprite) { // Elements in array correspond to R E G B O N U S s16 letterXOffset[] = { 0, -40, 0, 0, 48, 0, 24, 0}; s16 letterYOffset[] = {-32, 0, -32, -48, 0, -48, 0, -48}; s16 letterDelay[] = { 16, 12, 16, 0, 0, 4, 8, 8}; switch (sprite->sState) { case 0: sprite->x2 = letterXOffset[sprite->sSpriteId]; sprite->y2 = letterYOffset[sprite->sSpriteId]; sprite->sCounter = letterDelay[sprite->sSpriteId]; sprite->sState++; // fallthrough case 1: if (sprite->sCounter-- == 0) sprite->sState++; break; case 2: if (sprite->x2 > 0) sprite->x2 -= 4; else if (sprite->x2 < 0) sprite->x2 += 4; if (sprite->y2 > 0) sprite->y2 -= 4; else if (sprite->y2 < 0) sprite->y2 += 4; if (sprite->x2 == 0 && sprite->y2 == 0) sprite->sState++; break; } } static void SpriteCB_DigitalDisplay_BigBonus(struct Sprite *sprite) { s16 sp0[] = {160, 192, 224, 104, 80, 64, 48, 24}; if (sprite->sState == 0) { sprite->sState++; sprite->sCounter = 12; } sprite->x2 = Cos(sp0[sprite->sSpriteId], sprite->sCounter); sprite->y2 = Sin(sp0[sprite->sSpriteId], sprite->sCounter); if (sprite->sCounter != 0) sprite->sCounter--; } // For the A Button prompt when inserting bet // Initially no sprite until after the first bet static void SpriteCB_DigitalDisplay_AButtonStart(struct Sprite *sprite) { switch (sprite->sState) { case 0: sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_CLR; sSlotMachine->winOut = WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR; sSlotMachine->win0v = WIN_RANGE(32, 136); sprite->invisible = TRUE; sprite->sState++; // fallthrough case 1: sprite->sCounter += 2; sprite->data[2] = sprite->sCounter + 176; sprite->data[3] = DISPLAY_WIDTH - sprite->sCounter; if (sprite->data[2] > 208) sprite->data[2] = 208; if (sprite->data[3] < 208) sprite->data[3] = 208; sSlotMachine->win0h = (sprite->data[2] << 8) | sprite->data[3]; if (sprite->sCounter > 51) { sprite->sState++; sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR; } break; case 2: if (sSlotMachine->bet == 0) break; AddDigitalDisplaySprite(DIG_SPRITE_A_BUTTON, SpriteCallbackDummy, 208, 116, 0); sSlotMachine->win0h = WIN_RANGE(192, 224); sSlotMachine->win0v = WIN_RANGE(104, 128); sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_CLR; sprite->sState++; sprite->sCounter = 0; // fallthrough case 3: sprite->sCounter += 2; sprite->data[2] = sprite->sCounter + 192; sprite->data[3] = DISPLAY_WIDTH - 16 - sprite->sCounter; if (sprite->data[2] > 208) sprite->data[2] = 208; if (sprite->data[3] < 208) sprite->data[3] = 208; sSlotMachine->win0h = (sprite->data[2] << 8) | sprite->data[3]; if (sprite->sCounter > 15) { sprite->sState++; sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR; } break; } } static void EndDigitalDisplayScene_Dummy(void) { } static void EndDigitalDisplayScene_StopReel(void) { SetGpuReg(REG_OFFSET_MOSAIC, 0); } static void EndDigitalDisplayScene_Win(void) { LoadPalette(sDigitalDisplay_Pal, OBJ_PLTT_ID(IndexOfSpritePaletteTag(PALTAG_DIG_DISPLAY)), PLTT_SIZE_4BPP); } static void EndDigitalDisplayScene_InsertBet(void) { sSlotMachine->win0h = DISPLAY_WIDTH; sSlotMachine->win0v = DISPLAY_HEIGHT; sSlotMachine->winIn = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR; sSlotMachine->winOut = WINOUT_WIN01_BG_ALL | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR; } static void LoadSlotMachineGfx(void) { u8 i; LoadReelBackground(); sDigitalDisplayGfxPtr = Alloc(0x3200); LZDecompressWram(gSlotMachineDigitalDisplay_Gfx, sDigitalDisplayGfxPtr); sReelTimeGfxPtr = Alloc(0x3600); LZDecompressWram(sReelTimeGfx, sReelTimeGfxPtr); sSlotMachineSpritesheetsPtr = AllocZeroed(sizeof(struct SpriteSheet) * ARRAY_COUNT(sSlotMachineSpriteSheets)); for (i = 0; i < ARRAY_COUNT(sSlotMachineSpriteSheets); i++) { sSlotMachineSpritesheetsPtr[i].data = sSlotMachineSpriteSheets[i].data; sSlotMachineSpritesheetsPtr[i].size = sSlotMachineSpriteSheets[i].size; sSlotMachineSpritesheetsPtr[i].tag = sSlotMachineSpriteSheets[i].tag; } sSlotMachineSpritesheetsPtr[GFXTAG_STOP - 1].data = sDigitalDisplayGfxPtr + 0xA00; sSlotMachineSpritesheetsPtr[GFXTAG_BONUS - 1].data = sDigitalDisplayGfxPtr + 0x1400; sSlotMachineSpritesheetsPtr[GFXTAG_BIG - 1].data = sDigitalDisplayGfxPtr + 0x1600; sSlotMachineSpritesheetsPtr[GFXTAG_REG - 1].data = sDigitalDisplayGfxPtr + 0x1900; LoadSpriteSheets(sSlotMachineSpritesheetsPtr); LoadSpritePalettes(sSlotMachineSpritePalettes); } static void LoadReelBackground(void) { u8 *dest; u8 i, j; sReelBackgroundSpriteSheet = AllocZeroed(sizeof(struct SpriteSheet)); sReelBackground_Gfx = AllocZeroed(0x2000); // Background is plain white dest = sReelBackground_Gfx; for (i = 0; i < 0x40; i++) { for (j = 0; j < 0x20; j++, dest++) *dest = sReelBackground_Tilemap[j]; } sReelBackgroundSpriteSheet->data = sReelBackground_Gfx; sReelBackgroundSpriteSheet->size = 0x800; sReelBackgroundSpriteSheet->tag = GFXTAG_REEL_BG; LoadSpriteSheet(sReelBackgroundSpriteSheet); } static void LoadMenuGfx(void) { sMenuGfx = Alloc(0x2200); LZDecompressWram(gSlotMachineMenu_Gfx, sMenuGfx); LoadBgTiles(2, sMenuGfx, 0x2200, 0); LoadPalette(gSlotMachineMenu_Pal, BG_PLTT_ID(0), 5 * PLTT_SIZE_4BPP); LoadPalette(sUnkPalette, BG_PLTT_ID(13), PLTT_SIZE_4BPP); } static void LoadMenuAndReelOverlayTilemaps(void) { LoadSlotMachineMenuTilemap(); LoadSlotMachineReelOverlay(); } static void LoadSlotMachineMenuTilemap(void) { LoadBgTilemap(2, gSlotMachineMenu_Tilemap, 0x500, 0); } static void LoadSlotMachineReelOverlay(void) { s16 x, y, dx; for (x = 4; x < 18; x += 5) { for (dx = 0; dx < 4; dx++) { LoadBgTilemap(3, sReelOverlay_Tilemap, 2, x + dx + 5 * 32); LoadBgTilemap(3, sReelOverlay_Tilemap + 1, 2, x + dx + 13 * 32); LoadBgTilemap(3, sReelOverlay_Tilemap + 2, 2, x + dx + 6 * 32); LoadBgTilemap(3, sReelOverlay_Tilemap + 3, 2, x + dx + 12 * 32); } LoadBgTilemap(3, sReelOverlay_Tilemap + 4, 2, x + 6 * 32); LoadBgTilemap(3, sReelOverlay_Tilemap + 5, 2, x + 12 * 32); for (y = 7; y <= 11; y++) LoadBgTilemap(3, sReelOverlay_Tilemap + 6, 2, x + y * 32); } } // For (un)shading the gray button at the bottom of a reel when A is pressed. The button is colored in quadrants static void SetReelButtonTilemap(s16 offset, u16 topLeft, u16 topRight, u16 bottomLeft, u16 bottomRight) { sReelButtonPress_Tilemap[0] = topLeft; sReelButtonPress_Tilemap[1] = topRight; sReelButtonPress_Tilemap[2] = bottomLeft; sReelButtonPress_Tilemap[3] = bottomRight; LoadBgTilemap(2, sReelButtonPress_Tilemap, 2, 15 * 32 + offset); // Top left LoadBgTilemap(2, sReelButtonPress_Tilemap + 1, 2, 15 * 32 + 1 + offset); // Top right LoadBgTilemap(2, sReelButtonPress_Tilemap + 2, 2, 16 * 32 + offset); // Bottom left LoadBgTilemap(2, sReelButtonPress_Tilemap + 3, 2, 16 * 32 + 1 + offset); // Bottom Right } static void LoadInfoBoxTilemap(void) { LoadBgTilemap(2, gSlotMachineInfoBox_Tilemap, 0x500, 0); HideBg(3); } static void SetDigitalDisplayImagePtrs(void) { sImageTables_DigitalDisplay[DIG_SPRITE_REEL] = sImageTable_DigitalDisplay_Reel; sImageTables_DigitalDisplay[DIG_SPRITE_TIME] = sImageTable_DigitalDisplay_Time; sImageTables_DigitalDisplay[DIG_SPRITE_INSERT] = sImageTable_DigitalDisplay_Insert; sImageTables_DigitalDisplay[DIG_SPRITE_WIN] = sImageTable_DigitalDisplay_Win; sImageTables_DigitalDisplay[DIG_SPRITE_LOSE] = sImageTable_DigitalDisplay_Lose; sImageTables_DigitalDisplay[DIG_SPRITE_A_BUTTON] = sImageTable_DigitalDisplay_AButton; sImageTables_DigitalDisplay[DIG_SPRITE_SMOKE] = sImageTable_DigitalDisplay_Smoke; sImageTables_DigitalDisplay[DIG_SPRITE_NUMBER] = sImageTable_DigitalDisplay_Number; sImageTables_DigitalDisplay[DIG_SPRITE_POKE_BALL] = sImageTable_DigitalDisplay_Pokeball; sImageTables_DigitalDisplay[DIG_SPRITE_D_PAD] = sImageTable_DigitalDisplay_DPad; sImageTables_DigitalDisplay[DIG_SPRITE_STOP_S] = sImageTable_DigitalDisplay_Stop; sImageTables_DigitalDisplay[DIG_SPRITE_STOP_T] = sImageTable_DigitalDisplay_Stop; sImageTables_DigitalDisplay[DIG_SPRITE_STOP_O] = sImageTable_DigitalDisplay_Stop; sImageTables_DigitalDisplay[DIG_SPRITE_STOP_P] = sImageTable_DigitalDisplay_Stop; sImageTables_DigitalDisplay[DIG_SPRITE_BONUS_B] = sImageTable_DigitalDisplay_Bonus; sImageTables_DigitalDisplay[DIG_SPRITE_BONUS_O] = sImageTable_DigitalDisplay_Bonus; sImageTables_DigitalDisplay[DIG_SPRITE_BONUS_N] = sImageTable_DigitalDisplay_Bonus; sImageTables_DigitalDisplay[DIG_SPRITE_BONUS_U] = sImageTable_DigitalDisplay_Bonus; sImageTables_DigitalDisplay[DIG_SPRITE_BONUS_S] = sImageTable_DigitalDisplay_Bonus; sImageTables_DigitalDisplay[DIG_SPRITE_BIG_B] = sImageTable_DigitalDisplay_Big; sImageTables_DigitalDisplay[DIG_SPRITE_BIG_I] = sImageTable_DigitalDisplay_Big; sImageTables_DigitalDisplay[DIG_SPRITE_BIG_G] = sImageTable_DigitalDisplay_Big; sImageTables_DigitalDisplay[DIG_SPRITE_REG_R] = sImageTable_DigitalDisplay_Reg; sImageTables_DigitalDisplay[DIG_SPRITE_REG_E] = sImageTable_DigitalDisplay_Reg; sImageTables_DigitalDisplay[DIG_SPRITE_REG_G] = sImageTable_DigitalDisplay_Reg; sImageTables_DigitalDisplay[DIG_SPRITE_EMPTY] = NULL; } static void AllocDigitalDisplayGfx(void) { sImageTable_DigitalDisplay_Reel = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Reel[0].data = sDigitalDisplayGfxPtr; sImageTable_DigitalDisplay_Reel[0].size = 0x600; sImageTable_DigitalDisplay_Time = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Time[0].data = sDigitalDisplayGfxPtr + 0x600; sImageTable_DigitalDisplay_Time[0].size = 0x200; sImageTable_DigitalDisplay_Insert = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Insert[0].data = sDigitalDisplayGfxPtr + 0x800; sImageTable_DigitalDisplay_Insert[0].size = 0x200; sImageTable_DigitalDisplay_Stop = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Stop[0].data = sDigitalDisplayGfxPtr + 0xA00; sImageTable_DigitalDisplay_Stop[0].size = 0x200; sImageTable_DigitalDisplay_Win = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Win[0].data = sDigitalDisplayGfxPtr + 0xC00; sImageTable_DigitalDisplay_Win[0].size = 0x300; sImageTable_DigitalDisplay_Lose = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Lose[0].data = sDigitalDisplayGfxPtr + 0x1000; sImageTable_DigitalDisplay_Lose[0].size = 0x400; sImageTable_DigitalDisplay_Bonus = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Bonus[0].data = sDigitalDisplayGfxPtr + 0x1400; sImageTable_DigitalDisplay_Bonus[0].size = 0x200; sImageTable_DigitalDisplay_Big = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Big[0].data = sDigitalDisplayGfxPtr + 0x1600; sImageTable_DigitalDisplay_Big[0].size = 0x300; sImageTable_DigitalDisplay_Reg = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Reg[0].data = sDigitalDisplayGfxPtr + 0x1900; sImageTable_DigitalDisplay_Reg[0].size = 0x300; sImageTable_DigitalDisplay_AButton = AllocZeroed(sizeof(struct SpriteFrameImage) * 2); sImageTable_DigitalDisplay_AButton[0].data = sDigitalDisplayGfxPtr + 0x1C00; sImageTable_DigitalDisplay_AButton[0].size = 0x200; sImageTable_DigitalDisplay_AButton[1].data = sDigitalDisplayGfxPtr + 0x1E00; sImageTable_DigitalDisplay_AButton[1].size = 0x200; sImageTable_DigitalDisplay_Smoke = AllocZeroed(sizeof(struct SpriteFrameImage) * 1); sImageTable_DigitalDisplay_Smoke[0].data = sDigitalDisplayGfxPtr + 0x2000; sImageTable_DigitalDisplay_Smoke[0].size = 640; sImageTable_DigitalDisplay_Number = AllocZeroed(sizeof(struct SpriteFrameImage) * 5); sImageTable_DigitalDisplay_Number[0].data = sDigitalDisplayGfxPtr + 0x2280; sImageTable_DigitalDisplay_Number[0].size = 0x80; sImageTable_DigitalDisplay_Number[1].data = sDigitalDisplayGfxPtr + 0x2300; sImageTable_DigitalDisplay_Number[1].size = 0x80; sImageTable_DigitalDisplay_Number[2].data = sDigitalDisplayGfxPtr + 0x2380; sImageTable_DigitalDisplay_Number[2].size = 0x80; sImageTable_DigitalDisplay_Number[3].data = sDigitalDisplayGfxPtr + 0x2400; sImageTable_DigitalDisplay_Number[3].size = 0x80; sImageTable_DigitalDisplay_Number[4].data = sDigitalDisplayGfxPtr + 0x2480; sImageTable_DigitalDisplay_Number[4].size = 0x80; sImageTable_DigitalDisplay_Pokeball = AllocZeroed(sizeof(struct SpriteFrameImage) * 2); sImageTable_DigitalDisplay_Pokeball[0].data = sDigitalDisplayGfxPtr + 0x2600; sImageTable_DigitalDisplay_Pokeball[0].size = 0x480; sImageTable_DigitalDisplay_Pokeball[1].data = sDigitalDisplayGfxPtr + 10880; sImageTable_DigitalDisplay_Pokeball[1].size = 0x480; sImageTable_DigitalDisplay_DPad = AllocZeroed(sizeof(struct SpriteFrameImage) * 2); sImageTable_DigitalDisplay_DPad[0].data = sDigitalDisplayGfxPtr + 0x2F00; sImageTable_DigitalDisplay_DPad[0].size = 0x180; sImageTable_DigitalDisplay_DPad[1].data = sDigitalDisplayGfxPtr + 0x3080; sImageTable_DigitalDisplay_DPad[1].size = 0x180; } static const u8 sReelSymbols[NUM_REELS][SYMBOLS_PER_REEL] = { [LEFT_REEL] = { SYMBOL_7_RED, SYMBOL_CHERRY, SYMBOL_AZURILL, SYMBOL_REPLAY, SYMBOL_POWER, SYMBOL_LOTAD, SYMBOL_7_BLUE, SYMBOL_LOTAD, SYMBOL_CHERRY, SYMBOL_POWER, SYMBOL_REPLAY, SYMBOL_AZURILL, SYMBOL_7_RED, SYMBOL_POWER, SYMBOL_LOTAD, SYMBOL_REPLAY, SYMBOL_AZURILL, SYMBOL_7_BLUE, SYMBOL_POWER, SYMBOL_LOTAD, SYMBOL_REPLAY }, [MIDDLE_REEL] = { SYMBOL_7_RED, SYMBOL_CHERRY, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_AZURILL, SYMBOL_CHERRY, SYMBOL_REPLAY, SYMBOL_POWER, SYMBOL_POWER, SYMBOL_LOTAD, SYMBOL_7_BLUE, SYMBOL_LOTAD, SYMBOL_REPLAY, SYMBOL_CHERRY, SYMBOL_AZURILL, SYMBOL_LOTAD, SYMBOL_REPLAY, SYMBOL_CHERRY, SYMBOL_LOTAD, SYMBOL_REPLAY, SYMBOL_CHERRY }, [RIGHT_REEL] = { SYMBOL_7_RED, SYMBOL_POWER, SYMBOL_7_BLUE, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_AZURILL, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_POWER, SYMBOL_AZURILL, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_AZURILL, SYMBOL_POWER, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_AZURILL, SYMBOL_POWER, SYMBOL_REPLAY, SYMBOL_LOTAD, SYMBOL_CHERRY }, }; static const u8 sReelTimeSymbols[] = { 1, 0, 5, 4, 3, 2 }; // Column 0: Normal game // Column 1: Lucky game static const s16 sInitialReelPositions[NUM_REELS][2] = { [LEFT_REEL] = {0, 6}, [MIDDLE_REEL] = {0, 10}, [RIGHT_REEL] = {0, 2} }; static const u8 sSpecialDrawOdds[NUM_SLOT_MACHINE_IDS][MAX_BET] = { [SLOT_MACHINE_UNLUCKIEST] = {1, 1, 12}, [SLOT_MACHINE_UNLUCKIER] = {1, 1, 14}, [SLOT_MACHINE_UNLUCKY] = {2, 2, 14}, [SLOT_MACHINE_LUCKY] = {2, 2, 14}, [SLOT_MACHINE_LUCKIER] = {2, 3, 16}, [SLOT_MACHINE_LUCKIEST] = {3, 3, 16} }; static const u8 sBiasProbabilities_Special[][NUM_SLOT_MACHINE_IDS] = { { // Probabilities for BIAS_STRAIGHT_7 [SLOT_MACHINE_UNLUCKIEST] = 25, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 30, [SLOT_MACHINE_LUCKY] = 40, [SLOT_MACHINE_LUCKIER] = 40, [SLOT_MACHINE_LUCKIEST] = 50 }, { // Probabilities for BIAS_REELTIME [SLOT_MACHINE_UNLUCKIEST] = 25, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 30, [SLOT_MACHINE_LUCKY] = 30, [SLOT_MACHINE_LUCKIER] = 35, [SLOT_MACHINE_LUCKIEST] = 35 }, { // Probabilities for BIAS_MIXED_7 [SLOT_MACHINE_UNLUCKIEST] = 25, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 30, [SLOT_MACHINE_LUCKY] = 25, [SLOT_MACHINE_LUCKIER] = 25, [SLOT_MACHINE_LUCKIEST] = 30 } }; static const u8 sBiasProbabilities_Regular[][NUM_SLOT_MACHINE_IDS] = { { // Probabilities for BIAS_POWER [SLOT_MACHINE_UNLUCKIEST] = 20, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 25, [SLOT_MACHINE_LUCKY] = 20, [SLOT_MACHINE_LUCKIER] = 25, [SLOT_MACHINE_LUCKIEST] = 25 }, { // Probabilities for BIAS_AZURILL [SLOT_MACHINE_UNLUCKIEST] = 12, [SLOT_MACHINE_UNLUCKIER] = 15, [SLOT_MACHINE_UNLUCKY] = 15, [SLOT_MACHINE_LUCKY] = 18, [SLOT_MACHINE_LUCKIER] = 19, [SLOT_MACHINE_LUCKIEST] = 22 }, { // Probabilities for BIAS_LOTAD [SLOT_MACHINE_UNLUCKIEST] = 25, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 25, [SLOT_MACHINE_LUCKY] = 30, [SLOT_MACHINE_LUCKIER] = 30, [SLOT_MACHINE_LUCKIEST] = 40 }, { // Probabilities for BIAS_CHERRY [SLOT_MACHINE_UNLUCKIEST] = 25, [SLOT_MACHINE_UNLUCKIER] = 25, [SLOT_MACHINE_UNLUCKY] = 20, [SLOT_MACHINE_LUCKY] = 20, [SLOT_MACHINE_LUCKIER] = 15, [SLOT_MACHINE_LUCKIEST] = 15 }, { // Probabilities for BIAS_REPLAY [SLOT_MACHINE_UNLUCKIEST] = 40, [SLOT_MACHINE_UNLUCKIER] = 40, [SLOT_MACHINE_UNLUCKY] = 35, [SLOT_MACHINE_LUCKY] = 35, [SLOT_MACHINE_LUCKIER] = 40, [SLOT_MACHINE_LUCKIEST] = 40 } }; // INTENTION: // As you get more Power bolts, the odds of getting higher yields (3+ spins) // increases modestly. There's a high chance of getting at least 1 spin, which // will clear your Power bolts. // // NOTE: The way these probabilities are drawn significantly skews the odds // toward drawing 0 spins: // // | Up to N bolts | Prob intended | Prob actual | // |---------------|---------------|-------------| // | 2 | 94% | 99% | // | 6 | 31% | 57% | // | 12 | 16% | 44% | // | 15 | 2% | 31% | // | 16 | 2% | 31% | static const u8 sReelTimeProbabilities_NormalGame[][17] = { {243, 243, 243, 80, 80, 80, 80, 40, 40, 40, 40, 40, 40, 5, 5, 5, 5}, // 0 spins { 5, 5, 5, 150, 150, 150, 150, 130, 130, 130, 130, 130, 130, 100, 100, 100, 5}, // 1 spin { 4, 4, 4, 20, 20, 20, 20, 80, 80, 80, 80, 80, 80, 100, 100, 100, 40}, // 2 spins { 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 45, 45, 45, 100}, // 3 spins { 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 5, 5, 100}, // 4 spins { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6} // 5 spins }; // INTENTION: // As you get more Power bolts, the odds of getting higher yields (3+ spins) // increases substantially. There is always a high chance of getting no spins, // which lets you keep your Power bolts. // // NOTE: The way these probabilities are drawn significantly skews the odds // toward drawing 0 spins: // // | Up to N bolts | Prob intended | Prob actual | // |---------------|---------------|-------------| // | 2 | 94% | 99% | // | 6 | 78% | 96% | // | 12 | 63% | 88% | // | 15 | 27% | 58% | // | 16 | 2% | 33% | static const u8 sReelTimeProbabilities_LuckyGame[][17] = { { 243, 243, 243, 200, 200, 200, 200, 160, 160, 160, 160, 160, 160, 70, 70, 70, 5}, // 0 spins { 5, 5, 5, 25, 25, 25, 25, 5, 5, 5, 5, 5, 5, 2, 2, 2, 6}, // 1 spin { 4, 4, 4, 25, 25, 25, 25, 30, 30, 30, 30, 30, 30, 40, 40, 40, 35}, // 2 spins { 2, 2, 2, 3, 3, 3, 3, 30, 30, 30, 30, 30, 30, 100, 100, 100, 50}, // 3 spins { 1, 1, 1, 2, 2, 2, 2, 30, 30, 30, 30, 30, 30, 40, 40, 40, 100}, // 4 spins { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 60} // 5 spins }; static const u16 sReelTimeExplodeProbability[] = { 128, 175, 200, 225, 256 }; // Column 0: Probability of half-speed // Column 1: Base probability of quarter-speed static const u16 sReelTimeSpeed_Probabilities[][2] = { {10, 5}, {10, 10}, {10, 15}, {10, 25}, {10, 35} }; // Boosted odds of quarter speed during ReelTime static const u16 sQuarterSpeed_ProbabilityBoost[] = { 0, 5, 10, 15, 20 }; static const u8 sBiasSymbols[] = { SYMBOL_REPLAY, // BIAS_REPLAY SYMBOL_CHERRY, // BIAS_CHERRY SYMBOL_LOTAD, // BIAS_LOTAD SYMBOL_AZURILL, // BIAS_AZURILL SYMBOL_POWER, // BIAS_POWER SYMBOL_7_RED, // BIAS_REELTIME SYMBOL_7_RED, // BIAS_MIXED_7 SYMBOL_7_RED // BIAS_STRAIGHT_7 }; static const u16 sBiasesSpecial[] = { BIAS_STRAIGHT_7, BIAS_REELTIME, BIAS_MIXED_7 }; static const u16 sBiasesRegular[] = { BIAS_POWER, BIAS_AZURILL, BIAS_LOTAD, BIAS_CHERRY, BIAS_REPLAY }; static const u8 sSymbolToMatch[] = { [SYMBOL_7_RED] = MATCH_RED_7, [SYMBOL_7_BLUE] = MATCH_BLUE_7, [SYMBOL_AZURILL] = MATCH_AZURILL, [SYMBOL_LOTAD] = MATCH_LOTAD, [SYMBOL_CHERRY] = MATCH_CHERRY, [SYMBOL_POWER] = MATCH_POWER, [SYMBOL_REPLAY] = MATCH_REPLAY }; static const u16 sSlotMatchFlags[] = { [MATCH_CHERRY] = 1 << MATCH_CHERRY, [MATCH_TOPBOT_CHERRY] = 1 << MATCH_TOPBOT_CHERRY, [MATCH_REPLAY] = 1 << MATCH_REPLAY, [MATCH_LOTAD] = 1 << MATCH_LOTAD, [MATCH_AZURILL] = 1 << MATCH_AZURILL, [MATCH_POWER] = 1 << MATCH_POWER, [MATCH_MIXED_7] = 1 << MATCH_MIXED_7, [MATCH_RED_7] = 1 << MATCH_RED_7, [MATCH_BLUE_7] = 1 << MATCH_BLUE_7 }; static const u16 sSlotPayouts[] = { [MATCH_CHERRY] = 2, [MATCH_TOPBOT_CHERRY] = 4, [MATCH_REPLAY] = 0, [MATCH_LOTAD] = 6, [MATCH_AZURILL] = 12, [MATCH_POWER] = 3, [MATCH_MIXED_7] = 90, [MATCH_RED_7] = 300, [MATCH_BLUE_7] = 300 }; static const s16 sDigitalDisplay_SpriteCoords[][2] = { [DIG_DISPINFO_INSERT] = { 208, 56}, [DIG_DISPINFO_STOP_S] = { 184, 0}, [DIG_DISPINFO_STOP_T] = { 200, 8}, [DIG_DISPINFO_STOP_O] = { 216, 16}, [DIG_DISPINFO_STOP_P] = { 232, 24}, [DIG_DISPINFO_A_BUTTON_STOP] = { 208, 72}, [DIG_DISPINFO_POKE_BALL_ROCKING] = { 208, 8}, [DIG_DISPINFO_WIN] = { 208, 64}, [DIG_DISPINFO_LOSE] = { 208, 56}, [DIG_DISPINFO_SMOKE_NW] = { 192, 88}, [DIG_DISPINFO_SMOKE_NE] = { 224, 88}, [DIG_DISPINFO_SMOKE_SW] = { 192, 120}, [DIG_DISPINFO_SMOKE_SE] = { 224, 120}, [DIG_DISPINFO_REEL] = { 144, 56}, [DIG_DISPINFO_TIME] = { 272, 88}, [DIG_DISPINFO_NUMBER] = { 168, 112}, [DIG_DISPINFO_DPAD] = { 208, 84}, [DIG_DISPINFO_POKE_BALL_SHINING] = { 208, 112}, [DIG_DISPINFO_REG_R] = { 188, 52}, [DIG_DISPINFO_REG_E] = { 208, 52}, [DIG_DISPINFO_REG_G] = { 228, 52}, [DIG_DISPINFO_REG_BONUS_B] = { 184, 72}, [DIG_DISPINFO_REG_BONUS_O] = { 196, 72}, [DIG_DISPINFO_REG_BONUS_N] = { 208, 72}, [DIG_DISPINFO_REG_BONUS_U] = { 220, 72}, [DIG_DISPINFO_REG_BONUS_S] = { 232, 72}, [DIG_DISPINFO_BIG_B] = { 188, 52}, [DIG_DISPINFO_BIG_I] = { 208, 52}, [DIG_DISPINFO_BIG_G] = { 228, 52}, [DIG_DISPINFO_BIG_BONUS_B] = { 184, 72}, [DIG_DISPINFO_BIG_BONUS_O] = { 196, 72}, [DIG_DISPINFO_BIG_BONUS_N] = { 208, 72}, [DIG_DISPINFO_BIG_BONUS_U] = { 220, 72}, [DIG_DISPINFO_BIG_BONUS_S] = { 232, 72}, [DIG_DISPINFO_A_BUTTON_START] = { 0, 0} // Initially offscreen }; static const SpriteCallback sDigitalDisplay_SpriteCallbacks[] = { [DIG_DISPINFO_INSERT] = SpriteCB_DigitalDisplay_Static, [DIG_DISPINFO_STOP_S] = SpriteCB_DigitalDisplay_Stop, [DIG_DISPINFO_STOP_T] = SpriteCB_DigitalDisplay_Stop, [DIG_DISPINFO_STOP_O] = SpriteCB_DigitalDisplay_Stop, [DIG_DISPINFO_STOP_P] = SpriteCB_DigitalDisplay_Stop, [DIG_DISPINFO_A_BUTTON_STOP] = SpriteCB_DigitalDisplay_AButtonStop, [DIG_DISPINFO_POKE_BALL_ROCKING] = SpriteCB_DigitalDisplay_PokeballRocking, [DIG_DISPINFO_WIN] = SpriteCB_DigitalDisplay_Static, [DIG_DISPINFO_LOSE] = SpriteCB_DigitalDisplay_Static, [DIG_DISPINFO_SMOKE_NW] = SpriteCB_DigitalDisplay_Smoke, [DIG_DISPINFO_SMOKE_NE] = SpriteCB_DigitalDisplay_SmokeNE, [DIG_DISPINFO_SMOKE_SW] = SpriteCB_DigitalDisplay_SmokeSW, [DIG_DISPINFO_SMOKE_SE] = SpriteCB_DigitalDisplay_SmokeSE, [DIG_DISPINFO_REEL] = SpriteCB_DigitalDisplay_Reel, [DIG_DISPINFO_TIME] = SpriteCB_DigitalDisplay_Time, [DIG_DISPINFO_NUMBER] = SpriteCB_DigitalDisplay_ReelTimeNumber, [DIG_DISPINFO_DPAD] = SpriteCB_DigitalDisplay_Static, [DIG_DISPINFO_POKE_BALL_SHINING] = SpriteCB_DigitalDisplay_PokeballShining, [DIG_DISPINFO_REG_R] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_E] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_G] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_BONUS_B] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_BONUS_O] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_BONUS_N] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_BONUS_U] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_REG_BONUS_S] = SpriteCB_DigitalDisplay_RegBonus, [DIG_DISPINFO_BIG_B] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_I] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_G] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_BONUS_B] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_BONUS_O] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_BONUS_N] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_BONUS_U] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_BIG_BONUS_S] = SpriteCB_DigitalDisplay_BigBonus, [DIG_DISPINFO_A_BUTTON_START] = SpriteCB_DigitalDisplay_AButtonStart }; static const struct DigitalDisplaySprite sDigitalDisplay_InsertBet[] = { {DIG_SPRITE_EMPTY, DIG_DISPINFO_A_BUTTON_START, 0}, // Sprite replaced with DIG_SPRITE_A_BUTTON after first bet {DIG_SPRITE_INSERT, DIG_DISPINFO_INSERT, 0}, {DIG_SPRITE_D_PAD, DIG_DISPINFO_DPAD, 0}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_StopReel[] = { {DIG_SPRITE_STOP_S, DIG_DISPINFO_STOP_S, 0}, {DIG_SPRITE_STOP_T, DIG_DISPINFO_STOP_T, 0}, {DIG_SPRITE_STOP_O, DIG_DISPINFO_STOP_O, 0}, {DIG_SPRITE_STOP_P, DIG_DISPINFO_STOP_P, 0}, {DIG_SPRITE_A_BUTTON, DIG_DISPINFO_A_BUTTON_STOP, 0}, {DIG_SPRITE_POKE_BALL, DIG_DISPINFO_POKE_BALL_ROCKING, 0}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_Win[] = { {DIG_SPRITE_WIN, DIG_DISPINFO_WIN, 0}, {DIG_SPRITE_POKE_BALL, DIG_DISPINFO_POKE_BALL_SHINING, 0}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_Lose[] = { {DIG_SPRITE_LOSE, DIG_DISPINFO_LOSE, 0}, {DIG_SPRITE_SMOKE, DIG_DISPINFO_SMOKE_NW, 0}, {DIG_SPRITE_SMOKE, DIG_DISPINFO_SMOKE_NE, 1}, {DIG_SPRITE_SMOKE, DIG_DISPINFO_SMOKE_SW, 2}, {DIG_SPRITE_SMOKE, DIG_DISPINFO_SMOKE_SE, 3}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_ReelTime[] = { {DIG_SPRITE_REEL, DIG_DISPINFO_REEL, 0}, {DIG_SPRITE_TIME, DIG_DISPINFO_TIME, 0}, {DIG_SPRITE_NUMBER, DIG_DISPINFO_NUMBER, 0}, // Number of reel time spins left DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_BonusBig[] = { {DIG_SPRITE_BIG_B, DIG_DISPINFO_BIG_B, 0}, {DIG_SPRITE_BIG_I, DIG_DISPINFO_BIG_I, 1}, {DIG_SPRITE_BIG_G, DIG_DISPINFO_BIG_G, 2}, {DIG_SPRITE_BONUS_B, DIG_DISPINFO_BIG_BONUS_B, 3}, {DIG_SPRITE_BONUS_O, DIG_DISPINFO_BIG_BONUS_O, 4}, {DIG_SPRITE_BONUS_N, DIG_DISPINFO_BIG_BONUS_N, 5}, {DIG_SPRITE_BONUS_U, DIG_DISPINFO_BIG_BONUS_U, 6}, {DIG_SPRITE_BONUS_S, DIG_DISPINFO_BIG_BONUS_S, 7}, {DIG_SPRITE_POKE_BALL, DIG_DISPINFO_POKE_BALL_SHINING, 0}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite sDigitalDisplay_BonusRegular[] = { {DIG_SPRITE_REG_R, DIG_DISPINFO_REG_R, 0}, {DIG_SPRITE_REG_E, DIG_DISPINFO_REG_E, 1}, {DIG_SPRITE_REG_G, DIG_DISPINFO_REG_G, 2}, {DIG_SPRITE_BONUS_B, DIG_DISPINFO_REG_BONUS_B, 3}, {DIG_SPRITE_BONUS_O, DIG_DISPINFO_REG_BONUS_O, 4}, {DIG_SPRITE_BONUS_N, DIG_DISPINFO_REG_BONUS_N, 5}, {DIG_SPRITE_BONUS_U, DIG_DISPINFO_REG_BONUS_U, 6}, {DIG_SPRITE_BONUS_S, DIG_DISPINFO_REG_BONUS_S, 7}, {DIG_SPRITE_POKE_BALL, DIG_DISPINFO_POKE_BALL_SHINING, 0}, DIG_SPRITE_DUMMY }; static const struct DigitalDisplaySprite *const sDigitalDisplayScenes[] = { [DIG_DISPLAY_INSERT_BET] = sDigitalDisplay_InsertBet, [DIG_DISPLAY_STOP_REEL] = sDigitalDisplay_StopReel, [DIG_DISPLAY_WIN] = sDigitalDisplay_Win, [DIG_DISPLAY_LOSE] = sDigitalDisplay_Lose, [DIG_DISPLAY_REEL_TIME] = sDigitalDisplay_ReelTime, [DIG_DISPLAY_BONUS_REG] = sDigitalDisplay_BonusRegular, [DIG_DISPLAY_BONUS_BIG] = sDigitalDisplay_BonusBig }; static void (*const sDigitalDisplaySceneExitCallbacks[])(void) = { [DIG_DISPLAY_INSERT_BET] = EndDigitalDisplayScene_InsertBet, [DIG_DISPLAY_STOP_REEL] = EndDigitalDisplayScene_StopReel, [DIG_DISPLAY_WIN] = EndDigitalDisplayScene_Win, [DIG_DISPLAY_LOSE] = EndDigitalDisplayScene_Dummy, [DIG_DISPLAY_REEL_TIME] = EndDigitalDisplayScene_Dummy, [DIG_DISPLAY_BONUS_REG] = EndDigitalDisplayScene_Win, [DIG_DISPLAY_BONUS_BIG] = EndDigitalDisplayScene_Win }; static const struct OamData sOam_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(8x8), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(8x8), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_8x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(8x16), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(8x16), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(16x16), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(16x16), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_16x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(16x32), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(16x32), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_32x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(32x32), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(32x32), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_32x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(32x64), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(32x64), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_64x32 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(64x32), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(64x32), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct OamData sOam_64x64 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, .mosaic = FALSE, .bpp = ST_OAM_4BPP, .shape = SPRITE_SHAPE(64x64), .x = 0, .matrixNum = 0, .size = SPRITE_SIZE(64x64), .tileNum = 0, .priority = 0, .paletteNum = 0, .affineParam = 0, }; static const struct SpriteFrameImage sImageTable_ReelTimeNumbers[] = { { gSlotMachineReelTimeNumber0, 0x80 }, { gSlotMachineReelTimeNumber1, 0x80 }, { gSlotMachineReelTimeNumber2, 0x80 }, { gSlotMachineReelTimeNumber3, 0x80 }, { gSlotMachineReelTimeNumber4, 0x80 }, { gSlotMachineReelTimeNumber5, 0x80 }, }; static const struct SpriteFrameImage sImageTable_ReelTimeShadow[] = { gSlotMachineReelTimeShadow, 0x200 }; static const struct SpriteFrameImage sImageTable_ReelTimeNumberGap[] = { gSlotMachineReelTimeNumberGap_Gfx, 0x40 }; static const struct SpriteFrameImage sImageTable_ReelTimeBolt[] = { { gSlotMachineReelTimeBolt0, 0x100 }, { gSlotMachineReelTimeBolt1, 0x100 }, }; static const struct SpriteFrameImage sImageTable_ReelTimePikachuAura[] = { gSlotMachineReelTimePikaAura, 0x400 }; static const struct SpriteFrameImage sImageTable_ReelTimeExplosion[] = { { gSlotMachineReelTimeExplosion0, 0x200 }, { gSlotMachineReelTimeExplosion1, 0x200 }, }; static const struct SpriteFrameImage sImageTable_ReelTimeDuck[] = { gSlotMachineReelTimeDuck, 0x20}; static const struct SpriteFrameImage sImageTable_ReelTimeSmoke[] = { gSlotMachineReelTimeSmoke, 0x80}; static const struct SpriteFrameImage sImageTable_PikaPowerBolt[] = { gSlotMachinePikaPowerBolt, 0x20}; static const union AnimCmd sAnim_SingleFrame[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeDuck[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimePikachu_Still[] = { ANIMCMD_FRAME(0, 16), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimePikachu_ChargingSlow[] = { ANIMCMD_FRAME(1, 16), ANIMCMD_FRAME(0, 16), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimePikachu_ChargingMedium[] = { ANIMCMD_FRAME(1, 8), ANIMCMD_FRAME(0, 8), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimePikachu_ChargingFast[] = { ANIMCMD_FRAME(1, 4), ANIMCMD_FRAME(0, 4), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimePikachu_Cheering[] = { ANIMCMD_FRAME(2, 32), ANIMCMD_FRAME(3, 32), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimePikachu_FellOver[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_0[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_1[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_2[] = { ANIMCMD_FRAME(2, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_3[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_4[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeNumber_5[] = { ANIMCMD_FRAME(5, 1), ANIMCMD_END }; static const union AnimCmd sAnim_ReelTimeBolt[] = { ANIMCMD_FRAME(0, 4), ANIMCMD_FRAME(1, 4), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_ReelTimeExplosion[] = { ANIMCMD_FRAME(0, 16), ANIMCMD_FRAME(1, 16), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_DigitalDisplay_AButton_Flashing[] = { ANIMCMD_FRAME(0, 30), ANIMCMD_FRAME(1, 30), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_DigitalDisplay_AButton_Static[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_DPad_Flashing[] = { ANIMCMD_FRAME(0, 30), ANIMCMD_FRAME(1, 30), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_DigitalDisplay_Pokeball_Rocking[] = { ANIMCMD_FRAME(0, 16), ANIMCMD_FRAME(1, 16), ANIMCMD_FRAME(0, 16), ANIMCMD_FRAME(1, 16, .hFlip = TRUE), ANIMCMD_JUMP(0) }; static const union AnimCmd sAnim_DigitalDisplay_Pokeball_Static[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_Number_1[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_Number_2[] = { ANIMCMD_FRAME(1, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_Number_3[] = { ANIMCMD_FRAME(2, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_Number_4[] = { ANIMCMD_FRAME(3, 1), ANIMCMD_END }; static const union AnimCmd sAnim_DigitalDisplay_Number_5[] = { ANIMCMD_FRAME(4, 1), ANIMCMD_END }; static const union AnimCmd *const sAnims_SingleFrame[] = { sAnim_SingleFrame }; static const union AnimCmd *const sAnims_ReelTimeDuck[] = { sAnim_ReelTimeDuck }; static const union AnimCmd *const sAnims_ReelTimePikachu[] = { sAnim_ReelTimePikachu_Still, sAnim_ReelTimePikachu_ChargingSlow, sAnim_ReelTimePikachu_ChargingMedium, sAnim_ReelTimePikachu_ChargingFast, sAnim_ReelTimePikachu_Cheering, sAnim_ReelTimePikachu_FellOver }; static const union AnimCmd *const sAnims_ReelTimeNumbers[] = { sAnim_ReelTimeNumber_0, sAnim_ReelTimeNumber_1, sAnim_ReelTimeNumber_2, sAnim_ReelTimeNumber_3, sAnim_ReelTimeNumber_4, sAnim_ReelTimeNumber_5 }; static const union AnimCmd *const sAnims_ReelTimeBolt[] = { sAnim_ReelTimeBolt }; static const union AnimCmd *const sAnims_ReelTimeExplosion[] = { sAnim_ReelTimeExplosion }; static const union AnimCmd *const sAnims_DigitalDisplay_AButton[] = { sAnim_DigitalDisplay_AButton_Flashing, sAnim_DigitalDisplay_AButton_Static }; static const union AnimCmd *const sAnims_DigitalDisplay_DPad[] = { sAnim_DigitalDisplay_DPad_Flashing }; static const union AnimCmd *const sAnims_DigitalDisplay_Pokeball[] = { sAnim_DigitalDisplay_Pokeball_Rocking, sAnim_DigitalDisplay_Pokeball_Static }; static const union AnimCmd *const sAnims_DigitalDisplay_Number[] = { sAnim_DigitalDisplay_Number_1, sAnim_DigitalDisplay_Number_2, sAnim_DigitalDisplay_Number_3, sAnim_DigitalDisplay_Number_4, sAnim_DigitalDisplay_Number_5 }; static const union AffineAnimCmd sAffineAnim_ReelTimeSmoke[] = { AFFINEANIMCMD_FRAME(16, 16, 0, 0), AFFINEANIMCMD_LOOP(0), AFFINEANIMCMD_FRAME(1, 1, 0, 1), AFFINEANIMCMD_LOOP(0xFF), AFFINEANIMCMD_END }; static const union AffineAnimCmd *const sAffineAnims_ReelTimeSmoke[] = { sAffineAnim_ReelTimeSmoke }; // Spin as it appears static const union AffineAnimCmd sAffineAnim_PikaPowerBolt[] = { AFFINEANIMCMD_FRAME(0, 0, 8, 32), AFFINEANIMCMD_FRAME(0, 0, 6, 32), AFFINEANIMCMD_FRAME(0, 0, 4, 16), AFFINEANIMCMD_FRAME(0, 0, 12, 2), AFFINEANIMCMD_FRAME(0, 0, -12, 4), AFFINEANIMCMD_FRAME(0, 0, 12, 2), AFFINEANIMCMD_FRAME(0, 0, 12, 2), AFFINEANIMCMD_FRAME(0, 0, -12, 4), AFFINEANIMCMD_FRAME(0, 0, 12, 2), AFFINEANIMCMD_END }; static const union AffineAnimCmd *const sAffineAnims_PikaPowerBolt[] = { sAffineAnim_PikaPowerBolt }; static const struct SpriteTemplate sSpriteTemplate_ReelSymbol = { .tileTag = GFXTAG_SYMBOLS_START, .paletteTag = PALTAG_REEL, .oam = &sOam_32x32, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelSymbol }; static const struct SpriteTemplate sSpriteTemplate_CoinNumber = { .tileTag = GFXTAG_NUMBERS_START, .paletteTag = PALTAG_MISC, .oam = &sOam_8x16, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_CoinNumber }; static const struct SpriteTemplate sSpriteTemplate_ReelBackground = { .tileTag = GFXTAG_REEL_BG, .paletteTag = PALTAG_REEL, .oam = &sOam_64x64, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_ReelTimePikachu = { .tileTag = TAG_NONE, .paletteTag = PALTAG_REEL_TIME_PIKACHU, .oam = &sOam_64x64, .anims = sAnims_ReelTimePikachu, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimePikachu }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeMachineAntennae = { .tileTag = TAG_NONE, .paletteTag = PALTAG_REEL_TIME_MISC, .oam = &sOam_8x16, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeMachine = { .tileTag = TAG_NONE, .paletteTag = PALTAG_REEL_TIME_MACHINE, .oam = &sOam_8x16, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_BrokenReelTimeMachine = { .tileTag = TAG_NONE, .paletteTag = PALTAG_REEL_TIME_MACHINE, .oam = &sOam_8x16, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeNumbers = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_16x16, .anims = sAnims_ReelTimeNumbers, .images = sImageTable_ReelTimeNumbers, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimeNumbers }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeShadow = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_16x16, .anims = sAnims_SingleFrame, .images = sImageTable_ReelTimeShadow, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeNumberGap = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_16x16, .anims = sAnims_SingleFrame, .images = sImageTable_ReelTimeNumberGap, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeBolt = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_16x32, .anims = sAnims_ReelTimeBolt, .images = sImageTable_ReelTimeBolt, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimeBolt }; static const struct SpriteTemplate sSpriteTemplate_ReelTimePikachuAura = { .tileTag = TAG_NONE, .paletteTag = PALTAG_PIKA_AURA, .oam = &sOam_32x64, .anims = sAnims_SingleFrame, .images = sImageTable_ReelTimePikachuAura, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimePikachuAura }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeExplosion = { .tileTag = TAG_NONE, .paletteTag = PALTAG_EXPLOSION, .oam = &sOam_32x32, .anims = sAnims_ReelTimeExplosion, .images = sImageTable_ReelTimeExplosion, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimeExplosion }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeDuck = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_8x8, .anims = sAnims_ReelTimeDuck, .images = sImageTable_ReelTimeDuck, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_ReelTimeDuck }; static const struct SpriteTemplate sSpriteTemplate_ReelTimeSmoke = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_16x16, .anims = sAnims_SingleFrame, .images = sImageTable_ReelTimeSmoke, .affineAnims = sAffineAnims_ReelTimeSmoke, .callback = SpriteCB_ReelTimeSmoke }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Reel = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Time = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Insert = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Stop = { .tileTag = GFXTAG_STOP, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Win = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_64x32, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Lose = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_64x32, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Bonus = { .tileTag = GFXTAG_BONUS, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Big = { .tileTag = GFXTAG_BIG, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Reg = { .tileTag = GFXTAG_REG, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_AButton = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_32x32, .anims = sAnims_DigitalDisplay_AButton, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Smoke = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Number = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_16x16, .anims = sAnims_DigitalDisplay_Number, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_Pokeball = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_DigitalDisplay_Pokeball, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_DigitalDisplay_DPad = { .tileTag = TAG_NONE, .paletteTag = PALTAG_DIG_DISPLAY, .oam = &sOam_8x8, .anims = sAnims_DigitalDisplay_DPad, .images = NULL, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; static const struct SpriteTemplate sSpriteTemplate_PikaPowerBolt = { .tileTag = TAG_NONE, .paletteTag = PALTAG_MISC, .oam = &sOam_8x8, .anims = sAnims_SingleFrame, .images = sImageTable_PikaPowerBolt, .affineAnims = sAffineAnims_PikaPowerBolt, .callback = SpriteCB_PikaPowerBolt }; /* [0 ][1 ] [ ][ ] [ ][ ] [ ][ ] [ ][ ] [______________][______________] 128x128 [ ]+ <- Origin ] [ ][ ] [ ][ ] [ ][ ] [ ][ ] [2 ][3 ] */ static const struct Subsprite sSubsprites_ReelBackground[] = { { .x = -64, .y = -64, .shape = SPRITE_SHAPE(64x64), .size = SPRITE_SIZE(64x64), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = -64, .shape = SPRITE_SHAPE(64x64), .size = SPRITE_SIZE(64x64), .tileOffset = 0, .priority = 3, }, { .x = -64, .y = 0, .shape = SPRITE_SHAPE(64x64), .size = SPRITE_SIZE(64x64), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = 0, .shape = SPRITE_SHAPE(64x64), .size = SPRITE_SIZE(64x64), .tileOffset = 0, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_ReelBackground[] = { ARRAY_COUNT(sSubsprites_ReelBackground), sSubsprites_ReelBackground }; /* v-- Origin on 3 [0_____][1_____] [2_____][3_____] 64x24 [4 ][5 ] */ static const struct Subsprite sSubsprites_ReelTimeMachineAntennae[] = { { .x = -32, .y = -12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 1, }, { .x = 0, .y = -12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 1, }, { .x = -32, .y = -4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 1, }, { .x = 0, .y = -4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 1, }, { .x = -32, .y = 4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 16, .priority = 1, }, { .x = 0, .y = 4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 20, .priority = 1 } }; static const struct SubspriteTable sSubspriteTable_ReelTimeMachineAntennae[] = { ARRAY_COUNT(sSubsprites_ReelTimeMachineAntennae), sSubsprites_ReelTimeMachineAntennae }; /* [0 ] [ ] [ + Origin] [______________] 64x40 [1 ][2 ] */ static const struct Subsprite sSubsprites_ReelTimeMachine[] = { { .x = -32, .y = -20, .shape = SPRITE_SHAPE(64x32), .size = SPRITE_SIZE(64x32), .tileOffset = 0, .priority = 1, }, { .x = -32, .y = 12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 32, .priority = 1, }, { .x = 0, .y = 12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 36, .priority = 1, } }; static const struct SubspriteTable sSubspriteTable_ReelTimeMachine[] = { ARRAY_COUNT(sSubsprites_ReelTimeMachine), sSubsprites_ReelTimeMachine }; /* [0 ] [ ] [ + Origin] [______________] 64x48 [1 ][2 ] [3 ][4 ] */ static const struct Subsprite sSubsprites_BrokenReelTimeMachine[] = { { .x = -32, .y = -24, .shape = SPRITE_SHAPE(64x32), .size = SPRITE_SIZE(64x32), .tileOffset = 0, .priority = 1, }, { .x = -32, .y = 8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 32, .priority = 1, }, { .x = 0, .y = 8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 36, .priority = 1, }, { .x = -32, .y = 16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 40, .priority = 1, }, { .x = 0, .y = 16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 44, .priority = 1, } }; static const struct SubspriteTable sSubspriteTable_BrokenReelTimeMachine[] = { ARRAY_COUNT(sSubsprites_BrokenReelTimeMachine), sSubsprites_BrokenReelTimeMachine }; /* v-- Origin on 3 [0_____][1_____] [2 ][3 ] 64x16 */ static const struct Subsprite sSubsprites_ReelTimeShadow[] = { { .x = -32, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 1, }, { .x = 0, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 1, }, { .x = -32, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 1, }, { .x = 0, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 1, } }; static const struct SubspriteTable sSubspriteTable_ReelTimeShadow[] = { ARRAY_COUNT(sSubsprites_ReelTimeShadow), sSubsprites_ReelTimeShadow }; /* [0_] 16x24 [1+] <--Origin [2_] */ static const struct Subsprite sSubsprites_ReelTimeNumberGap[] = { { .x = -8, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 1, }, { .x = -8, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 1, }, { .x = -8, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 1, } }; static const struct SubspriteTable sSubspriteTable_ReelTimeNumberGap[] = { ARRAY_COUNT(sSubsprites_ReelTimeNumberGap), sSubsprites_ReelTimeNumberGap }; /* [0 ] [ ] [ + Origin] [______________] 64x48 [1 ][2 ] [3 ][4 ] */ static const struct Subsprite sSubsprites_DigitalDisplay_Reel[] = { { .x = -32, .y = -24, .shape = SPRITE_SHAPE(64x32), .size = SPRITE_SIZE(64x32), .tileOffset = 0, .priority = 3, }, { .x = -32, .y = 8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 32, .priority = 3, }, { .x = 0, .y = 8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 36, .priority = 3, }, { .x = -32, .y = 16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 40, .priority = 3, }, { .x = 0, .y = 16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 44, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Reel[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Reel), sSubsprites_DigitalDisplay_Reel }; /* v-- Origin on 3 [0_____][1_____] [2 ][3 ] 64x16 */ static const struct Subsprite sSubsprites_DigitalDisplay_Time[] = { { .x = -32, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 3, }, { .x = -32, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 3, }, { .x = 0, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Time[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Time), sSubsprites_DigitalDisplay_Time }; /* v-- Origin on 3 [0_____][1_____] [2 ][3 ] 64x16 */ static const struct Subsprite sSubsprites_DigitalDisplay_Insert[] = { { .x = -32, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 3, }, { .x = -32, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 3, }, { .x = 0, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Insert[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Insert), sSubsprites_DigitalDisplay_Insert }; /* v-- Origin on 3 [0_____][1_____] [2 ][3 ] 64x16 */ static const struct Subsprite sSubsprites_DigitalDisplay_Unused1[] = { { .x = -32, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 3, }, { .x = -32, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 3, }, { .x = 0, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Unused1[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Unused1), sSubsprites_DigitalDisplay_Unused1 }; /* v-- Origin on 3 [0_____][1_____] [2_____][3_____] [4 ][5 ] 64x24 */ static const struct Subsprite sSubsprites_DigitalDisplay_Win[] = { { .x = -32, .y = -12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 3, }, { .x = 0, .y = -12, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 4, .priority = 3, }, { .x = -32, .y = -4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 8, .priority = 3, }, { .x = 0, .y = -4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 3, }, { .x = -32, .y = 4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 16, .priority = 3, }, { .x = 0, .y = 4, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 20, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Win[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Win), sSubsprites_DigitalDisplay_Win }; static const struct Subsprite sSubsprites_DigitalDisplay_Smoke[] = { { .x = -16, .y = -16, .shape = SPRITE_SHAPE(32x32), .size = SPRITE_SIZE(32x32), .tileOffset = 0, .priority = 3, } }; static const struct Subsprite sSubsprites_DigitalDisplay_Unused2[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x16), .size = SPRITE_SIZE(16x16), .tileOffset = 16, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Smoke[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Smoke), sSubsprites_DigitalDisplay_Smoke }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Unused2[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Unused2), sSubsprites_DigitalDisplay_Unused2 }; /* [0_____][1_] [2_____][3_] [4_____][5_] [6_____][7+] <-- Origin [8_____][9_] [10____][11] */ static const struct Subsprite sSubsprites_DigitalDisplay_Pokeball[] = { { .x = -24, .y = -24, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 0, .priority = 3, }, { .x = 8, .y = -24, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 4, .priority = 3, }, { .x = -24, .y = -16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 6, .priority = 3, }, { .x = 8, .y = -16, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 10, .priority = 3, }, { .x = -24, .y = -8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 12, .priority = 3, }, { .x = 8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 16, .priority = 3, }, { .x = -24, .y = 0, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 18, .priority = 3, }, { .x = 8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 22, .priority = 3, }, { .x = -24, .y = 8, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 24, .priority = 3, }, { .x = 8, .y = 8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 28, .priority = 3, }, { .x = -24, .y = 16, .shape = SPRITE_SHAPE(32x8), .size = SPRITE_SIZE(32x8), .tileOffset = 30, .priority = 3, }, { .x = 8, .y = 16, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 34, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_Pokeball[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_Pokeball), sSubsprites_DigitalDisplay_Pokeball }; /* [0 ] 32x24 [ + ] <- Origin [1 ][2 ] */ static const struct Subsprite sSubsprites_DigitalDisplay_DPad[] = { { .x = -16, .y = -12, .shape = SPRITE_SHAPE(32x16), .size = SPRITE_SIZE(32x16), .tileOffset = 0, .priority = 3, }, { .x = -16, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 8, .priority = 3, }, { .x = 0, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 10, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_DPad[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_DPad), sSubsprites_DigitalDisplay_DPad }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_StopS[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 8, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_StopS[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_StopS), sSubsprites_DigitalDisplay_StopS }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_StopT[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 2, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 10, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_StopT[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_StopT), sSubsprites_DigitalDisplay_StopT }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_StopO[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 4, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 12, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_StopO[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_StopO), sSubsprites_DigitalDisplay_StopO }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_StopP[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 6, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 14, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_StopP[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_StopP), sSubsprites_DigitalDisplay_StopP }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_BonusB[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 8, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BonusB[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BonusB), sSubsprites_DigitalDisplay_BonusB }; /* []<-0 16x16 []<-1 <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_BonusO[] = { { .x = -4, .y = -8, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 2, .priority = 3, }, { .x = -4, .y = 0, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 10, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BonusO[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BonusO), sSubsprites_DigitalDisplay_BonusO }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_BonusN[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 3, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 11, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BonusN[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BonusN), sSubsprites_DigitalDisplay_BonusN }; /* []<-0 16x16 []<-1 <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_BonusU[] = { { .x = -4, .y = -8, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 5, .priority = 3, }, { .x = -4, .y = 0, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 13, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BonusU[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BonusU), sSubsprites_DigitalDisplay_BonusU }; /* [0 ] 16x16 [1+] <- Origin */ static const struct Subsprite sSubsprites_DigitalDisplay_BonusS[] = { { .x = -8, .y = -8, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 6, .priority = 3, }, { .x = -8, .y = 0, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 14, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BonusS[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BonusS), sSubsprites_DigitalDisplay_BonusS }; /* [0_][] <-1 [2_][] <-3 [4_][] <-5 ^-- Origin on 3 */ static const struct Subsprite sSubsprites_DigitalDisplay_BigB[] = { { .x = -12, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 3, }, { .x = 4, .y = -12, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 2, .priority = 3, }, { .x = -12, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 8, .priority = 3, }, { .x = 4, .y = -4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 10, .priority = 3, }, { .x = -12, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 16, .priority = 3, }, { .x = 4, .y = 4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 18, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BigB[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BigB), sSubsprites_DigitalDisplay_BigB }; /* [0_] 16x24 [1+] <--Origin [2_] */ static const struct Subsprite sSubsprites_DigitalDisplay_BigI[] = { { .x = -8, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 3, .priority = 3, }, { .x = -8, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 11, .priority = 3, }, { .x = -8, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 19, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BigI[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BigI), sSubsprites_DigitalDisplay_BigI }; /* [0_][] <-1 [2_][] <-3 [4_][] <-5 ^-- Origin on 3 */ static const struct Subsprite sSubsprites_DigitalDisplay_BigG[] = { { .x = -12, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 5, .priority = 3, }, { .x = 4, .y = -12, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 7, .priority = 3, }, { .x = -12, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 13, .priority = 3, }, { .x = 4, .y = -4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 15, .priority = 3, }, { .x = -12, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 21, .priority = 3, }, { .x = 4, .y = 4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 23, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_BigG[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_BigG), sSubsprites_DigitalDisplay_BigG }; /* [0_][] <-1 [2_][] <-3 [4_][] <-5 ^-- Origin on 3 */ static const struct Subsprite sSubsprites_DigitalDisplay_RegR[] = { { .x = -12, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 0, .priority = 3, }, { .x = 4, .y = -12, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 2, .priority = 3, }, { .x = -12, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 8, .priority = 3, }, { .x = 4, .y = -4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 10, .priority = 3, }, { .x = -12, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 16, .priority = 3, }, { .x = 4, .y = 4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 18, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_RegR[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_RegR), sSubsprites_DigitalDisplay_RegR }; /* [0_] 16x24 [1+] <--Origin [2_] */ static const struct Subsprite sSubsprites_DigitalDisplay_RegE[] = { { .x = -8, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 3, .priority = 3, }, { .x = -8, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 11, .priority = 3, }, { .x = -8, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 19, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_RegE[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_RegE), sSubsprites_DigitalDisplay_RegE }; /* [0_][] <-1 [2_][] <-3 [4_][] <-5 ^-- Origin on 3 */ static const struct Subsprite sSubsprites_DigitalDisplay_RegG[] = { { .x = -12, .y = -12, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 5, .priority = 3, }, { .x = 4, .y = -12, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 7, .priority = 3, }, { .x = -12, .y = -4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 13, .priority = 3, }, { .x = 4, .y = -4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 15, .priority = 3, }, { .x = -12, .y = 4, .shape = SPRITE_SHAPE(16x8), .size = SPRITE_SIZE(16x8), .tileOffset = 21, .priority = 3, }, { .x = 4, .y = 4, .shape = SPRITE_SHAPE(8x8), .size = SPRITE_SIZE(8x8), .tileOffset = 23, .priority = 3, } }; static const struct SubspriteTable sSubspriteTable_DigitalDisplay_RegG[] = { ARRAY_COUNT(sSubsprites_DigitalDisplay_RegG), sSubsprites_DigitalDisplay_RegG }; static const struct SpriteTemplate *const sSpriteTemplates_DigitalDisplay[NUM_DIG_DISPLAY_SPRITES] = { [DIG_SPRITE_REEL] = &sSpriteTemplate_DigitalDisplay_Reel, [DIG_SPRITE_TIME] = &sSpriteTemplate_DigitalDisplay_Time, [DIG_SPRITE_INSERT] = &sSpriteTemplate_DigitalDisplay_Insert, [DIG_SPRITE_WIN] = &sSpriteTemplate_DigitalDisplay_Win, [DIG_SPRITE_LOSE] = &sSpriteTemplate_DigitalDisplay_Lose, [DIG_SPRITE_A_BUTTON] = &sSpriteTemplate_DigitalDisplay_AButton, [DIG_SPRITE_SMOKE] = &sSpriteTemplate_DigitalDisplay_Smoke, [DIG_SPRITE_NUMBER] = &sSpriteTemplate_DigitalDisplay_Number, [DIG_SPRITE_POKE_BALL] = &sSpriteTemplate_DigitalDisplay_Pokeball, [DIG_SPRITE_D_PAD] = &sSpriteTemplate_DigitalDisplay_DPad, [DIG_SPRITE_STOP_S] = &sSpriteTemplate_DigitalDisplay_Stop, [DIG_SPRITE_STOP_T] = &sSpriteTemplate_DigitalDisplay_Stop, [DIG_SPRITE_STOP_O] = &sSpriteTemplate_DigitalDisplay_Stop, [DIG_SPRITE_STOP_P] = &sSpriteTemplate_DigitalDisplay_Stop, [DIG_SPRITE_BONUS_B] = &sSpriteTemplate_DigitalDisplay_Bonus, [DIG_SPRITE_BONUS_O] = &sSpriteTemplate_DigitalDisplay_Bonus, [DIG_SPRITE_BONUS_N] = &sSpriteTemplate_DigitalDisplay_Bonus, [DIG_SPRITE_BONUS_U] = &sSpriteTemplate_DigitalDisplay_Bonus, [DIG_SPRITE_BONUS_S] = &sSpriteTemplate_DigitalDisplay_Bonus, [DIG_SPRITE_BIG_B] = &sSpriteTemplate_DigitalDisplay_Big, [DIG_SPRITE_BIG_I] = &sSpriteTemplate_DigitalDisplay_Big, [DIG_SPRITE_BIG_G] = &sSpriteTemplate_DigitalDisplay_Big, [DIG_SPRITE_REG_R] = &sSpriteTemplate_DigitalDisplay_Reg, [DIG_SPRITE_REG_E] = &sSpriteTemplate_DigitalDisplay_Reg, [DIG_SPRITE_REG_G] = &sSpriteTemplate_DigitalDisplay_Reg, [DIG_SPRITE_EMPTY] = &gDummySpriteTemplate }; static const struct SubspriteTable *const sSubspriteTables_DigitalDisplay[NUM_DIG_DISPLAY_SPRITES] = { [DIG_SPRITE_REEL] = sSubspriteTable_DigitalDisplay_Reel, [DIG_SPRITE_TIME] = sSubspriteTable_DigitalDisplay_Time, [DIG_SPRITE_INSERT] = sSubspriteTable_DigitalDisplay_Insert, [DIG_SPRITE_WIN] = sSubspriteTable_DigitalDisplay_Win, [DIG_SPRITE_LOSE] = NULL, [DIG_SPRITE_A_BUTTON] = NULL, [DIG_SPRITE_SMOKE] = sSubspriteTable_DigitalDisplay_Smoke, [DIG_SPRITE_NUMBER] = NULL, [DIG_SPRITE_POKE_BALL] = sSubspriteTable_DigitalDisplay_Pokeball, [DIG_SPRITE_D_PAD] = sSubspriteTable_DigitalDisplay_DPad, [DIG_SPRITE_STOP_S] = sSubspriteTable_DigitalDisplay_StopS, [DIG_SPRITE_STOP_T] = sSubspriteTable_DigitalDisplay_StopT, [DIG_SPRITE_STOP_O] = sSubspriteTable_DigitalDisplay_StopO, [DIG_SPRITE_STOP_P] = sSubspriteTable_DigitalDisplay_StopP, [DIG_SPRITE_BONUS_B] = sSubspriteTable_DigitalDisplay_BonusB, [DIG_SPRITE_BONUS_O] = sSubspriteTable_DigitalDisplay_BonusO, [DIG_SPRITE_BONUS_N] = sSubspriteTable_DigitalDisplay_BonusN, [DIG_SPRITE_BONUS_U] = sSubspriteTable_DigitalDisplay_BonusU, [DIG_SPRITE_BONUS_S] = sSubspriteTable_DigitalDisplay_BonusS, [DIG_SPRITE_BIG_B] = sSubspriteTable_DigitalDisplay_BigB, [DIG_SPRITE_BIG_I] = sSubspriteTable_DigitalDisplay_BigI, [DIG_SPRITE_BIG_G] = sSubspriteTable_DigitalDisplay_BigG, [DIG_SPRITE_REG_R] = sSubspriteTable_DigitalDisplay_RegR, [DIG_SPRITE_REG_E] = sSubspriteTable_DigitalDisplay_RegE, [DIG_SPRITE_REG_G] = sSubspriteTable_DigitalDisplay_RegG, [DIG_SPRITE_EMPTY] = NULL }; static const struct SpriteSheet sSlotMachineSpriteSheets[22] = { { .data = gSlotMachineReelSymbol1Tiles, .size = 0x200, .tag = GFXTAG_7_RED }, { .data = gSlotMachineReelSymbol2Tiles, .size = 0x200, .tag = GFXTAG_7_BLUE }, { .data = gSlotMachineReelSymbol3Tiles, .size = 0x200, .tag = GFXTAG_AZURILL }, { .data = gSlotMachineReelSymbol4Tiles, .size = 0x200, .tag = GFXTAG_LOTAD }, { .data = gSlotMachineReelSymbol5Tiles, .size = 0x200, .tag = GFXTAG_CHERRY }, { .data = gSlotMachineReelSymbol6Tiles, .size = 0x200, .tag = GFXTAG_POWER }, { .data = gSlotMachineReelSymbol7Tiles, .size = 0x200, .tag = GFXTAG_REPLAY }, { .data = gSlotMachineNumber0Tiles, .size = 0x40, .tag = GFXTAG_NUM_0 }, { .data = gSlotMachineNumber1Tiles, .size = 0x40, .tag = GFXTAG_NUM_1 }, { .data = gSlotMachineNumber2Tiles, .size = 0x40, .tag = GFXTAG_NUM_2 }, { .data = gSlotMachineNumber3Tiles, .size = 0x40, .tag = GFXTAG_NUM_3 }, { .data = gSlotMachineNumber4Tiles, .size = 0x40, .tag = GFXTAG_NUM_4 }, { .data = gSlotMachineNumber5Tiles, .size = 0x40, .tag = GFXTAG_NUM_5 }, { .data = gSlotMachineNumber6Tiles, .size = 0x40, .tag = GFXTAG_NUM_6 }, { .data = gSlotMachineNumber7Tiles, .size = 0x40, .tag = GFXTAG_NUM_7 }, { .data = gSlotMachineNumber8Tiles, .size = 0x40, .tag = GFXTAG_NUM_8 }, { .data = gSlotMachineNumber9Tiles, .size = 0x40, .tag = GFXTAG_NUM_9 }, // skips GFXTAG_REEL_BG, which has its own spritesheet // the data for these sheets is determined at runtime { .data = NULL, .size = 0x200, .tag = GFXTAG_STOP }, { .data = NULL, .size = 0x200, .tag = GFXTAG_BONUS }, { .data = NULL, .size = 0x300, .tag = GFXTAG_BIG }, { .data = NULL, .size = 0x300, .tag = GFXTAG_REG }, {}, }; static const u8 *const sReelBackground_Tilemap = gSlotMachineReelBackground_Tilemap; static const u16 sUnusedColors[] = { RGB(27, 27, 27), RGB(8, 11, 26), RGB(11, 21, 13), RGB(31, 31, 31), RGB(16, 26, 21), RGB(0, 22, 31), RGB(26, 21, 0), RGB(26, 21, 0), RGB(29, 15, 0), RGB(29, 15, 0), }; // The Bet 2 and 3 match line palettes are duplicated unnecessarily static const u16 sMiddleRowLit_Pal[] = {RGB(17, 28, 31)}; static const u16 sTopRowLit_Pal[] = {RGB(31, 29, 16)}; static const u16 sBottomRowt_Pal[] = {RGB(31, 29, 16)}; static const u16 sNWSEDiagLit_Pal[] = {RGB(31, 21, 18)}; static const u16 sNESWDiagLit_Pal[] = {RGB(31, 21, 18)}; static const u16 *const sLitMatchLinePalTable[NUM_MATCH_LINES] = { [MATCH_MIDDLE_ROW] = sMiddleRowLit_Pal, [MATCH_TOP_ROW] = sTopRowLit_Pal, [MATCH_BOTTOM_ROW] = sBottomRowt_Pal, [MATCH_NWSE_DIAG] = sNWSEDiagLit_Pal, [MATCH_NESW_DIAG] = sNESWDiagLit_Pal, }; static const u16 *const sDarkMatchLinePalTable[NUM_MATCH_LINES] = { [MATCH_MIDDLE_ROW] = &gSlotMachineMenu_Pal[BG_PLTT_ID(4) + 10], [MATCH_TOP_ROW] = &gSlotMachineMenu_Pal[BG_PLTT_ID(4) + 11], [MATCH_BOTTOM_ROW] = &gSlotMachineMenu_Pal[BG_PLTT_ID(4) + 12], [MATCH_NWSE_DIAG] = &gSlotMachineMenu_Pal[BG_PLTT_ID(4) + 13], [MATCH_NESW_DIAG] = &gSlotMachineMenu_Pal[BG_PLTT_ID(4) + 14], }; static const u8 sMatchLinePalOffsets[NUM_MATCH_LINES] = { [MATCH_MIDDLE_ROW] = BG_PLTT_ID(4) + 10, [MATCH_TOP_ROW] = BG_PLTT_ID(4) + 11, [MATCH_BOTTOM_ROW] = BG_PLTT_ID(4) + 12, [MATCH_NWSE_DIAG] = BG_PLTT_ID(4) + 14, // Diag colors flipped for some reason [MATCH_NESW_DIAG] = BG_PLTT_ID(4) + 13 // Doesn't matter as both are identical }; static const u8 sBetToMatchLineIds[MAX_BET][2] = { {MATCH_MIDDLE_ROW, MATCH_MIDDLE_ROW}, // Bet 1 {MATCH_TOP_ROW, MATCH_BOTTOM_ROW}, // Bet 2 {MATCH_NWSE_DIAG, MATCH_NESW_DIAG}, // Bet 3 }; static const u8 sMatchLinesPerBet[MAX_BET] = { 1, 2, 2 }; // Flashing lights at top of slot machine, brightest point inside light goes from toward center of machine, to middle, to toward edges static const u16 sFlashingLightsInside_Pal[] = INCBIN_U16("graphics/slot_machine/flashing_lights_inside.gbapal"); static const u16 sFlashingLightsMiddle_Pal[] = INCBIN_U16("graphics/slot_machine/flashing_lights_middle.gbapal"); static const u16 sFlashingLightsOutside_Pal[] = INCBIN_U16("graphics/slot_machine/flashing_lights_outside.gbapal"); static const u16 *const sFlashingLightsPalTable[] = { sFlashingLightsInside_Pal, sFlashingLightsMiddle_Pal, sFlashingLightsOutside_Pal, }; static const u16 *const sSlotMachineMenu_Pal = {gSlotMachineMenu_Pal + 16}; static const u16 sPokeballShining0_Pal[] = INCBIN_U16("graphics/slot_machine/pokeball_shining_0.gbapal"); static const u16 sPokeballShining1_Pal[] = INCBIN_U16("graphics/slot_machine/pokeball_shining_1.gbapal"); static const u16 sPokeballShining2_Pal[] = INCBIN_U16("graphics/slot_machine/pokeball_shining_2.gbapal"); static const u16 *const sPokeballShiningPalTable[] = { sPokeballShining0_Pal, // Streak on left side of ball sPokeballShining1_Pal, // Streak in middle of ball sPokeballShining2_Pal, // Streak on right side of ball gSlotMachineDigitalDisplay_Pal, // Back to normal }; static const u16 *const sDigitalDisplay_Pal = gSlotMachineDigitalDisplay_Pal; static const u16 sUnkPalette[16] = { [1] = RGB_WHITEALPHA, [3] = RGB(8, 8, 8), }; static const struct SpritePalette sSlotMachineSpritePalettes[] = { { .data = gSlotMachineReelSymbols_Pal, .tag = PALTAG_REEL}, { .data = gSlotMachineReelTimePikachu_Pal, .tag = PALTAG_REEL_TIME_PIKACHU}, { .data = gSlotMachineReelTimeMisc_Pal, .tag = PALTAG_REEL_TIME_MISC}, { .data = gSlotMachineReelTimeMachine_Pal, .tag = PALTAG_REEL_TIME_MACHINE}, { .data = gSlotMachineMisc_Pal, .tag = PALTAG_MISC}, { .data = gSlotMachineReelTimeExplosion_Pal, .tag = PALTAG_EXPLOSION}, { .data = gSlotMachineDigitalDisplay_Pal, .tag = PALTAG_DIG_DISPLAY}, { .data = gSlotMachineMisc_Pal, .tag = PALTAG_PIKA_AURA}, {} }; static const u32 sReelTimeGfx[] = INCBIN_U32("graphics/slot_machine/reel_time_gfx.4bpp.lz"); // reel_time_machine and reel_time_pikachu static const u16 sReelTimeWindow_Tilemap[] = INCBIN_U16("graphics/slot_machine/reel_time_window.bin"); static const u16 sEmptyTilemap[] = {0};