tbld/tumbledemerald-legacy
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 5 Wiki Activity
2fd2705498
tumbledemerald-legacy/src/roulette.c

4777 lines
145 KiB
C
Raw Normal View History

import from github
2022-05-19 19:14:13 +02:00
#include "global.h"
#include "malloc.h"
#include "bg.h"
#include "coins.h"
#include "decompress.h"
#include "event_data.h"
#include "field_screen_effect.h"
#include "gpu_regs.h"
#include "graphics.h"
#include "m4a.h"
#include "main.h"
#include "menu.h"
#include "menu_helpers.h"
#include "overworld.h"
#include "palette.h"
#include "palette_util.h"
#include "random.h"
#include "roulette.h"
#include "rtc.h"
#include "scanline_effect.h"
#include "script.h"
#include "sound.h"
#include "sprite.h"
#include "string_util.h"
#include "strings.h"
#include "task.h"
#include "trig.h"
#include "tv.h"
#include "window.h"
#include "constants/coins.h"
#include "constants/rgb.h"
#include "constants/roulette.h"
#include "constants/songs.h"
#define BALLS_PER_ROUND 6
// "Board" is used in this file to refer to both the wheel and the bet selection grid
#define NUM_BOARD_COLORS 3 // Rows on grid
#define NUM_BOARD_POKES 4 // Columns on grid
#define NUM_ROULETTE_SLOTS (NUM_BOARD_COLORS * NUM_BOARD_POKES)
// The degree change between each slot on the roulette wheel
#define DEGREES_PER_SLOT (360 / NUM_ROULETTE_SLOTS)
// Where in the slot the ball will drop when landing
#define SLOT_MIDPOINT (DEGREES_PER_SLOT / 2 - 1)
// IDs for grid selections when betting
#define SELECTION_NONE 0
#define COL_WYNAUT 1
#define COL_AZURILL 2
#define COL_SKITTY 3
#define COL_MAKUHITA 4
#define ROW_ORANGE (COL_MAKUHITA + 1)
#define SQU_ORANGE_WYNAUT (ROW_ORANGE + COL_WYNAUT)
#define SQU_ORANGE_AZURILL (ROW_ORANGE + COL_AZURILL)
#define SQU_ORANGE_SKITTY (ROW_ORANGE + COL_SKITTY)
#define SQU_ORANGE_MAKUHITA (ROW_ORANGE + COL_MAKUHITA)
#define ROW_GREEN (SQU_ORANGE_MAKUHITA + 1)
#define SQU_GREEN_WYNAUT (ROW_GREEN + COL_WYNAUT)
#define SQU_GREEN_AZURILL (ROW_GREEN + COL_AZURILL)
#define SQU_GREEN_SKITTY (ROW_GREEN + COL_SKITTY)
#define SQU_GREEN_MAKUHITA (ROW_GREEN + COL_MAKUHITA)
#define ROW_PURPLE (SQU_GREEN_MAKUHITA + 1)
#define SQU_PURPLE_WYNAUT (ROW_PURPLE + COL_WYNAUT)
#define SQU_PURPLE_AZURILL (ROW_PURPLE + COL_AZURILL)
#define SQU_PURPLE_SKITTY (ROW_PURPLE + COL_SKITTY)
#define SQU_PURPLE_MAKUHITA (ROW_PURPLE + COL_MAKUHITA)
#define NUM_GRID_SELECTIONS SQU_PURPLE_MAKUHITA
// Get the id of the col/row from the selection ID
// e.g. GET_ROW(SQU_PURPLE_SKITTY) is ROW_PURPLE
#define GET_COL(selectionId)((selectionId) % (NUM_BOARD_POKES + 1))
#define GET_ROW(selectionId)((selectionId) / (NUM_BOARD_POKES + 1) * (NUM_BOARD_POKES + 1))
// Get the col/row index from the selection ID
// e.g. GET_ROW_IDX(SQU_PURPLE_SKITTY) is 2 (purple being the 3rd row)
#define GET_COL_IDX(selectionId)(selectionId - 1)
#define GET_ROW_IDX(selectionId)(selectionId / 5 - 1)
// Flags for the above selections, used to set which spaces have been hit or bet on
#define F_WYNAUT_COL (1 << COL_WYNAUT)
#define F_AZURILL_COL (1 << COL_AZURILL)
#define F_SKITTY_COL (1 << COL_SKITTY)
#define F_MAKUHITA_COL (1 << COL_MAKUHITA)
#define F_ORANGE_ROW (1 << ROW_ORANGE)
#define F_ORANGE_WYNAUT (1 << SQU_ORANGE_WYNAUT)
#define F_ORANGE_AZURILL (1 << SQU_ORANGE_AZURILL)
#define F_ORANGE_SKITTY (1 << SQU_ORANGE_SKITTY)
#define F_ORANGE_MAKUHITA (1 << SQU_ORANGE_MAKUHITA)
#define F_GREEN_ROW (1 << ROW_GREEN)
#define F_GREEN_WYNAUT (1 << SQU_GREEN_WYNAUT)
#define F_GREEN_AZURILL (1 << SQU_GREEN_AZURILL)
#define F_GREEN_SKITTY (1 << SQU_GREEN_SKITTY)
#define F_GREEN_MAKUHITA (1 << SQU_GREEN_MAKUHITA)
#define F_PURPLE_ROW (1 << ROW_PURPLE)
#define F_PURPLE_WYNAUT (1 << SQU_PURPLE_WYNAUT)
#define F_PURPLE_AZURILL (1 << SQU_PURPLE_AZURILL)
#define F_PURPLE_SKITTY (1 << SQU_PURPLE_SKITTY)
#define F_PURPLE_MAKUHITA (1 << SQU_PURPLE_MAKUHITA)
// Flags for flashing selections on the roulette wheel
#define F_FLASH_COLOR_O_WYNAUT (1 << 0)
#define F_FLASH_COLOR_G_AZURILL (1 << 1)
#define F_FLASH_COLOR_P_SKITTY (1 << 2)
#define F_FLASH_COLOR_O_MAKUHITA (1 << 3)
#define F_FLASH_COLOR_G_WYNAUT (1 << 4)
#define F_FLASH_COLOR_P_AZURILL (1 << 5)
#define F_FLASH_COLOR_O_SKITTY (1 << 6)
#define F_FLASH_COLOR_G_MAKUHITA (1 << 7)
#define F_FLASH_COLOR_P_WYNAUT (1 << 8)
#define F_FLASH_COLOR_O_AZURILL (1 << 9)
#define F_FLASH_COLOR_G_SKITTY (1 << 10)
#define F_FLASH_COLOR_P_MAKUHITA (1 << 11)
#define F_FLASH_OUTER_EDGES (1 << 12) // when the player wins
#define FLASH_ICON (NUM_ROULETTE_SLOTS + 1)
#define FLASH_ICON_2 (FLASH_ICON + 1)
#define FLASH_ICON_3 (FLASH_ICON + 2)
#define F_FLASH_ICON (1 << FLASH_ICON)
#define F_FLASH_COLUMN (1 << FLASH_ICON | 1 << FLASH_ICON_2 | 1 << FLASH_ICON_3)
#define MAX_MULTIPLIER 12
#define PALTAG_SHADOW 1
#define PALTAG_BALL 2
#define PALTAG_BALL_COUNTER 3
#define PALTAG_CURSOR 4
#define PALTAG_INTERFACE 5
#define PALTAG_SHROOMISH 6
#define PALTAG_TAILLOW 7
#define PALTAG_GRID_ICONS 8
#define PALTAG_WYNAUT 9
#define PALTAG_AZURILL 10
#define PALTAG_SKITTY 11
#define PALTAG_MAKUHITA 12
#define GFXTAG_WHEEL_ICONS 0
#define GFXTAG_HEADERS 4
#define GFXTAG_GRID_ICONS 5
#define GFXTAG_WHEEL_CENTER 6
#define GFXTAG_CREDIT 7
#define GFXTAG_CREDIT_DIGIT 8
#define GFXTAG_MULTIPLIER 9
#define GFXTAG_BALL_COUNTER 10
#define GFXTAG_CURSOR 11
#define GFXTAG_BALL 12
#define GFXTAG_SHROOMISH_TAILLOW 13
#define GFXTAG_SHADOW 14
// 2 different Roulette tables with 2 different rates (normal vs service day special)
// & 1 gets which table, >> 7 gets if ROULETTE_SPECIAL_RATE is set
#define GET_MIN_BET_ID(var)(((var) & 1) + (((var) >> 7) * 2))
// Having Shroomish or Taillow in the party can make rolls more consistent in length
// It also increases the likelihood that, if they appear to unstick a ball, they'll move it to a slot the player bet on
#define HAS_SHROOMISH (1 << 0)
#define HAS_TAILLOW (1 << 1)
#define NO_DELAY 0xFFFF
enum {
BALL_STATE_ROLLING,
BALL_STATE_STUCK,
BALL_STATE_LANDED = 0xFF,
};
enum {
SELECT_STATE_WAIT,
SELECT_STATE_DRAW,
SELECT_STATE_UPDATE,
SELECT_STATE_ERASE = 0xFF,
};
// Roulette uses a large amount of sprites, and stores ids for these in a single array
// Many are looped over rather than referenced directly
enum {
SPR_WHEEL_BALL_1,
SPR_WHEEL_BALL_2,
SPR_WHEEL_BALL_3,
SPR_WHEEL_BALL_4,
SPR_WHEEL_BALL_5,
SPR_WHEEL_BALL_6,
SPR_WHEEL_CENTER,
SPR_WHEEL_ICON_ORANGE_WYNAUT,
SPR_WHEEL_ICON_GREEN_AZURILL,
SPR_WHEEL_ICON_PURPLE_SKITTY,
SPR_WHEEL_ICON_ORANGE_MAKUHITA,
SPR_WHEEL_ICON_GREEN_WYNAUT,
SPR_WHEEL_ICON_PURPLE_AZURILL,
SPR_WHEEL_ICON_ORANGE_SKITTY,
SPR_WHEEL_ICON_GREEN_MAKUHITA,
SPR_WHEEL_ICON_PURPLE_WYNAUT,
SPR_WHEEL_ICON_ORANGE_AZURILL,
SPR_WHEEL_ICON_GREEN_SKITTY,
SPR_WHEEL_ICON_PURPLE_MAKUHITA,
SPR_19, // Unused
SPR_CREDIT,
SPR_CREDIT_DIG_1,
SPR_CREDIT_DIG_10,
SPR_CREDIT_DIG_100,
SPR_CREDIT_DIG_1000,
SPR_MULTIPLIER,
SPR_BALL_COUNTER_1,
SPR_BALL_COUNTER_2,
SPR_BALL_COUNTER_3,
SPR_GRID_ICON_ORANGE_WYNAUT,
SPR_GRID_ICON_GREEN_AZURILL,
SPR_GRID_ICON_PURPLE_SKITTY,
SPR_GRID_ICON_ORANGE_MAKUHITA,
SPR_GRID_ICON_GREEN_WYNAUT,
SPR_GRID_ICON_PURPLE_AZURILL,
SPR_GRID_ICON_ORANGE_SKITTY,
SPR_GRID_ICON_GREEN_MAKUHITA,
SPR_GRID_ICON_PURPLE_WYNAUT,
SPR_GRID_ICON_ORANGE_AZURILL,
SPR_GRID_ICON_GREEN_SKITTY,
SPR_GRID_ICON_PURPLE_MAKUHITA,
SPR_POKE_HEADER_1,
SPR_POKE_HEADER_2,
SPR_POKE_HEADER_3,
SPR_POKE_HEADER_4,
SPR_COLOR_HEADER_1,
SPR_COLOR_HEADER_2,
SPR_COLOR_HEADER_3,
SPR_WIN_SLOT_CURSOR,
SPR_GRID_BALL_1,
SPR_GRID_BALL_2,
SPR_GRID_BALL_3,
SPR_GRID_BALL_4,
SPR_GRID_BALL_5,
SPR_GRID_BALL_6,
SPR_CLEAR_MON, // Shroomish/Taillow
SPR_CLEAR_MON_SHADOW_1,
SPR_CLEAR_MON_SHADOW_2,
SPR_58, // Here below unused
SPR_59,
SPR_60,
SPR_61,
SPR_62,
SPR_63,
};
// Start points for sprite IDs that are looped over
#define SPR_WHEEL_BALLS SPR_WHEEL_BALL_1
#define SPR_WHEEL_ICONS SPR_WHEEL_ICON_ORANGE_WYNAUT
#define SPR_BALL_COUNTER SPR_BALL_COUNTER_1
#define SPR_CREDIT_DIGITS SPR_CREDIT_DIG_1
#define SPR_GRID_ICONS SPR_GRID_ICON_ORANGE_WYNAUT
#define SPR_POKE_HEADERS SPR_POKE_HEADER_1
#define SPR_COLOR_HEADERS SPR_COLOR_HEADER_1
#define SPR_GRID_BALLS SPR_GRID_BALL_1
struct Shroomish
{
u16 startAngle;
u16 dropAngle;
u16 fallSlowdown;
};
struct Taillow
{
u16 baseDropDelay;
u16 rightStartAngle;
u16 leftStartAngle;
};
struct RouletteTable
{
u8 minBet; // Never read
u8 randDistanceHigh;
u8 randDistanceLow;
u8 wheelSpeed;
u8 wheelDelay;
struct Shroomish shroomish;
struct Taillow taillow;
u16 ballSpeed;
u16 baseTravelDist;
f32 var1C;
};
struct GridSelection
{
u8 spriteIdOffset;
u8 baseMultiplier:4;
u8 column:4; // Never read
u8 row; // Never read
u8 x;
u8 y;
u8 var05; // Never read
u8 tilemapOffset;
u32 flag;
u32 inSelectionFlags;
u16 flashFlags;
};
struct RouletteSlot
{
u8 id1; // Never read
u8 id2; // Never read
u8 gridSquare;
u32 flag;
};
static EWRAM_DATA struct Roulette
{
u8 unk0; // Never read
u8 shroomishShadowTimer;
u8 partySpeciesFlags;
bool8 useTaillow:5;
bool8 ballStuck:1;
bool8 ballUnstuck:1;
bool8 ballRolling:1; // Never read
u8 tableId:2;
u8 unused:5;
bool8 isSpecialRate:1;
u32 hitFlags;
u8 hitSquares[BALLS_PER_ROUND];
u8 pokeHits[NUM_BOARD_POKES];
u8 colorHits[NUM_BOARD_COLORS];
u8 minBet;
u8 curBallNum:4; // Never actually gets incremented, tracked with tBallNum instead
u8 unk1:4; // Never read
u8 betSelection[BALLS_PER_ROUND]; // Because curBallNum is used as the only index, only the first element is ever used (prev bet selections are never needed)
u8 wheelDelayTimer;
u8 wheelSpeed;
u8 wheelDelay;
s16 wheelAngle;
s16 gridX;
s16 selectionRectDrawState;
s16 updateGridHighlight;
struct OamMatrix wheelRotation;
u16 shroomishShadowAlpha;
struct Sprite *ball;
u8 spriteIds[MAX_SPRITES];
u8 curBallSpriteId;
u8 ballState;
u8 hitSlot;
u8 stuckHitSlot;
s16 ballTravelDist; // Never read
s16 ballTravelDistFast;
u16 ballTravelDistMed;
u16 ballTravelDistSlow;
f32 ballAngle;
f32 ballAngleSpeed;
f32 ballAngleAccel;
f32 ballDistToCenter;
f32 ballFallSpeed;
f32 ballFallAccel;
f32 varA0;
u8 playTaskId;
u8 spinTaskId;
u8 filler_1[2];
u16 taskWaitDelay;
u16 taskWaitKey;
TaskFunc nextTask;
u8 filler_2[4];
TaskFunc prevTask;
struct RouletteFlashUtil flashUtil;
u16 tilemapBuffers[7][0x400];
u16 *gridTilemap;
} *sRoulette = NULL;
static EWRAM_DATA u8 sTextWindowId = 0;
static void Task_SpinWheel(u8);
static void Task_StartPlaying(u8);
static void Task_ContinuePlaying(u8);
static void Task_StopPlaying(u8);
static void Task_SelectFirstEmptySquare(u8);
static void Task_HandleBetGridInput(u8);
static void Task_SlideGridOffscreen(u8);
static void Task_InitBallRoll(u8);
static void Task_RollBall(u8);
static void Task_RecordBallHit(u8);
static void Task_SlideGridOnscreen(u8);
static void Task_FlashBallOnWinningSquare(u8);
static void Task_PrintSpinResult(u8);
static void Task_PrintPayout(u8);
static void Task_EndTurn(u8);
static void Task_TryPrintEndTurnMsg(u8);
static void Task_ClearBoard(u8);
static void ExitRoulette(u8);
static void Task_ExitRoulette(u8);
static void StartTaskAfterDelayOrInput(u8, TaskFunc, u16, u16);
static void ResetBallDataForNewSpin(u8);
static void ResetHits(void);
static void Task_AcceptMinBet(u8);
static void Task_DeclineMinBet(u8);
static u8 RecordHit(u8, u8);
static bool8 IsHitInBetSelection(u8, u8);
static void FlashSelectionOnWheel(u8);
static void DrawGridBackground(u8);
static u8 GetMultiplier(u8);
static void UpdateWheelPosition(void);
static void LoadOrFreeMiscSpritePalettesAndSheets(u8);
static void CreateGridSprites(void);
static void ShowHideGridIcons(bool8, u8);
static void CreateGridBallSprites(void);
static void ShowHideGridBalls(bool8, u8);
static void ShowHideWinSlotCursor(u8);
static void CreateWheelIconSprites(void);
static void SpriteCB_WheelIcon(struct Sprite *);
static void CreateInterfaceSprites(void);
static void SetCreditDigits(u16);
static void SetMultiplierSprite(u8);
static void SetBallCounterNumLeft(u8);
static void SpriteCB_GridSquare(struct Sprite *);
static void CreateWheelCenterSprite(void);
static void SpriteCB_WheelCenter(struct Sprite *);
static void CreateWheelBallSprites(void);
static void HideWheelBalls(void);
static void SpriteCB_RollBall_Start(struct Sprite *);
static void CreateShroomishSprite(struct Sprite *);
static void CreateTaillowSprite(struct Sprite *);
static void SetBallStuck(struct Sprite *);
static void SpriteCB_Shroomish(struct Sprite *);
static void SpriteCB_Taillow(struct Sprite *);
static const u16 sWheel_Pal[] = INCBIN_U16("graphics/roulette/wheel.gbapal"); // also palette for grid
static const u32 sGrid_Tilemap[] = INCBIN_U32("graphics/roulette/grid.bin.lz");
static const u32 sWheel_Tilemap[] = INCBIN_U32("graphics/roulette/wheel.bin.lz");
static const struct BgTemplate sBgTemplates[] =
{
// Text box
{
.bg = 0,
.charBaseIndex = 2,
.mapBaseIndex = 31,
.screenSize = 0,
.paletteMode = 0,
.priority = 0,
.baseTile = 0
},
// Selection grid
{
.bg = 1,
.charBaseIndex = 0,
.mapBaseIndex = 4,
.screenSize = 1,
.paletteMode = 0,
.priority = 1,
.baseTile = 0
},
// Wheel
{
.bg = 2,
.charBaseIndex = 1,
.mapBaseIndex = 6,
.screenSize = 1,
.paletteMode = 1,
.priority = 2,
.baseTile = 0
}
};
static const struct WindowTemplate sWindowTemplates[] =
{
{
.bg = 0,
.tilemapLeft = 3,
.tilemapTop = 15,
.width = 24,
.height = 4,
.paletteNum = 15,
.baseBlock = 0xC5
},
#ifdef UBFIX
DUMMY_WIN_TEMPLATE,
#endif
};
static const struct GridSelection sGridSelections[NUM_GRID_SELECTIONS + 1] =
{
[SELECTION_NONE] = {
.spriteIdOffset = 0xFF,
.baseMultiplier = 0,
.column = 0,
.row = 0,
.x = 7,
.y = 7,
.var05 = 0,
.tilemapOffset = 0,
.flag = 0,
.inSelectionFlags = 0,
.flashFlags = 0,
},
[COL_WYNAUT] = {
.spriteIdOffset = 12,
.baseMultiplier = NUM_BOARD_POKES,
.column = 1,
.row = 0,
.x = 17,
.y = 7,
.var05 = 0,
.tilemapOffset = 0,
.flag = F_WYNAUT_COL,
.inSelectionFlags = F_WYNAUT_COL | F_ORANGE_WYNAUT | F_GREEN_WYNAUT | F_PURPLE_WYNAUT,
.flashFlags = F_FLASH_COLUMN,
},
[COL_AZURILL] = {
.spriteIdOffset = 13,
.baseMultiplier = NUM_BOARD_POKES,
.column = 2,
.row = 0,
.x = 20,
.y = 7,
.var05 = 0,
.tilemapOffset = 0,
.flag = F_AZURILL_COL,
.inSelectionFlags = F_AZURILL_COL | F_ORANGE_AZURILL | F_GREEN_AZURILL | F_PURPLE_AZURILL,
.flashFlags = F_FLASH_COLUMN,
},
[COL_SKITTY] = {
.spriteIdOffset = 14,
.baseMultiplier = NUM_BOARD_POKES,
.column = 3,
.row = 0,
.x = 23,
.y = 7,
.var05 = 0,
.tilemapOffset = 0,
.flag = F_SKITTY_COL,
.inSelectionFlags = F_SKITTY_COL | F_ORANGE_SKITTY | F_GREEN_SKITTY | F_PURPLE_SKITTY,
.flashFlags = F_FLASH_COLUMN,
},
[COL_MAKUHITA] = {
.spriteIdOffset = 15,
.baseMultiplier = NUM_BOARD_POKES,
.column = 4,
.row = 0,
.x = 26,
.y = 7,
.var05 = 0,
.tilemapOffset = 0,
.flag = F_MAKUHITA_COL,
.inSelectionFlags = F_MAKUHITA_COL | F_ORANGE_MAKUHITA | F_GREEN_MAKUHITA | F_PURPLE_MAKUHITA,
.flashFlags = F_FLASH_COLUMN,
},
[ROW_ORANGE] = {
.spriteIdOffset = 16,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 1,
.x = 14,
.y = 10,
.var05 = 0,
.tilemapOffset = 12,
.flag = F_ORANGE_ROW,
.inSelectionFlags = F_ORANGE_ROW | F_ORANGE_WYNAUT | F_ORANGE_AZURILL | F_ORANGE_SKITTY | F_ORANGE_MAKUHITA,
.flashFlags = F_FLASH_COLOR_O_WYNAUT | F_FLASH_COLOR_O_AZURILL | F_FLASH_COLOR_O_SKITTY | F_FLASH_COLOR_O_MAKUHITA,
},
[SQU_ORANGE_WYNAUT] = {
.spriteIdOffset = 0,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 1,
.x = 17,
.y = 10,
.var05 = 3,
.tilemapOffset = 3,
.flag = F_ORANGE_WYNAUT,
.inSelectionFlags = F_ORANGE_WYNAUT,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_O_WYNAUT,
},
[SQU_ORANGE_AZURILL] = {
.spriteIdOffset = 9,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 1,
.x = 20,
.y = 10,
.var05 = 3,
.tilemapOffset = 3,
.flag = F_ORANGE_AZURILL,
.inSelectionFlags = F_ORANGE_AZURILL,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_O_AZURILL,
},
[SQU_ORANGE_SKITTY] = {
.spriteIdOffset = 6,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 1,
.x = 23,
.y = 10,
.var05 = 3,
.tilemapOffset = 3,
.flag = F_ORANGE_SKITTY,
.inSelectionFlags = F_ORANGE_SKITTY,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_O_SKITTY,
},
[SQU_ORANGE_MAKUHITA] = {
.spriteIdOffset = 3,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 1,
.x = 26,
.y = 10,
.var05 = 3,
.tilemapOffset = 3,
.flag = F_ORANGE_MAKUHITA,
.inSelectionFlags = F_ORANGE_MAKUHITA,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_O_MAKUHITA,
},
[ROW_GREEN] = {
.spriteIdOffset = 17,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 2,
.x = 14,
.y = 13,
.var05 = 3,
.tilemapOffset = 15,
.flag = F_GREEN_ROW,
.inSelectionFlags = F_GREEN_ROW | F_GREEN_WYNAUT | F_GREEN_AZURILL | F_GREEN_SKITTY | F_GREEN_MAKUHITA,
.flashFlags = F_FLASH_COLOR_G_WYNAUT | F_FLASH_COLOR_G_AZURILL | F_FLASH_COLOR_G_SKITTY | F_FLASH_COLOR_G_MAKUHITA,
},
[SQU_GREEN_WYNAUT] = {
.spriteIdOffset = 4,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 2,
.x = 17,
.y = 13,
.var05 = 6,
.tilemapOffset = 6,
.flag = F_GREEN_WYNAUT,
.inSelectionFlags = F_GREEN_WYNAUT,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_G_WYNAUT,
},
[SQU_GREEN_AZURILL] = {
.spriteIdOffset = 1,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 2,
.x = 20,
.y = 13,
.var05 = 6,
.tilemapOffset = 6,
.flag = F_GREEN_AZURILL,
.inSelectionFlags = F_GREEN_AZURILL,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_G_AZURILL,
},
[SQU_GREEN_SKITTY] = {
.spriteIdOffset = 10,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 2,
.x = 23,
.y = 13,
.var05 = 6,
.tilemapOffset = 6,
.flag = F_GREEN_SKITTY,
.inSelectionFlags = F_GREEN_SKITTY,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_G_SKITTY,
},
[SQU_GREEN_MAKUHITA] = {
.spriteIdOffset = 7,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 2,
.x = 26,
.y = 13,
.var05 = 6,
.tilemapOffset = 6,
.flag = F_GREEN_MAKUHITA,
.inSelectionFlags = F_GREEN_MAKUHITA,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_G_MAKUHITA,
},
[ROW_PURPLE] = {
.spriteIdOffset = 18,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 3,
.x = 14,
.y = 16,
.var05 = 6,
.tilemapOffset = 18,
.flag = F_PURPLE_ROW,
.inSelectionFlags = F_PURPLE_ROW | F_PURPLE_WYNAUT | F_PURPLE_AZURILL | F_PURPLE_SKITTY | F_PURPLE_MAKUHITA,
.flashFlags = F_FLASH_COLOR_P_WYNAUT | F_FLASH_COLOR_P_AZURILL | F_FLASH_COLOR_P_SKITTY | F_FLASH_COLOR_P_MAKUHITA,
},
[SQU_PURPLE_WYNAUT] = {
.spriteIdOffset = 8,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 3,
.x = 17,
.y = 16,
.var05 = 9,
.tilemapOffset = 9,
.flag = F_PURPLE_WYNAUT,
.inSelectionFlags = F_PURPLE_WYNAUT,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_P_WYNAUT,
},
[SQU_PURPLE_AZURILL] = {
.spriteIdOffset = 5,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 3,
.x = 20,
.y = 16,
.var05 = 9,
.tilemapOffset = 9,
.flag = F_PURPLE_AZURILL,
.inSelectionFlags = F_PURPLE_AZURILL,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_P_AZURILL,
},
[SQU_PURPLE_SKITTY] = {
.spriteIdOffset = 2,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 3,
.x = 23,
.y = 16,
.var05 = 9,
.tilemapOffset = 9,
.flag = F_PURPLE_SKITTY,
.inSelectionFlags = F_PURPLE_SKITTY,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_P_SKITTY,
},
[SQU_PURPLE_MAKUHITA] = {
.spriteIdOffset = 11,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 3,
.x = 26,
.y = 16,
.var05 = 9,
.tilemapOffset = 9,
.flag = F_PURPLE_MAKUHITA,
.inSelectionFlags = F_PURPLE_MAKUHITA,
.flashFlags = F_FLASH_ICON | F_FLASH_COLOR_P_MAKUHITA,
},
};
static const struct RouletteSlot sRouletteSlots[] =
{
{
.id1 = 0,
.id2 = 1,
.gridSquare = SQU_ORANGE_WYNAUT,
.flag = F_ORANGE_WYNAUT,
},
{
.id1 = 1,
.id2 = 3,
.gridSquare = SQU_GREEN_AZURILL,
.flag = F_GREEN_AZURILL,
},
{
.id1 = 2,
.id2 = 5,
.gridSquare = SQU_PURPLE_SKITTY,
.flag = F_PURPLE_SKITTY,
},
{
.id1 = 3,
.id2 = 7,
.gridSquare = SQU_ORANGE_MAKUHITA,
.flag = F_ORANGE_MAKUHITA,
},
{
.id1 = 4,
.id2 = 9,
.gridSquare = SQU_GREEN_WYNAUT,
.flag = F_GREEN_WYNAUT,
},
{
.id1 = 5,
.id2 = 11,
.gridSquare = SQU_PURPLE_AZURILL,
.flag = F_PURPLE_AZURILL,
},
{
.id1 = 6,
.id2 = 13,
.gridSquare = SQU_ORANGE_SKITTY,
.flag = F_ORANGE_SKITTY,
},
{
.id1 = 7,
.id2 = 15,
.gridSquare = SQU_GREEN_MAKUHITA,
.flag = F_GREEN_MAKUHITA,
},
{
.id1 = 8,
.id2 = 17,
.gridSquare = SQU_PURPLE_WYNAUT,
.flag = F_PURPLE_WYNAUT,
},
{
.id1 = 9,
.id2 = 19,
.gridSquare = SQU_ORANGE_AZURILL,
.flag = F_ORANGE_AZURILL,
},
{
.id1 = 10,
.id2 = 21,
.gridSquare = SQU_GREEN_SKITTY,
.flag = F_GREEN_SKITTY,
},
{
.id1 = 11,
.id2 = 23,
.gridSquare = SQU_PURPLE_MAKUHITA,
.flag = F_PURPLE_MAKUHITA,
},
};
static const u8 sTableMinBets[] = {1, 3, 1, 6};
static const struct RouletteTable sRouletteTables[] =
{
// Left table
{
.minBet = 1,
.randDistanceHigh = DEGREES_PER_SLOT * 2,
.randDistanceLow = DEGREES_PER_SLOT,
.wheelSpeed = 1,
.wheelDelay = 1,
.shroomish = {
.startAngle = 45,
.dropAngle = 30,
.fallSlowdown = 1,
},
.taillow = {
.baseDropDelay = 75,
.rightStartAngle = 27,
.leftStartAngle = 24,
},
.ballSpeed = 10,
.baseTravelDist = 360,
.var1C = -0.5f
},
// Right table
{
.minBet = 3,
.randDistanceHigh = DEGREES_PER_SLOT,
.randDistanceLow = DEGREES_PER_SLOT / 2,
.wheelSpeed = 1,
.wheelDelay = 0,
.shroomish = {
.startAngle = 75,
.dropAngle = 60,
.fallSlowdown = 2,
},
.taillow = {
.baseDropDelay = 0,
.rightStartAngle = 54,
.leftStartAngle = 48,
},
.ballSpeed = 10,
.baseTravelDist = 270,
.var1C = -1.0f
}
};
// Data to flash the color indicator for each slot on the roulette wheel
static const struct RouletteFlashSettings sFlashData_Colors[NUM_ROULETTE_SLOTS + 1] =
{
{ // F_FLASH_COLOR_O_WYNAUT
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x5,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_G_AZURILL
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0xA,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_P_SKITTY
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x15,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_O_MAKUHITA
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x55,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_G_WYNAUT
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x5A,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_P_AZURILL
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x65,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_O_SKITTY
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x75,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_G_MAKUHITA
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x7A,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_P_WYNAUT
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x85,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_O_AZURILL
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x95,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_G_SKITTY
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0x9A,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_COLOR_P_MAKUHITA
.color = FLASHUTIL_USE_EXISTING_COLOR,
.paletteOffset = 0xA5,
.numColors = 1,
.delay = 1,
.unk6 = -1,
.numFadeCycles = 8,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
{ // F_FLASH_OUTER_EDGES
.color = RGB(22, 30, 29),
.paletteOffset = 0x28,
.numColors = 2,
.delay = 10,
.unk6 = -1,
.numFadeCycles = 14,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
};
// Data to flash any pokemon icon (F_FLASH_ICON) on the roulette wheel. One entry for each color row
// Each poke icon flashes with the tint of the row color it belongs to, so the pokemon itself is irrelevant
static const struct RouletteFlashSettings sFlashData_PokeIcons[NUM_BOARD_COLORS] =
{
[GET_ROW_IDX(ROW_ORANGE)] = {
.color = RGB(31, 31, 20),
.paletteOffset = 0x101,
.numColors = 5,
.delay = 30,
.unk6 = -1,
.numFadeCycles = 14,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
[GET_ROW_IDX(ROW_GREEN)] = {
.color = RGB(27, 31, 31),
.paletteOffset = 0x106,
.numColors = 5,
.delay = 30,
.unk6 = -1,
.numFadeCycles = 14,
.unk7_5 = -2,
.colorDeltaDir = 0,
},
[GET_ROW_IDX(ROW_PURPLE)] = {
.color = RGB(31, 27, 31),
.paletteOffset = 0x10B,
.numColors = 5,
.delay = 30,
.unk6 = -1,
.numFadeCycles = 14,
.unk7_5 = -2,
.colorDeltaDir = 0,
}
};
static const struct YesNoFuncTable sYesNoTable_AcceptMinBet =
{
Task_AcceptMinBet,
Task_DeclineMinBet
};
static const struct YesNoFuncTable sYesNoTable_KeepPlaying =
{
Task_ContinuePlaying,
Task_StopPlaying
};
static void CB2_Roulette(void)
{
RunTasks();
AnimateSprites();
BuildOamBuffer();
if (sRoulette->flashUtil.enabled)
RouletteFlash_Run(&sRoulette->flashUtil);
}
static void VBlankCB_Roulette(void)
{
LoadOam();
ProcessSpriteCopyRequests();
TransferPlttBuffer();
UpdateWheelPosition();
SetGpuReg(REG_OFFSET_BG1HOFS, 0x200 - sRoulette->gridX);
if (sRoulette->shroomishShadowTimer)
SetGpuReg(REG_OFFSET_BLDALPHA, sRoulette->shroomishShadowAlpha);
if (sRoulette->updateGridHighlight)
{
DmaCopy16(3, &sRoulette->tilemapBuffers[2][0xE0], (void *)BG_SCREEN_ADDR(4) + 0x1C0, 0x340);
sRoulette->updateGridHighlight = FALSE;
}
switch (sRoulette->selectionRectDrawState)
{
case SELECT_STATE_DRAW:
SetBgAttribute(0, BG_ATTR_CHARBASEINDEX, 0);
ShowBg(0);
DmaCopy16(3, &sRoulette->tilemapBuffers[0][0xE0], (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
sRoulette->selectionRectDrawState = SELECT_STATE_UPDATE;
break;
case SELECT_STATE_UPDATE:
DmaCopy16(3, &sRoulette->tilemapBuffers[0][0xE0], (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
break;
case SELECT_STATE_ERASE:
SetBgAttribute(0, BG_ATTR_CHARBASEINDEX, 2);
ShowBg(0);
DmaFill16(3, 0, (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
sRoulette->selectionRectDrawState = SELECT_STATE_WAIT;
case SELECT_STATE_WAIT:
break;
}
}
static void InitRouletteBgAndWindows(void)
{
u32 size = 0;
sRoulette = AllocZeroed(sizeof(*sRoulette));
ResetBgsAndClearDma3BusyFlags(0);
InitBgsFromTemplates(1, sBgTemplates, ARRAY_COUNT(sBgTemplates));
SetBgTilemapBuffer(0, sRoulette->tilemapBuffers[0]);
SetBgTilemapBuffer(1, sRoulette->tilemapBuffers[2]);
SetBgTilemapBuffer(2, sRoulette->tilemapBuffers[6]);
InitWindows(sWindowTemplates);
InitTextBoxGfxAndPrinters();
sTextWindowId = 0;
sRoulette->gridTilemap = malloc_and_decompress(sGrid_Tilemap, &size);
}
static void FreeRoulette(void)
{
FREE_AND_SET_NULL(sRoulette->gridTilemap);
FreeAllWindowBuffers();
UnsetBgTilemapBuffer(0);
UnsetBgTilemapBuffer(1);
UnsetBgTilemapBuffer(2);
ResetBgsAndClearDma3BusyFlags(0);
memset(sRoulette, 0, sizeof(*sRoulette));
FREE_AND_SET_NULL(sRoulette);
}
static void InitRouletteTableData(void)
{
u8 i;
u16 bgColors[3] = {RGB(24, 4, 10), RGB(10, 19, 6), RGB(24, 4, 10)}; // 3rd is never used, same as 1st
sRoulette->tableId = (gSpecialVar_0x8004 & 1);
if (gSpecialVar_0x8004 & ROULETTE_SPECIAL_RATE)
sRoulette->isSpecialRate = TRUE;
sRoulette->wheelSpeed = sRouletteTables[sRoulette->tableId].wheelSpeed;
sRoulette->wheelDelay = sRouletteTables[sRoulette->tableId].wheelDelay;
sRoulette->minBet = sTableMinBets[sRoulette->tableId + sRoulette->isSpecialRate * 2];
sRoulette->unk1 = 1;
// Left table (with min bet of 1) has red background, other table has green
if (sRoulette->minBet == 1)
gPlttBufferUnfaded[0] = gPlttBufferUnfaded[0x51] = gPlttBufferFaded[0] = gPlttBufferFaded[0x51] = bgColors[0];
else
gPlttBufferUnfaded[0] = gPlttBufferUnfaded[0x51] = gPlttBufferFaded[0] = gPlttBufferFaded[0x51] = bgColors[1];
RouletteFlash_Reset(&sRoulette->flashUtil);
// Init flash util for flashing the selected colors on the wheel
// + 1 for the additional entry to flash the outer edges on a win
for (i = 0; i < NUM_ROULETTE_SLOTS + 1; i++)
{
RouletteFlash_Add(&sRoulette->flashUtil, i, &sFlashData_Colors[i]);
}
for (i = 0; i < PARTY_SIZE; i++)
{
switch (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES2))
{
case SPECIES_SHROOMISH:
sRoulette->partySpeciesFlags |= HAS_SHROOMISH;
break;
case SPECIES_TAILLOW:
sRoulette->partySpeciesFlags |= HAS_TAILLOW;
break;
}
}
RtcCalcLocalTime();
}
// Task data for the roulette game tasks, starting with Task_StartPlaying
#define tMultiplier data[2]
#define tSelectionId data[4]
#define tWonBet data[5]
#define tBallNum data[6]
#define tTotalBallNum data[8] // Same as tBallNum but isn't cleared every 6 balls
#define tConsecutiveWins data[11]
#define tWinningSquare data[12]
#define tCoins data[13]
static void CB2_LoadRoulette(void)
{
u8 taskId;
switch (gMain.state)
{
case 0:
SetVBlankCallback(NULL);
ScanlineEffect_Stop();
SetVBlankHBlankCallbacksToNull();
ResetVramOamAndBgCntRegs();
ResetAllBgsCoordinates();
break;
case 1:
InitRouletteBgAndWindows();
DeactivateAllTextPrinters();
SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_NONE |
BLDCNT_TGT2_BG2 |
BLDCNT_TGT2_BD);
SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(10, 6));
break;
case 2:
ResetPaletteFade();
ResetSpriteData();
ResetTasks();
ResetTempTileDataBuffers();
break;
case 3:
LoadPalette(&sWheel_Pal, 0, 0x1C0);
DecompressAndCopyTileDataToVram(1, gRouletteMenu_Gfx, 0, 0, 0);
DecompressAndCopyTileDataToVram(2, gRouletteWheel_Gfx, 0, 0, 0);
break;
case 4:
if (FreeTempTileDataBuffersIfPossible())
return;
InitRouletteTableData();
CopyToBgTilemapBuffer(2, sWheel_Tilemap, 0, 0);
break;
case 5:
LoadOrFreeMiscSpritePalettesAndSheets(FALSE);
CreateWheelBallSprites();
CreateWheelCenterSprite();
CreateInterfaceSprites();
CreateGridSprites();
CreateGridBallSprites();
CreateWheelIconSprites();
break;
case 6:
AnimateSprites();
BuildOamBuffer();
SetCreditDigits(GetCoins());
SetBallCounterNumLeft(BALLS_PER_ROUND);
SetMultiplierSprite(SELECTION_NONE);
DrawGridBackground(SELECTION_NONE);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_ControlsInstruction, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
gSpriteCoordOffsetX = -60;
gSpriteCoordOffsetY = 0;
break;
case 7:
SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 |
DISPCNT_OBJ_1D_MAP |
DISPCNT_OBJ_ON);
CopyBgTilemapBufferToVram(1);
CopyBgTilemapBufferToVram(2);
ShowBg(0);
ShowBg(1);
ShowBg(2);
break;
case 8:
EnableInterrupts(INTR_FLAG_VBLANK);
SetVBlankCallback(VBlankCB_Roulette);
BeginHardwarePaletteFade(0xFF, 0, 16, 0, 1);
taskId = sRoulette->playTaskId = CreateTask(Task_StartPlaying, 0);
gTasks[taskId].tBallNum = BALLS_PER_ROUND;
gTasks[taskId].tCoins = GetCoins();
AlertTVThatPlayerPlayedRoulette(GetCoins());
sRoulette->spinTaskId = CreateTask(Task_SpinWheel, 1);
SetMainCallback2(CB2_Roulette);
return;
}
gMain.state++;
}
static void Task_SpinWheel(u8 taskId)
{
s16 sin;
s16 cos;
if (sRoulette->wheelDelayTimer++ == sRoulette->wheelDelay)
{
sRoulette->wheelDelayTimer = 0;
if ((sRoulette->wheelAngle -= sRoulette->wheelSpeed) < 0)
sRoulette->wheelAngle = 360 - sRoulette->wheelSpeed;
}
sin = Sin2(sRoulette->wheelAngle);
cos = Cos2(sRoulette->wheelAngle);
sin = sin / 16;
sRoulette->wheelRotation.a = sRoulette->wheelRotation.d = cos / 16;
sRoulette->wheelRotation.b = sin;
sRoulette->wheelRotation.c = -sin;
}
static void Task_StartPlaying(u8 taskId)
{
if (UpdatePaletteFade() == 0)
{
SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_EFFECT_NONE |
BLDCNT_TGT2_BG2 |
BLDCNT_TGT2_BD);
SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(8, 8));
gTasks[taskId].tBallNum = 0;
ResetBallDataForNewSpin(taskId);
ResetHits();
HideWheelBalls();
DrawGridBackground(SELECTION_NONE);
SetBallCounterNumLeft(BALLS_PER_ROUND);
StartTaskAfterDelayOrInput(taskId, Task_ContinuePlaying, NO_DELAY, A_BUTTON | B_BUTTON);
}
}
static void Task_AskKeepPlaying(u8 taskId)
{
DisplayYesNoMenuDefaultYes();
DrawStdWindowFrame(sTextWindowId, 0);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_KeepPlaying, 0, 1, TEXT_SKIP_DRAW, 0);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
DoYesNoFuncWithChoice(taskId, &sYesNoTable_KeepPlaying);
}
static void Task_ContinuePlaying(u8 taskId)
{
ClearStdWindowAndFrame(0, TRUE);
gTasks[taskId].func = Task_SelectFirstEmptySquare;
}
static void Task_StopPlaying(u8 taskId)
{
DestroyTask(sRoulette->spinTaskId);
ExitRoulette(taskId);
}
static void UpdateGridSelectionRect(u8 selectionId)
{
u8 temp0, temp1;
switch (selectionId)
{
case SELECTION_NONE:
FillTilemapRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
break;
case COL_WYNAUT:
case COL_AZURILL:
case COL_SKITTY:
case COL_MAKUHITA:
temp0 = (selectionId * 3 + 14);
FillTilemapRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetTilemapRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->gridTilemap[281], temp0, 7, 3, 13);
break;
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
temp1 = ((selectionId - 1) / 5 * 3 + 10);
FillTilemapRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetTilemapRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->gridTilemap[320], 14, temp1, 16, 3);
break;
// Individual square
default:
temp0 = GET_COL(selectionId) * 3 + 14;
temp1 = ((selectionId - 1) / 5 * 3 + 7);
FillTilemapRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetTilemapRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->gridTilemap[272], temp0, temp1, 3, 3);
break;
}
}
static void UpdateGridSelection(u8 taskId)
{
SetMultiplierSprite(gTasks[taskId].tSelectionId);
UpdateGridSelectionRect(gTasks[taskId].tSelectionId);
}
static void Task_StartHandleBetGridInput(u8 taskId)
{
sRoulette->selectionRectDrawState = SELECT_STATE_DRAW;
UpdateGridSelectionRect(gTasks[taskId].tSelectionId);
sRoulette->wheelDelay = 2;
sRoulette->wheelDelayTimer = 0;
gTasks[taskId].func = Task_HandleBetGridInput;
}
static void Task_SelectFirstEmptySquare(u8 taskId)
{
s16 i;
if (sRoulette->hitFlags & F_ORANGE_ROW)
{
// If the whole orange row is filled, get first in green row
for (i = SQU_GREEN_WYNAUT; i < SQU_GREEN_MAKUHITA; i++)
{
if (!(sRoulette->hitFlags & sGridSelections[i].flag))
break;
}
}
else
{
// Otherwise get first in orange row
// With only 6 balls both rows can't be filled, no need to check purple row
for (i = SQU_ORANGE_WYNAUT; i <= SQU_ORANGE_MAKUHITA; i++) // <= is accidental, but it will never get that far
{
if (!(sRoulette->hitFlags & sGridSelections[i].flag))
break;
}
}
gTasks[taskId].tSelectionId = i;
ResetBallDataForNewSpin(taskId);
DrawGridBackground(gTasks[taskId].tSelectionId);
SetMultiplierSprite(gTasks[taskId].tSelectionId);
FlashSelectionOnWheel(gTasks[taskId].tSelectionId);
gTasks[taskId].data[1] = 0;
gTasks[taskId].func = Task_StartHandleBetGridInput;
}
static bool8 CanMoveSelectionInDir(s16 *selectionId, u8 dir)
{
s8 temp1 = 0;
s8 temp = 0;
s8 moveOffsets[4] = {-5, 5, -1, 1};
s8 originalSelection = *selectionId;
switch (dir)
{
case 0: // UP
case 1: // DOWN
temp1 = GET_COL(*selectionId);
temp = temp1 + ROW_PURPLE;
if (temp1 == SELECTION_NONE)
temp1 = 5;
break;
case 2: // LEFT
case 3: // RIGHT
temp1 = GET_ROW(*selectionId);
temp = temp1 + COL_MAKUHITA;
if (temp1 == SELECTION_NONE)
temp1 = 1;
break;
}
*selectionId += moveOffsets[dir];
if (*selectionId < temp1)
*selectionId = temp;
if (*selectionId > temp)
*selectionId = temp1;
if (*selectionId != originalSelection)
return TRUE;
return FALSE;
}
static void ProcessBetGridInput(u8 taskId)
{
u8 headerOffset = 0;
bool8 dirPressed = FALSE;
if ((!(JOY_NEW(DPAD_UP)) || ((dirPressed = TRUE) && CanMoveSelectionInDir(&gTasks[taskId].tSelectionId, 0)))
&& (!(JOY_NEW(DPAD_DOWN)) || ((dirPressed = TRUE) && CanMoveSelectionInDir(&gTasks[taskId].tSelectionId, 1)))
&& (!(JOY_NEW(DPAD_LEFT)) || ((dirPressed = TRUE) && CanMoveSelectionInDir(&gTasks[taskId].tSelectionId, 2)))
&& (!(JOY_NEW(DPAD_RIGHT)) || ((dirPressed = TRUE) && CanMoveSelectionInDir(&gTasks[taskId].tSelectionId, 3)))
&& (dirPressed))
{
u8 i;
DrawGridBackground(gTasks[taskId].tSelectionId);
UpdateGridSelection(taskId);
gTasks[taskId].data[1] = 0;
PlaySE(SE_SELECT);
RouletteFlash_Stop(&sRoulette->flashUtil, 0xFFFF);
sRoulette->flashUtil.palettes[FLASH_ICON].available = sRoulette->flashUtil.palettes[FLASH_ICON_2].available = sRoulette->flashUtil.palettes[FLASH_ICON_3].available = FALSE;
FlashSelectionOnWheel(gTasks[taskId].tSelectionId);
// Switch all the poke (column) headers to gray outlines
for (i = 0; i < NUM_BOARD_POKES; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].anims)->type;
}
// If the current selection is a column with at least 1 unhit space, fill in the header
if ((u16)(gTasks[taskId].tSelectionId - 1) < COL_MAKUHITA && !(sRoulette->hitFlags & sGridSelections[gTasks[taskId].tSelectionId].flag))
{
headerOffset = gTasks[taskId].tSelectionId - 1;
gSprites[sRoulette->spriteIds[headerOffset + SPR_POKE_HEADERS]].oam.tileNum =
gSprites[sRoulette->spriteIds[headerOffset + SPR_POKE_HEADERS]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[headerOffset + SPR_POKE_HEADERS]].anims + 1)->type;
}
}
}
static void Task_StartSpin(u8 taskId)
{
IncrementDailyRouletteUses();
sRoulette->selectionRectDrawState = SELECT_STATE_ERASE;
if (sRoulette->minBet == 1)
sRoulette->wheelDelay = 1;
else
sRoulette->wheelDelay = 0;
sRoulette->wheelDelayTimer = 0;
gTasks[taskId].data[1] = 32;
gTasks[taskId].func = Task_SlideGridOffscreen;
}
static void Task_PlaceBet(u8 taskId)
{
sRoulette->betSelection[sRoulette->curBallNum] = gTasks[taskId].tSelectionId;
gTasks[taskId].tMultiplier = GetMultiplier(sRoulette->betSelection[sRoulette->curBallNum]);
SetMultiplierSprite(sRoulette->betSelection[sRoulette->curBallNum]);
if ((gTasks[taskId].tCoins -= sRoulette->minBet) < 0)
gTasks[taskId].tCoins = 0;
SetCreditDigits(gTasks[taskId].tCoins);
gTasks[taskId].func = Task_StartSpin;
}
static void Task_HandleBetGridInput(u8 taskId)
{
ProcessBetGridInput(taskId);
// Flash selection rect
switch (gTasks[taskId].data[1])
{
case 0:
UpdateGridSelectionRect(gTasks[taskId].tSelectionId);
gTasks[taskId].data[1]++;
break;
case 30:
UpdateGridSelectionRect(SELECTION_NONE);
gTasks[taskId].data[1]++;
break;
case 59:
gTasks[taskId].data[1] = 0;
break;
default:
gTasks[taskId].data[1]++;
}
if (JOY_NEW(A_BUTTON))
{
if (sRoulette->hitFlags & sGridSelections[gTasks[taskId].tSelectionId].flag)
{
// Ball has already landed on this space
PlaySE(SE_BOO);
}
else
{
m4aSongNumStart(SE_SHOP);
gTasks[taskId].func = Task_PlaceBet;
}
}
}
static void Task_SlideGridOffscreen(u8 taskId)
{
if (gTasks[taskId].data[1]-- > 0)
{
// Slide wheel over
if (gTasks[taskId].data[1] > 2)
gSpriteCoordOffsetX += 2;
// Slide grid over
if ((sRoulette->gridX += 4) == 104)
gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]].callback = &SpriteCallbackDummy;
}
else
{
ShowHideGridIcons(TRUE, -1);
ShowHideGridBalls(TRUE, -1);
gTasks[taskId].func = Task_InitBallRoll;
gTasks[taskId].data[1] = 0;
}
}
// Each table has a set base distance used to determine how far the ball will travel
// Each roll a random value is generated to add onto this distance
// Half the value returned by this function is the max distance that can be added on per roll
// i.e. the lower this value is, the closer the roll will be to a consistent distance
// Odds of a lower value increase as play continues, if the player has Shroomish and/or Taillow in the party, and dependent on the time
static u8 GetRandomForBallTravelDistance(u16 ballNum, u16 rand)
{
switch (sRoulette->partySpeciesFlags)
{
case HAS_SHROOMISH:
case HAS_TAILLOW:
// one of the two is in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 10)
{
if (ballNum < BALLS_PER_ROUND * 2 || (rand & 1))
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
else
return 1;
}
else if (!(rand & 3))
{
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
}
else
{
return sRouletteTables[sRoulette->tableId].randDistanceLow;
}
break;
case HAS_SHROOMISH | HAS_TAILLOW:
// both are in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 11)
{
if (ballNum < BALLS_PER_ROUND || (rand & 1))
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
else
return 1;
}
else if ((rand & 1) && ballNum > BALLS_PER_ROUND)
{
return sRouletteTables[sRoulette->tableId].randDistanceLow / 4;
}
else
{
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
}
break;
case 0:
default:
// neither is in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 10)
{
if (!(rand & 3))
return 1;
else
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
}
else if (!(rand & 3))
{
if (ballNum > BALLS_PER_ROUND * 2)
return sRouletteTables[sRoulette->tableId].randDistanceLow / 2;
else
return sRouletteTables[sRoulette->tableId].randDistanceLow;
}
else if (rand & (1 << 15))
{
if (ballNum > BALLS_PER_ROUND * 2)
return sRouletteTables[sRoulette->tableId].randDistanceLow;
else
return sRouletteTables[sRoulette->tableId].randDistanceHigh;
}
else
{
return sRouletteTables[sRoulette->tableId].randDistanceHigh * 2;
}
break;
}
}
static void Task_InitBallRoll(u8 taskId)
{
u8 randTravelMod;
s8 randTravelDist;
s8 startAngleId;
u16 travelDist = 0;
u16 rand;
u16 randmod;
u16 startAngles[4] = {0, 180, 90, 270}; // possible angles to start ball from
rand = Random();
randmod = rand % 100;
sRoulette->curBallSpriteId = gTasks[taskId].tBallNum;
// BALL_STATE_ROLLING set below
sRoulette->ballState = sRoulette->hitSlot = sRoulette->stuckHitSlot = 0;
randTravelMod = GetRandomForBallTravelDistance(gTasks[taskId].tTotalBallNum, rand);
randTravelDist = (rand % randTravelMod) - (randTravelMod / 2);
if (gLocalTime.hours < 13)
startAngleId = 0;
else
startAngleId = 1;
if (randmod < 80)
startAngleId *= 2;
else
startAngleId = (1 - startAngleId) * 2;
sRoulette->ballTravelDist = travelDist = sRouletteTables[sRoulette->tableId].baseTravelDist + randTravelDist;
travelDist = S16TOPOSFLOAT(travelDist) / 5.0f;
sRoulette->ballTravelDistFast = travelDist * 3;
sRoulette->ballTravelDistSlow = sRoulette->ballTravelDistMed = travelDist;
sRoulette->ballAngle = S16TOPOSFLOAT(startAngles[(rand & 1) + startAngleId]);
sRoulette->ballAngleSpeed = S16TOPOSFLOAT(sRouletteTables[sRoulette->tableId].ballSpeed);
sRoulette->ballAngleAccel = ((sRoulette->ballAngleSpeed * 0.5f) - sRoulette->ballAngleSpeed) / S16TOPOSFLOAT(sRoulette->ballTravelDistFast);
sRoulette->ballDistToCenter = 68.0f;
sRoulette->ballFallAccel = 0.0f;
sRoulette->ballFallSpeed = -(8.0f / S16TOPOSFLOAT(sRoulette->ballTravelDistFast));
sRoulette->varA0 = 36.0f;
gTasks[taskId].func = Task_RollBall;
}
static void Task_RollBall(u8 taskId)
{
sRoulette->ballRolling = TRUE;
sRoulette->ball = &gSprites[sRoulette->spriteIds[sRoulette->curBallSpriteId]];
sRoulette->ball->callback = SpriteCB_RollBall_Start;
gTasks[taskId].tBallNum++;
gTasks[taskId].tTotalBallNum++;
SetBallCounterNumLeft(BALLS_PER_ROUND - gTasks[taskId].tBallNum);
m4aSongNumStart(SE_ROULETTE_BALL);
gTasks[taskId].func = Task_RecordBallHit;
}
static void Task_RecordBallHit(u8 taskId)
{
// Wait for ball to finish rolling
if (sRoulette->ballState != BALL_STATE_ROLLING)
{
// If the ball got stuck, wait for it to be unstuck
if (sRoulette->ballStuck)
{
if (sRoulette->ballUnstuck)
{
sRoulette->ballUnstuck = FALSE;
sRoulette->ballStuck = FALSE;
}
}
else
{
if (gTasks[taskId].data[1] == 0)
{
bool8 won = IsHitInBetSelection(RecordHit(taskId, sRoulette->hitSlot), sRoulette->betSelection[sRoulette->curBallNum]);
gTasks[taskId].tWonBet = won;
if (won == TRUE)
RouletteFlash_Enable(&sRoulette->flashUtil, F_FLASH_OUTER_EDGES);
}
if (gTasks[taskId].data[1] <= 60)
{
if (JOY_NEW(A_BUTTON))
gTasks[taskId].data[1] = 60;
gTasks[taskId].data[1]++;
}
else
{
DrawGridBackground(sRoulette->betSelection[sRoulette->curBallNum]);
ShowHideGridIcons(FALSE, gTasks[taskId].tWinningSquare);
ShowHideGridBalls(FALSE, gTasks[taskId].tBallNum - 1);
gTasks[taskId].data[1] = 32;
gTasks[taskId].func = Task_SlideGridOnscreen;
}
}
}
}
static void Task_SlideGridOnscreen(u8 taskId)
{
if (gTasks[taskId].data[1]-- > 0)
{
// Slide wheel over
if (gTasks[taskId].data[1] > 2)
gSpriteCoordOffsetX -= 2;
// Slide grid over
if ((sRoulette->gridX -= 4) == 104)
gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]].callback = SpriteCB_GridSquare;
}
else
{
ShowHideWinSlotCursor(gTasks[taskId].tWinningSquare);
if (gTasks[taskId].tWonBet == TRUE)
gTasks[taskId].data[1] = 121;
else
gTasks[taskId].data[1] = 61;
gTasks[taskId].func = Task_FlashBallOnWinningSquare;
}
}
static void Task_FlashBallOnWinningSquare(u8 taskId)
{
if (gTasks[taskId].data[1]-- > 1)
{
switch (gTasks[taskId].data[1] % 16)
{
case 8:
// Winning square uncovered
ShowHideGridIcons(FALSE, -1);
ShowHideGridBalls(FALSE, -1);
break;
case 0:
// Winning square occluded by ball
ShowHideGridIcons(FALSE, gTasks[taskId].tWinningSquare);
ShowHideGridBalls(FALSE, gTasks[taskId].tBallNum - 1);
break;
}
}
else
{
StartTaskAfterDelayOrInput(taskId, Task_PrintSpinResult, 30, 0);
}
}
static void Task_TryIncrementWins(u8 taskId)
{
switch (gTasks[taskId].tWonBet)
{
case TRUE:
case 2: // never happens
if (IsFanfareTaskInactive())
{
u32 wins = GetGameStat(GAME_STAT_CONSECUTIVE_ROULETTE_WINS);
if (wins < ++gTasks[taskId].tConsecutiveWins)
SetGameStat(GAME_STAT_CONSECUTIVE_ROULETTE_WINS, gTasks[taskId].tConsecutiveWins);
StartTaskAfterDelayOrInput(taskId, Task_PrintPayout, NO_DELAY, A_BUTTON | B_BUTTON);
}
break;
case FALSE:
default:
if (!IsSEPlaying())
{
gTasks[taskId].tConsecutiveWins = 0;
StartTaskAfterDelayOrInput(taskId, Task_EndTurn, NO_DELAY, A_BUTTON | B_BUTTON);
}
break;
}
}
static void Task_PrintSpinResult(u8 taskId)
{
switch (gTasks[taskId].tWonBet)
{
case TRUE:
case 2: // never happens
if (gTasks[taskId].tMultiplier == MAX_MULTIPLIER)
{
PlayFanfare(MUS_SLOTS_JACKPOT);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_Jackpot, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
}
else
{
PlayFanfare(MUS_SLOTS_WIN);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_ItsAHit, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
}
break;
case FALSE:
default:
m4aSongNumStart(SE_FAILURE);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_NothingDoing, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
break;
}
gTasks[taskId].data[1] = 0;
gTasks[taskId].func = Task_TryIncrementWins;
}
#define tPayout data[1]
static void Task_GivePayout(u8 taskId)
{
switch (gTasks[taskId].data[7])
{
case 0:
gTasks[taskId].tCoins++;
m4aSongNumStart(SE_PIN);
SetCreditDigits(gTasks[taskId].tCoins);
if (gTasks[taskId].tCoins >= MAX_COINS)
{
gTasks[taskId].tPayout = 0;
}
else
{
gTasks[taskId].tPayout--;
gTasks[taskId].data[7]++;
}
break;
case 3:
m4aSongNumStop(SE_PIN);
gTasks[taskId].data[7] = 0;
break;
default:
gTasks[taskId].data[7]++;
break;
}
if (gTasks[taskId].tPayout == 0)
StartTaskAfterDelayOrInput(taskId, Task_EndTurn, NO_DELAY, A_BUTTON | B_BUTTON);
}
static void Task_PrintPayout(u8 taskId)
{
ConvertIntToDecimalStringN(gStringVar1, (sRoulette->minBet * gTasks[taskId].tMultiplier), STR_CONV_MODE_LEFT_ALIGN, 2);
StringExpandPlaceholders(gStringVar4, Roulette_Text_YouveWonXCoins);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, gStringVar4, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
gTasks[taskId].tPayout = (sRoulette->minBet * gTasks[taskId].tMultiplier);
gTasks[taskId].data[7] = 0;
gTasks[taskId].func = Task_GivePayout;
}
#undef tPayout
static void Task_EndTurn(u8 taskId)
{
RouletteFlash_Stop(&sRoulette->flashUtil, 0xFFFF);
sRoulette->flashUtil.palettes[FLASH_ICON].available = sRoulette->flashUtil.palettes[FLASH_ICON_2].available = sRoulette->flashUtil.palettes[FLASH_ICON_3].available = FALSE;
gSprites[sRoulette->spriteIds[SPR_WHEEL_ICONS + sGridSelections[gTasks[taskId].tWinningSquare].spriteIdOffset]].invisible = TRUE;
gTasks[taskId].func = Task_TryPrintEndTurnMsg;
}
static void Task_TryPrintEndTurnMsg(u8 taskId)
{
u8 i = 0;
gTasks[taskId].tSelectionId = i;
sRoulette->betSelection[sRoulette->curBallNum] = SELECTION_NONE;
DrawGridBackground(SELECTION_NONE);
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].invisible = TRUE;
for (i = 0; i < NUM_BOARD_POKES; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADERS]].anims)->type;
}
if (gTasks[taskId].tCoins >= sRoulette->minBet)
{
if (gTasks[taskId].tBallNum == BALLS_PER_ROUND)
{
// Reached Ball 6, clear board
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_BoardWillBeCleared, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
StartTaskAfterDelayOrInput(taskId, Task_ClearBoard, NO_DELAY, A_BUTTON | B_BUTTON);
}
else if (gTasks[taskId].tCoins == MAX_COINS)
{
// Player maxed out coins
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_CoinCaseIsFull, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
StartTaskAfterDelayOrInput(taskId, Task_AskKeepPlaying, NO_DELAY, A_BUTTON | B_BUTTON);
}
else
{
// No special msg, ask to continue
gTasks[taskId].func = Task_AskKeepPlaying;
}
}
else
{
// Player out of coins
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_NoCoinsLeft, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
StartTaskAfterDelayOrInput(taskId, Task_StopPlaying, 60, A_BUTTON | B_BUTTON);
}
}
static void Task_ClearBoard(u8 taskId)
{
u8 i = 0;
gTasks[taskId].tBallNum = 0;
ResetBallDataForNewSpin(taskId);
ResetHits();
HideWheelBalls();
DrawGridBackground(SELECTION_NONE);
SetBallCounterNumLeft(BALLS_PER_ROUND);
for (i = 0; i < NUM_ROULETTE_SLOTS; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_WHEEL_ICONS]].invisible = FALSE;
}
if (gTasks[taskId].tCoins == MAX_COINS)
{
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, FONT_NORMAL, Roulette_Text_CoinCaseIsFull, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(sTextWindowId, COPYWIN_FULL);
StartTaskAfterDelayOrInput(taskId, Task_AskKeepPlaying, NO_DELAY, A_BUTTON | B_BUTTON);
}
else
{
gTasks[taskId].func = Task_AskKeepPlaying;
}
}
static void ExitRoulette(u8 taskId)
{
RouletteFlash_Stop(&sRoulette->flashUtil, 0xFFFF);
RouletteFlash_Reset(&sRoulette->flashUtil);
SetCoins(gTasks[taskId].tCoins);
if (GetCoins() < sRoulette->minBet)
gSpecialVar_0x8004 = TRUE;
else
gSpecialVar_0x8004 = FALSE;
TryPutFindThatGamerOnAir(GetCoins());
BeginHardwarePaletteFade(0xFF, 0, 0, 16, 0);
gTasks[taskId].func = Task_ExitRoulette;
}
static void Task_ExitRoulette(u8 taskId)
{
if (UpdatePaletteFade() == 0)
{
SetVBlankCallback(NULL);
gSpriteCoordOffsetX = gSpriteCoordOffsetY = 0;
ResetVramOamAndBgCntRegs();
ResetAllBgsCoordinates();
SetGpuReg(REG_OFFSET_BLDCNT, 0);
SetGpuReg(REG_OFFSET_BLDALPHA, 0);
SetGpuReg(REG_OFFSET_BLDY, 0);
FreeAllSpritePalettes();
ResetPaletteFade();
ResetSpriteData();
FreeRoulette();
gFieldCallback = FieldCB_ContinueScriptHandleMusic;
SetMainCallback2(CB2_ReturnToField);
DestroyTask(taskId);
}
}
static void Task_WaitForNextTask(u8 taskId)
{
if (sRoulette->taskWaitDelay == 0 || JOY_NEW(sRoulette->taskWaitKey))
{
gTasks[taskId].func = sRoulette->nextTask;
if (sRoulette->taskWaitKey > 0)
PlaySE(SE_SELECT);
sRoulette->nextTask = NULL;
sRoulette->taskWaitKey = 0;
sRoulette->taskWaitDelay = 0;
}
if (sRoulette->taskWaitDelay != NO_DELAY)
sRoulette->taskWaitDelay--;
}
static void StartTaskAfterDelayOrInput(u8 taskId, TaskFunc task, u16 delay, u16 key)
{
sRoulette->prevTask = gTasks[taskId].func;
if (task == NULL)
task = sRoulette->prevTask;
sRoulette->nextTask = task;
sRoulette->taskWaitDelay = delay;
if (delay == NO_DELAY && key == 0)
sRoulette->taskWaitKey = 0xFFFF;
else
sRoulette->taskWaitKey = key;
gTasks[taskId].func = Task_WaitForNextTask;
}
static void ResetBallDataForNewSpin(u8 taskId)
{
u8 i = 0;
sRoulette->unk0 = FALSE;
sRoulette->ballRolling = FALSE;
sRoulette->ballStuck = FALSE;
sRoulette->ballUnstuck = FALSE;
sRoulette->useTaillow = FALSE;
for (i = 0; i < BALLS_PER_ROUND; i++)
sRoulette->betSelection[i] = SELECTION_NONE;
sRoulette->curBallNum = 0;
gTasks[taskId].data[1] = 0;
}
static void ResetHits(void)
{
u8 i;
sRoulette->hitFlags = 0;
for (i = 0; i < BALLS_PER_ROUND; i++)
sRoulette->hitSquares[i] = 0;
for (i = 0; i < NUM_BOARD_POKES; i++)
sRoulette->pokeHits[i] = 0;
for (i = 0; i < NUM_BOARD_COLORS; i++)
sRoulette->colorHits[i] = 0;
ShowHideGridBalls(TRUE, -1);
}
static u8 RecordHit(u8 taskId, u8 slotId)
{
u8 i, j;
u32 columnFlags[NUM_BOARD_POKES] = {
F_WYNAUT_COL | F_ORANGE_WYNAUT | F_GREEN_WYNAUT | F_PURPLE_WYNAUT,
F_AZURILL_COL | F_ORANGE_AZURILL | F_GREEN_AZURILL | F_PURPLE_AZURILL,
F_SKITTY_COL | F_ORANGE_SKITTY | F_GREEN_SKITTY | F_PURPLE_SKITTY,
F_MAKUHITA_COL | F_ORANGE_MAKUHITA | F_GREEN_MAKUHITA | F_PURPLE_MAKUHITA
};
u32 rowFlags[NUM_BOARD_COLORS] = {
F_ORANGE_ROW | F_ORANGE_WYNAUT | F_ORANGE_AZURILL | F_ORANGE_SKITTY | F_ORANGE_MAKUHITA,
F_GREEN_ROW | F_GREEN_WYNAUT | F_GREEN_AZURILL | F_GREEN_SKITTY | F_GREEN_MAKUHITA,
F_PURPLE_ROW | F_PURPLE_WYNAUT | F_PURPLE_AZURILL | F_PURPLE_SKITTY | F_PURPLE_MAKUHITA
};
if (slotId >= NUM_ROULETTE_SLOTS)
return 0;
sRoulette->hitSquares[gTasks[taskId].tBallNum - 1] = sRouletteSlots[slotId].gridSquare;
gTasks[taskId].tWinningSquare = sRouletteSlots[slotId].gridSquare;
sRoulette->hitFlags |= sRouletteSlots[slotId].flag;
for (i = 0; i < NUM_BOARD_POKES; i++)
{
if (sRouletteSlots[slotId].flag & columnFlags[i])
sRoulette->pokeHits[i]++;
// If hit every color of a poke, set column completed
if (sRoulette->pokeHits[i] >= NUM_BOARD_COLORS)
sRoulette->hitFlags |= columnFlags[i];
}
for (j = 0; j < NUM_BOARD_COLORS; j++)
{
if (sRouletteSlots[slotId].flag & rowFlags[j])
sRoulette->colorHits[j]++;
// If hit every poke of a color, set row completed
if (sRoulette->colorHits[j] >= NUM_BOARD_POKES)
sRoulette->hitFlags |= rowFlags[j];
}
return sRouletteSlots[slotId].gridSquare;
}
static bool8 IsHitInBetSelection(u8 gridSquare, u8 betSelection)
{
u8 hit = gridSquare;
if (--gridSquare < NUM_GRID_SELECTIONS)
{
switch (betSelection)
{
case SELECTION_NONE:
return 3; // should never happen, player must place bet
case COL_WYNAUT:
case COL_AZURILL:
case COL_SKITTY:
case COL_MAKUHITA:
if (hit == betSelection + ROW_ORANGE
|| hit == betSelection + ROW_GREEN
|| hit == betSelection + ROW_PURPLE)
return TRUE;
break;
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
if (hit >= (betSelection + COL_WYNAUT)
&& hit <= (betSelection + COL_MAKUHITA))
return TRUE;
break;
// Individual square
default:
if (hit == betSelection)
return TRUE;
}
}
return FALSE;
}
static void FlashSelectionOnWheel(u8 selectionId)
{
u16 flashFlags = 0;
u8 numSelected;
u16 palOffset;
u8 i;
switch (selectionId)
{
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
// Flash colors of row selection
for (i = (selectionId + 1); i < (selectionId + 5); i++)
{
if (!(sRoulette->hitFlags & sGridSelections[i].flag))
flashFlags |= sGridSelections[i].flashFlags;
}
RouletteFlash_Enable(&sRoulette->flashUtil, flashFlags &= ~(F_FLASH_ICON));
break;
default:
{
// Selection is either a column or individual square
struct RouletteFlashSettings iconFlash[NUM_BOARD_COLORS];
memcpy(iconFlash, sFlashData_PokeIcons, sizeof(iconFlash));
if (selectionId >= COL_WYNAUT && selectionId <= COL_MAKUHITA)
numSelected = NUM_BOARD_COLORS; // Selection is full column
else
numSelected = 1;
palOffset = GET_ROW_IDX(selectionId);
switch (GET_COL(selectionId))
{
// The specific color of the poke it references doesn't matter, because the icons of a poke share a palette
// So it just uses the first sprite ID of each
case COL_WYNAUT:
palOffset = gSprites[sRoulette->spriteIds[SPR_WHEEL_ICON_ORANGE_WYNAUT]].oam.paletteNum * 16;
break;
case COL_AZURILL:
palOffset = gSprites[sRoulette->spriteIds[SPR_WHEEL_ICON_GREEN_AZURILL]].oam.paletteNum * 16;
break;
case COL_SKITTY:
palOffset = gSprites[sRoulette->spriteIds[SPR_WHEEL_ICON_PURPLE_SKITTY]].oam.paletteNum * 16;
break;
case COL_MAKUHITA:
palOffset = gSprites[sRoulette->spriteIds[SPR_WHEEL_ICON_ORANGE_MAKUHITA]].oam.paletteNum * 16;
break;
}
if (numSelected == 1)
{
// Selection is individual square, add entry in flash util for its icon
if (!(sRoulette->hitFlags & sGridSelections[selectionId].flag))
{
iconFlash[GET_ROW_IDX(selectionId)].paletteOffset += palOffset;
RouletteFlash_Add(&sRoulette->flashUtil, NUM_ROULETTE_SLOTS + 1, &iconFlash[GET_ROW_IDX(selectionId)]);
}
else
{
// Square was already hit, don't flash it
break;
}
}
else
{
// Selection is full column, add entry in flash util for each unhit space's icon
// If there is only 1 unhit space, also add its flags so its color will flash as well
for (i = 0; i < NUM_BOARD_COLORS; i++)
{
u8 columnSlotId = i * 5 + selectionId + 5;
if (!(sRoulette->hitFlags & sGridSelections[columnSlotId].flag))
{
iconFlash[GET_ROW_IDX(columnSlotId)].paletteOffset += palOffset;
RouletteFlash_Add(&sRoulette->flashUtil, i + NUM_ROULETTE_SLOTS + 1, &iconFlash[GET_ROW_IDX(columnSlotId)]);
if (numSelected == 3)
flashFlags = sGridSelections[columnSlotId].flashFlags;
numSelected--;
}
}
// If there was more than 1 space in the column, reset flags; only icons will flash
if (numSelected != 2)
flashFlags = 0;
}
// Do flash
RouletteFlash_Enable(&sRoulette->flashUtil, flashFlags |= sGridSelections[selectionId].flashFlags);
break;
}
}
}
static void DrawGridBackground(u8 selectionId)
{
vu8 i, j;
vu16 x, y;
vu8 tilemapOffset;
u8 selectionIds[NUM_BOARD_POKES >= NUM_BOARD_COLORS ? NUM_BOARD_POKES + 1 : NUM_BOARD_COLORS + 1];
u8 numSquares;
sRoulette->updateGridHighlight = TRUE;
ShowHideGridIcons(FALSE, 0);
SetTilemapRect(sRoulette->tilemapBuffers[2], sRoulette->gridTilemap, 14, 7, 16, 13);
// Highlight selected square
// (just buffers the highlight, it's actually drawn in VBlankCB_Roulette)
switch (selectionId)
{
case SELECTION_NONE:
return;
case COL_WYNAUT:
case COL_AZURILL:
case COL_SKITTY:
case COL_MAKUHITA:
numSquares = NUM_BOARD_COLORS + 1; // For each poke column, 3 colors and a header
for (i = 0; i < numSquares; i++)
selectionIds[i] = i * ROW_ORANGE + selectionId;
break;
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
numSquares = NUM_BOARD_POKES + 1; // For each color row, 4 pokes and a header
for (i = 0; i < numSquares; i++)
selectionIds[i] = i + selectionId;
break;
// Individual square
default:
numSquares = 1;
selectionIds[0] = selectionId;
}
for (i = 0; i < numSquares; i++)
{
tilemapOffset = sGridSelections[selectionIds[i]].tilemapOffset;
x = sGridSelections[selectionIds[i]].x;
// Grid square highlight is drawn in 9 segments, starting from the top left of the square
// Each iteration of this loop draws 3 segments to form a single horizontal segment
for (j = 0; j < 3; j++)
{
y = (sGridSelections[selectionIds[i]].y + j) * 32;
sRoulette->tilemapBuffers[2][x + y + 0] = sRoulette->gridTilemap[(tilemapOffset + j) * 3 + 208 + 0];
sRoulette->tilemapBuffers[2][x + y + 1] = sRoulette->gridTilemap[(tilemapOffset + j) * 3 + 208 + 1];
sRoulette->tilemapBuffers[2][x + y + 2] = sRoulette->gridTilemap[(tilemapOffset + j) * 3 + 208 + 2];
}
}
}
static u8 GetMultiplier(u8 selectionId)
{
u8 multipliers[5] = {0, 3, 4, 6, MAX_MULTIPLIER};
if (selectionId > NUM_GRID_SELECTIONS)
selectionId = 0;
switch (sGridSelections[selectionId].baseMultiplier)
{
case NUM_BOARD_COLORS:
selectionId = GET_ROW_IDX(selectionId);
// If already hit all pokes of this color, multiplier is 0
if (sRoulette->colorHits[selectionId] >= NUM_BOARD_POKES)
return 0;
return multipliers[sRoulette->colorHits[selectionId] + 1];
case NUM_BOARD_POKES:
selectionId = GET_COL_IDX(selectionId);
// If already hit all colors of this poke, multiplier is 0
if (sRoulette->pokeHits[selectionId] >= NUM_BOARD_COLORS)
return 0;
return multipliers[sRoulette->pokeHits[selectionId] + 2];
case NUM_ROULETTE_SLOTS:
// If square has been hit already, multiplier is 0
if (sRoulette->hitFlags & sGridSelections[selectionId].flag)
return 0;
return multipliers[ARRAY_COUNT(multipliers) - 1];
}
return 0;
}
static void UpdateWheelPosition(void)
{
s32 bg2x;
s32 bg2y;
SetGpuReg(REG_OFFSET_BG2PA, sRoulette->wheelRotation.a);
SetGpuReg(REG_OFFSET_BG2PB, sRoulette->wheelRotation.b);
SetGpuReg(REG_OFFSET_BG2PC, sRoulette->wheelRotation.c);
SetGpuReg(REG_OFFSET_BG2PD, sRoulette->wheelRotation.d);
bg2x = 0x7400 - sRoulette->wheelRotation.a * (gSpriteCoordOffsetX + 116)
- sRoulette->wheelRotation.b * (gSpriteCoordOffsetY + 80);
bg2y = 0x5400 - sRoulette->wheelRotation.c * (gSpriteCoordOffsetX + 116)
- sRoulette->wheelRotation.d * (gSpriteCoordOffsetY + 80);
SetGpuReg(REG_OFFSET_BG2X_L, bg2x);
SetGpuReg(REG_OFFSET_BG2X_H, (bg2x & 0x0fff0000) >> 16);
SetGpuReg(REG_OFFSET_BG2Y_L, bg2y);
SetGpuReg(REG_OFFSET_BG2Y_H, (bg2y & 0x0fff0000) >> 16);
}
static const u8 sFiller[3] = {};
static const u16 sShadow_Pal[] = INCBIN_U16("graphics/roulette/shadow.gbapal");
static const u16 sBall_Pal[] = INCBIN_U16("graphics/roulette/ball.gbapal");
static const u16 sBallCounter_Pal[] = INCBIN_U16("graphics/roulette/ball_counter.gbapal");
static const u16 sCursor_Pal[] = INCBIN_U16("graphics/roulette/cursor.gbapal");
static const u16 sCredit_Pal[] = INCBIN_U16("graphics/roulette/credit.gbapal");
static const u16 sShroomish_Pal[] = INCBIN_U16("graphics/roulette/shroomish.gbapal");
static const u16 sTaillow_Pal[] = INCBIN_U16("graphics/roulette/tailow.gbapal");
static const u16 sGridIcons_Pal[] = INCBIN_U16("graphics/roulette/grid_icons.gbapal");
static const u16 sWynaut_Pal[] = INCBIN_U16("graphics/roulette/wynaut.gbapal");
static const u16 sAzurill_Pal[] = INCBIN_U16("graphics/roulette/azurill.gbapal");
static const u16 sSkitty_Pal[] = INCBIN_U16("graphics/roulette/skitty.gbapal");
static const u16 sMakuhita_Pal[] = INCBIN_U16("graphics/roulette/makuhita.gbapal");
static const u16 sUnused1_Pal[] = INCBIN_U16("graphics/roulette/unused_1.gbapal");
static const u16 sUnused2_Pal[] = INCBIN_U16("graphics/roulette/unused_2.gbapal");
static const u16 sUnused3_Pal[] = INCBIN_U16("graphics/roulette/unused_3.gbapal");
static const u16 sUnused4_Pal[] = INCBIN_U16("graphics/roulette/unused_4.gbapal");
static const u32 sBall_Gfx[] = INCBIN_U32("graphics/roulette/ball.4bpp.lz");
static const u32 sBallCounter_Gfx[] = INCBIN_U32("graphics/roulette/ball_counter.4bpp.lz");
static const u32 sShroomishTaillow_Gfx[] = INCBIN_U32("graphics/roulette/roulette_tilt.4bpp.lz");
static const u32 sGridIcons_Gfx[] = INCBIN_U32("graphics/roulette/grid_icons.4bpp.lz");
static const u32 sWheelIcons_Gfx[] = INCBIN_U32("graphics/roulette/wheel_icons.4bpp.lz");
static const u32 sShadow_Gfx[] = INCBIN_U32("graphics/roulette/shadow.4bpp.lz");
static const u32 sCursor_Gfx[] = INCBIN_U32("graphics/roulette/cursor.4bpp.lz");
static const struct SpritePalette sSpritePalettes[] =
{
{ .data = sShadow_Pal, .tag = PALTAG_SHADOW },
{ .data = sBall_Pal, .tag = PALTAG_BALL },
{ .data = sBallCounter_Pal, .tag = PALTAG_BALL_COUNTER },
{ .data = sCursor_Pal, .tag = PALTAG_CURSOR },
{ .data = sCredit_Pal, .tag = PALTAG_INTERFACE },
{ .data = sShroomish_Pal, .tag = PALTAG_SHROOMISH },
{ .data = sTaillow_Pal, .tag = PALTAG_TAILLOW },
{ .data = sGridIcons_Pal, .tag = PALTAG_GRID_ICONS },
{ .data = sWynaut_Pal, .tag = PALTAG_WYNAUT },
{ .data = sAzurill_Pal, .tag = PALTAG_AZURILL },
{ .data = sSkitty_Pal, .tag = PALTAG_SKITTY },
{ .data = sMakuhita_Pal, .tag = PALTAG_MAKUHITA },
{}
};
static const struct OamData sOam_GridHeader =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x32),
.size = SPRITE_SIZE(32x32),
.priority = 1,
};
static const struct OamData sOam_GridIcon =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x16),
.size = SPRITE_SIZE(16x16),
.priority = 1,
};
static const struct OamData sOam_WheelIcon =
{
.y = 60,
.affineMode = ST_OAM_AFFINE_DOUBLE,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x32),
.size = SPRITE_SIZE(16x32),
.priority = 2,
};
static const union AnimCmd sAffineAnim_Unused1[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAffineAnims_Unused1[] =
{
sAffineAnim_Unused1
};
static const union AffineAnimCmd sAffineAnim_Unused2[] =
{
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const sAffineAnims_Unused2[] =
{
sAffineAnim_Unused2
};
static const struct CompressedSpriteSheet sSpriteSheet_WheelIcons =
{
.data = sWheelIcons_Gfx,
.size = 0xC00,
.tag = GFXTAG_WHEEL_ICONS
};
static const union AnimCmd sAnim_WheelIcons[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(32, 0),
ANIMCMD_FRAME(64, 0),
ANIMCMD_FRAME(72, 0),
ANIMCMD_FRAME(8, 0),
ANIMCMD_FRAME(40, 0),
ANIMCMD_FRAME(48, 0),
ANIMCMD_FRAME(80, 0),
ANIMCMD_FRAME(16, 0),
ANIMCMD_FRAME(24, 0),
ANIMCMD_FRAME(56, 0),
ANIMCMD_FRAME(88, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAnim_WheelIcon_OrangeWynaut[] =
{
&sAnim_WheelIcons[0]
};
static const union AnimCmd *const sAnim_WheelIcon_GreenAzurill[] =
{
&sAnim_WheelIcons[1]
};
static const union AnimCmd *const sAnim_WheelIcon_PurpleSkitty[] =
{
&sAnim_WheelIcons[2]
};
static const union AnimCmd *const sAnim_WheelIcon_OrangeMakuhita[] =
{
&sAnim_WheelIcons[3]
};
static const union AnimCmd *const sAnim_WheelIcon_GreenWynaut[] =
{
&sAnim_WheelIcons[4]
};
static const union AnimCmd *const sAnim_WheelIcon_PurpleAzurill[] =
{
&sAnim_WheelIcons[5]
};
static const union AnimCmd *const sAnim_WheelIcon_OrangeSkitty[] =
{
&sAnim_WheelIcons[6]
};
static const union AnimCmd *const sAnim_WheelIcon_GreenMakuhita[] =
{
&sAnim_WheelIcons[7]
};
static const union AnimCmd *const sAnim_WheelIcon_PurpleWynaut[] =
{
&sAnim_WheelIcons[8]
};
static const union AnimCmd *const sAnim_WheelIcon_OrangeAzurill[] =
{
&sAnim_WheelIcons[9]
};
static const union AnimCmd *const sAnim_WheelIcon_GreenSkitty[] =
{
&sAnim_WheelIcons[10]
};
static const union AnimCmd *const sAnim_WheelIcon_PurpleMakuhita[] =
{
&sAnim_WheelIcons[11]
};
static const struct CompressedSpriteSheet sSpriteSheet_Headers =
{
.data = gRouletteHeaders_Gfx,
.size = 0x1600,
.tag = GFXTAG_HEADERS
};
static const struct CompressedSpriteSheet sSpriteSheet_GridIcons =
{
.data = sGridIcons_Gfx,
.size = 0x400,
.tag = GFXTAG_GRID_ICONS
};
static const union AnimCmd sAnim_Headers[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(16, 0),
ANIMCMD_FRAME(32, 0),
ANIMCMD_FRAME(48, 0),
ANIMCMD_FRAME(64, 0),
ANIMCMD_FRAME(80, 0),
ANIMCMD_FRAME(96, 0),
ANIMCMD_FRAME(112, 0),
ANIMCMD_FRAME(128, 0),
ANIMCMD_FRAME(144, 0),
ANIMCMD_FRAME(160, 0),
ANIMCMD_END
};
static const union AnimCmd sAnim_GridIcons[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(4, 0),
ANIMCMD_FRAME(8, 0),
ANIMCMD_FRAME(12, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAnim_WynautHeader[] =
{
&sAnim_Headers[0]
};
static const union AnimCmd *const sAnim_AzurillHeader[] =
{
&sAnim_Headers[2]
};
static const union AnimCmd *const sAnim_SkittyHeader[] =
{
&sAnim_Headers[4]
};
static const union AnimCmd *const sAnim_MakuhitaHeader[] =
{
&sAnim_Headers[6]
};
static const union AnimCmd *const sAnim_OrangeHeader[] =
{
&sAnim_Headers[8]
};
static const union AnimCmd *const sAnim_GreenHeader[] =
{
&sAnim_Headers[9]
};
static const union AnimCmd *const sAnim_PurpleHeader[] =
{
&sAnim_Headers[10]
};
static const union AnimCmd *const sAnim_GridIcon_Wynaut[] =
{
&sAnim_GridIcons[0]
};
static const union AnimCmd *const sAnim_GridIcon_Azurill[] =
{
&sAnim_GridIcons[1]
};
static const union AnimCmd *const sAnim_GridIcon_Skitty[] =
{
&sAnim_GridIcons[2]
};
static const union AnimCmd *const sAnim_GridIcon_Makuhita[] =
{
&sAnim_GridIcons[3]
};
static const struct SpriteTemplate sSpriteTemplates_PokeHeaders[NUM_BOARD_POKES] =
{
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_WynautHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_AzurillHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_SkittyHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_MakuhitaHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
}
};
static const struct SpriteTemplate sSpriteTemplates_ColorHeaders[NUM_BOARD_COLORS] =
{
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_OrangeHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_GreenHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridHeader,
.anims = sAnim_PurpleHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
}
};
static const struct SpriteTemplate sSpriteTemplate_GridIcons[NUM_BOARD_POKES] =
{
{
.tileTag = GFXTAG_GRID_ICONS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridIcon,
.anims = sAnim_GridIcon_Wynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_GRID_ICONS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridIcon,
.anims = sAnim_GridIcon_Azurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_GRID_ICONS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridIcon,
.anims = sAnim_GridIcon_Skitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_GRID_ICONS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &sOam_GridIcon,
.anims = sAnim_GridIcon_Makuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
}
};
// Wheel icons are listed clockwise starting from 1 oclock on the roulette wheel (with pokeball upside right)
// They go Wynaut -> Azurill -> Skitty -> Makuhita, and Orange -> Green -> Purple
static const struct SpriteTemplate sSpriteTemplates_WheelIcons[NUM_ROULETTE_SLOTS] =
{
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_OrangeWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_GreenAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_PurpleSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_OrangeMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_GreenWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_PurpleAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_OrangeSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_GreenMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_PurpleWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_OrangeAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_GreenSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
},
{
.tileTag = GFXTAG_WHEEL_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_WheelIcon,
.anims = sAnim_WheelIcon_PurpleMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelIcon
}
};
static const struct OamData sOam_Credit =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(64x32),
.size = SPRITE_SIZE(64x32),
.priority = 1,
};
static const struct OamData sOam_CreditDigit =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(8x16),
.size = SPRITE_SIZE(8x16),
.priority = 1,
};
static const struct OamData sOam_Multiplier =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x16),
.size = SPRITE_SIZE(32x16),
.priority = 1,
};
static const struct OamData sOam_BallCounter =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x8),
.size = SPRITE_SIZE(16x8),
.priority = 1,
};
static const struct CompressedSpriteSheet sSpriteSheets_Interface[] =
{
{
.data = gRouletteCredit_Gfx,
.size = 0x400,
.tag = GFXTAG_CREDIT
},
{
.data = gRouletteNumbers_Gfx,
.size = 0x280,
.tag = GFXTAG_CREDIT_DIGIT
},
{
.data = gRouletteMultiplier_Gfx,
.size = 0x500,
.tag = GFXTAG_MULTIPLIER
},
{
.data = sBallCounter_Gfx,
.size = 0x140,
.tag = GFXTAG_BALL_COUNTER
},
{
.data = sCursor_Gfx,
.size = 0x200,
.tag = GFXTAG_CURSOR
},
{}
};
static const union AnimCmd sAnim_CreditDigit[] =
{
ANIMCMD_FRAME(0, 0), // 0
ANIMCMD_FRAME(2, 0), // 1
ANIMCMD_FRAME(4, 0), // 2
ANIMCMD_FRAME(6, 0), // 3
ANIMCMD_FRAME(8, 0), // 4
ANIMCMD_FRAME(10, 0), // 5
ANIMCMD_FRAME(12, 0), // 6
ANIMCMD_FRAME(14, 0), // 7
ANIMCMD_FRAME(16, 0), // 8
ANIMCMD_FRAME(18, 0), // 9
// BUG: Animation not terminated properly
// Doesn't matter in practice, the frames are set directly and not looped
#ifdef BUGFIX
ANIMCMD_END
#endif
};
static const union AnimCmd *const sAnims_CreditDigit[] =
{
sAnim_CreditDigit
};
static const union AnimCmd sAnim_Multiplier[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(8, 0),
ANIMCMD_FRAME(16, 0),
ANIMCMD_FRAME(24, 0),
ANIMCMD_FRAME(32, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAnims_Multiplier[] =
{
sAnim_Multiplier
};
static const union AnimCmd sAnim_BallCounter[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(2, 0),
ANIMCMD_FRAME(4, 0),
ANIMCMD_FRAME(6, 0),
ANIMCMD_FRAME(8, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAnims_BallCounter[] =
{
sAnim_BallCounter
};
static const struct SpriteTemplate sSpriteTemplate_Credit =
{
.tileTag = GFXTAG_CREDIT,
.paletteTag = PALTAG_INTERFACE,
.oam = &sOam_Credit,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const struct SpriteTemplate sSpriteTemplate_CreditDigit =
{
.tileTag = GFXTAG_CREDIT_DIGIT,
.paletteTag = PALTAG_INTERFACE,
.oam = &sOam_CreditDigit,
.anims = sAnims_CreditDigit,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const struct SpriteTemplate sSpriteTemplate_Multiplier =
{
.tileTag = GFXTAG_MULTIPLIER,
.paletteTag = PALTAG_INTERFACE,
.oam = &sOam_Multiplier,
.anims = sAnims_Multiplier,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
};
static const struct SpriteTemplate sSpriteTemplate_BallCounter =
{
.tileTag = GFXTAG_BALL_COUNTER,
.paletteTag = PALTAG_BALL_COUNTER,
.oam = &sOam_BallCounter,
.anims = sAnims_BallCounter,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
// NOTE: This cursor is only used to identify the winning square on the grid
static const struct SpriteTemplate sSpriteTemplate_Cursor =
{
.tileTag = GFXTAG_CURSOR,
.paletteTag = PALTAG_INTERFACE,
.oam = &sOam_GridHeader,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const struct OamData sOam_Ball =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x16),
.size = SPRITE_SIZE(16x16),
.priority = 2,
};
static const struct CompressedSpriteSheet sSpriteSheet_Ball = {
.data = sBall_Gfx,
.size = 0x200,
.tag = GFXTAG_BALL
};
static const union AnimCmd sAnim_Ball_RollFast[] =
{
ANIMCMD_FRAME(0, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Ball_RollMedium[] =
{
ANIMCMD_FRAME(0, 10),
ANIMCMD_FRAME(4, 10),
ANIMCMD_FRAME(8, 10),
ANIMCMD_FRAME(4, 10),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Ball_RollSlow[] =
{
ANIMCMD_FRAME(0, 15),
ANIMCMD_FRAME(4, 15),
ANIMCMD_FRAME(8, 15),
ANIMCMD_FRAME(4, 15),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Ball_StopOnFrame1[] =
{
ANIMCMD_FRAME(4, 2),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(12, 5),
ANIMCMD_END
};
static const union AnimCmd sAnim_Ball_StopOnFrame3[] =
{
ANIMCMD_FRAME(4, 2),
ANIMCMD_FRAME(0, 4),
ANIMCMD_FRAME(4, 4),
ANIMCMD_FRAME(8, 4),
ANIMCMD_FRAME(12, 4),
ANIMCMD_END
};
static const union AnimCmd sAnim_Ball_StopOnFrame4[] =
{
ANIMCMD_FRAME(0, 2),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(12, 5),
ANIMCMD_END
};
static const union AnimCmd sAnim_Ball_Still[] =
{
ANIMCMD_FRAME(12, 0),
ANIMCMD_END
};
static const union AnimCmd sAnim_Ball_StopOnFrame2[] =
{
ANIMCMD_FRAME(8, 2),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(0, 5),
ANIMCMD_FRAME(12, 5),
ANIMCMD_END
};
static const union AnimCmd *const sAnims_Ball[] =
{
sAnim_Ball_RollFast,
sAnim_Ball_RollMedium,
sAnim_Ball_RollSlow,
sAnim_Ball_StopOnFrame1,
sAnim_Ball_StopOnFrame2,
sAnim_Ball_StopOnFrame3,
sAnim_Ball_StopOnFrame4,
sAnim_Ball_StopOnFrame4,
sAnim_Ball_Still
};
static const struct SpriteTemplate sSpriteTemplate_Ball =
{
.tileTag = GFXTAG_BALL,
.paletteTag = PALTAG_BALL,
.oam = &sOam_Ball,
.anims = sAnims_Ball,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const struct OamData sOam_WheelCenter =
{
.y = 81,
.affineMode = ST_OAM_AFFINE_DOUBLE,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(64x64),
.size = SPRITE_SIZE(64x64),
.priority = 2,
};
static const struct CompressedSpriteSheet sSpriteSheet_WheelCenter =
{
.data = gRouletteCenter_Gfx,
.size = 0x800,
.tag = GFXTAG_WHEEL_CENTER
};
static const struct SpriteTemplate sSpriteTemplate_WheelCenter =
{
.tileTag = GFXTAG_WHEEL_CENTER,
.paletteTag = PALTAG_BALL,
.oam = &sOam_WheelCenter,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_WheelCenter
};
static const struct OamData sOam_Shroomish =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x32),
.size = SPRITE_SIZE(32x32),
.priority = 2,
};
static const struct OamData sOam_Taillow =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x32),
.size = SPRITE_SIZE(32x32),
.priority = 2,
};
static const struct CompressedSpriteSheet sSpriteSheet_ShroomishTaillow =
{
.data = sShroomishTaillow_Gfx,
.size = 0xE00,
.tag = GFXTAG_SHROOMISH_TAILLOW
};
static const union AnimCmd sAnim_Shroomish[] =
{
ANIMCMD_FRAME(0, 6),
ANIMCMD_FRAME(16, 6),
ANIMCMD_FRAME(32, 6),
ANIMCMD_FRAME(48, 6),
ANIMCMD_FRAME(32, 6),
ANIMCMD_FRAME(64, 6),
ANIMCMD_JUMP(2)
};
static const union AnimCmd sAnim_Taillow_WingDown_Left[] =
{
ANIMCMD_FRAME(80, 10),
ANIMCMD_END
};
static const union AnimCmd sAnim_Taillow_WingDown_Right[] =
{
ANIMCMD_FRAME(80, 10, .hFlip = TRUE),
ANIMCMD_END
};
static const union AnimCmd sAnim_Taillow_FlapSlow_Left[] =
{
ANIMCMD_FRAME(80, 20),
ANIMCMD_FRAME(96, 20),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Taillow_FlapSlow_Right[] =
{
ANIMCMD_FRAME(80, 20, .hFlip = TRUE),
ANIMCMD_FRAME(96, 20, .hFlip = TRUE),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Taillow_FlapFast_Left[] =
{
ANIMCMD_FRAME(80, 10),
ANIMCMD_FRAME(96, 10),
ANIMCMD_JUMP(0)
};
static const union AnimCmd sAnim_Taillow_FlapFast_Right[] =
{
ANIMCMD_FRAME(80, 10, .hFlip = TRUE),
ANIMCMD_FRAME(96, 10, .hFlip = TRUE),
ANIMCMD_JUMP(0)
};
static const union AnimCmd *const sAnims_Shroomish[] =
{
sAnim_Shroomish
};
static const union AnimCmd *const sAnims_Taillow[] =
{
sAnim_Taillow_WingDown_Left, // While gliding in
sAnim_Taillow_WingDown_Right,
sAnim_Taillow_FlapSlow_Left, // While carrying ball
sAnim_Taillow_FlapSlow_Right,
sAnim_Taillow_FlapFast_Left, // While flying off
sAnim_Taillow_FlapFast_Right
};
static const struct SpriteTemplate sSpriteTemplate_Shroomish =
{
.tileTag = GFXTAG_SHROOMISH_TAILLOW,
.paletteTag = PALTAG_SHROOMISH,
.oam = &sOam_Shroomish,
.anims = sAnims_Shroomish,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const struct SpriteTemplate sSpriteTemplate_Taillow =
{
.tileTag = GFXTAG_SHROOMISH_TAILLOW,
.paletteTag = PALTAG_TAILLOW,
.oam = &sOam_Taillow,
.anims = sAnims_Taillow,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_Taillow
};
static const struct OamData sOam_ShroomishBallShadow =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x16),
.size = SPRITE_SIZE(16x16),
.priority = 2,
};
static const struct OamData sOam_ShroomishShadow =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x16),
.size = SPRITE_SIZE(32x16),
.priority = 2,
};
static const struct OamData sOam_TaillowShadow =
{
.affineMode = ST_OAM_AFFINE_NORMAL,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(32x16),
.size = SPRITE_SIZE(32x16),
.priority = 2,
};
static const struct CompressedSpriteSheet sSpriteSheet_Shadow =
{
.data = sShadow_Gfx,
.size = 0x180,
.tag = GFXTAG_SHADOW
};
static const union AffineAnimCmd sAffineAnim_Unused3[] =
{
AFFINEANIMCMD_FRAME(0x80, 0x80, 0, 0),
AFFINEANIMCMD_FRAME(2, 2, 0, 60),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd sAffineAnim_TaillowShadow[] =
{
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
AFFINEANIMCMD_FRAME(-2, 0x0, 0, 15),
AFFINEANIMCMD_FRAME(-1, -2, 0, 15),
AFFINEANIMCMD_FRAME(-1, -5, 0, 24),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const sAffineAnims_Unused3[] =
{
sAffineAnim_Unused3
};
static const union AffineAnimCmd *const sAffineAnims_TaillowShadow[] =
{
sAffineAnim_TaillowShadow
};
static const union AffineAnimCmd sAffineAnim_Unused4[] =
{
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const sAffineAnims_Unused4[] =
{
sAffineAnim_Unused4
};
static const union AnimCmd sAnim_ShroomishBallShadow[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_END
};
static const union AnimCmd sAnim_UnstickMonShadow[] =
{
ANIMCMD_FRAME(4, 0),
ANIMCMD_END
};
static const union AnimCmd *const sAnims_ShroomishBallShadow[] =
{
sAnim_ShroomishBallShadow
};
static const union AnimCmd *const sAnims_UnstickMonShadow[] =
{
sAnim_UnstickMonShadow
};
static const struct SpriteTemplate sSpriteTemplate_ShroomishShadow[] =
{
// Ball's shadow as it flies up
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &sOam_ShroomishBallShadow,
.anims = sAnims_ShroomishBallShadow,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
},
// Shroomish's Shadow
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &sOam_ShroomishShadow,
.anims = sAnims_UnstickMonShadow,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_Shroomish
}
};
static const struct SpriteTemplate sSpriteTemplate_TaillowShadow =
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &sOam_TaillowShadow,
.anims = sAnims_UnstickMonShadow,
.images = NULL,
.affineAnims = sAffineAnims_TaillowShadow,
.callback = SpriteCB_Taillow
};
static void Task_ShowMinBetYesNo(u8 taskId)
{
DisplayYesNoMenuDefaultYes();
DoYesNoFuncWithChoice(taskId, &sYesNoTable_AcceptMinBet);
}
static void Task_FadeToRouletteGame(u8 taskId)
{
if (!gPaletteFade.active)
{
SetVBlankCallback(NULL);
SetMainCallback2(CB2_LoadRoulette);
DestroyTask(taskId);
}
}
static void Task_AcceptMinBet(u8 taskId)
{
ClearStdWindowAndFrame(0, TRUE);
HideCoinsWindow();
FreeAllWindowBuffers();
BeginNormalPaletteFade(PALETTES_ALL, 0, 0, 16, RGB_BLACK);
gPaletteFade.delayCounter = gPaletteFade.multipurpose2;
UpdatePaletteFade();
gTasks[taskId].func = Task_FadeToRouletteGame;
}
static void Task_DeclineMinBet(u8 taskId)
{
ClearStdWindowAndFrame(0, FALSE);
HideCoinsWindow();
ScriptContext2_Disable();
DestroyTask(taskId);
}
static void Task_NotEnoughForMinBet(u8 taskId)
{
gTasks[taskId].data[0]++;
if (JOY_NEW(A_BUTTON | B_BUTTON))
{
gSpecialVar_0x8004 = 1;
HideCoinsWindow();
ClearStdWindowAndFrame(0, TRUE);
ScriptContext2_Disable();
DestroyTask(taskId);
}
}
static void Task_PrintMinBet(u8 taskId)
{
if (JOY_NEW(A_BUTTON | B_BUTTON))
{
u32 minBet = sTableMinBets[GET_MIN_BET_ID(gSpecialVar_0x8004)];
ConvertIntToDecimalStringN(gStringVar1, minBet, STR_CONV_MODE_LEADING_ZEROS, 1);
StringExpandPlaceholders(gStringVar4, Roulette_Text_PlayMinimumWagerIsX);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, FONT_NORMAL, gStringVar4, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(0, COPYWIN_FULL);
gTasks[taskId].func = Task_ShowMinBetYesNo;
}
}
static void Task_PrintRouletteEntryMsg(u8 taskId)
{
s32 minBet;
PrintCoinsString(gTasks[taskId].tCoins);
minBet = sTableMinBets[GET_MIN_BET_ID(gSpecialVar_0x8004)];
ConvertIntToDecimalStringN(gStringVar1, minBet, STR_CONV_MODE_LEADING_ZEROS, 1);
if (gTasks[taskId].tCoins >= minBet)
{
if ((gSpecialVar_0x8004 & ROULETTE_SPECIAL_RATE) && (gSpecialVar_0x8004 & 1))
{
// Special rate for Game Corner service day (only at second table)
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, FONT_NORMAL, Roulette_Text_SpecialRateTable, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(0, COPYWIN_FULL);
gTasks[taskId].func = Task_PrintMinBet;
}
else
{
// Print minimum bet
StringExpandPlaceholders(gStringVar4, Roulette_Text_PlayMinimumWagerIsX);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, FONT_NORMAL, gStringVar4, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(0, COPYWIN_FULL);
gTasks[taskId].func = Task_ShowMinBetYesNo;
}
}
else
{
// Not enough for minimum bet
StringExpandPlaceholders(gStringVar4, Roulette_Text_NotEnoughCoins);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, FONT_NORMAL, gStringVar4, 0, 1, TEXT_SKIP_DRAW, NULL);
CopyWindowToVram(0, COPYWIN_FULL);
gTasks[taskId].func = Task_NotEnoughForMinBet;
gTasks[taskId].tCoins = 0;
gTasks[taskId].data[0] = 0;
}
}
void PlayRoulette(void)
{
u8 taskId;
ScriptContext2_Enable();
ShowCoinsWindow(GetCoins(), 1, 1);
taskId = CreateTask(Task_PrintRouletteEntryMsg, 0);
gTasks[taskId].tCoins = GetCoins();
}
static void LoadOrFreeMiscSpritePalettesAndSheets(bool8 free)
{
if (!free)
{
FreeAllSpritePalettes();
LoadSpritePalettes(sSpritePalettes);
LoadCompressedSpriteSheet(&sSpriteSheet_Ball);
LoadCompressedSpriteSheet(&sSpriteSheet_ShroomishTaillow);
LoadCompressedSpriteSheet(&sSpriteSheet_Shadow);
}
else
{
// Unused
FreeSpriteTilesByTag(GFXTAG_SHADOW);
FreeSpriteTilesByTag(GFXTAG_SHROOMISH_TAILLOW);
FreeSpriteTilesByTag(GFXTAG_BALL);
FreeAllSpritePalettes();
}
}
static u8 CreateWheelIconSprite(const struct SpriteTemplate *template, u8 r1, u16 *angle)
{
u16 temp;
u8 spriteId = CreateSprite(template, 116, 80, template->oam->y);
gSprites[spriteId].data[0] = *angle;
gSprites[spriteId].data[1] = r1;
gSprites[spriteId].coordOffsetEnabled = TRUE;
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
temp = *angle;
*angle += DEGREES_PER_SLOT;
if (*angle >= 360)
*angle = temp - (360 - DEGREES_PER_SLOT);
return spriteId;
}
static void CreateGridSprites(void)
{
u8 i, j;
u8 spriteId;
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheet_Headers.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_Headers.size;
s.tag = sSpriteSheet_Headers.tag;
LoadSpriteSheet(&s);
LZ77UnCompWram(sSpriteSheet_GridIcons.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_GridIcons.size;
s.tag = sSpriteSheet_GridIcons.tag;
LoadSpriteSheet(&s);
for (i = 0; i < NUM_BOARD_COLORS; i++)
{
u8 y = i * 24;
for (j = 0; j < NUM_BOARD_POKES; j++)
{
spriteId = sRoulette->spriteIds[(i * NUM_BOARD_POKES) + SPR_GRID_ICONS + j] = CreateSprite(&sSpriteTemplate_GridIcons[j], (j * 24) + 148, y + 92, 30);
gSprites[spriteId].animPaused = TRUE;
y += 24;
if (y >= 72)
y = 0;
}
}
for (i = 0; i < ARRAY_COUNT(sSpriteTemplates_PokeHeaders); i++)
{
spriteId = sRoulette->spriteIds[i + SPR_POKE_HEADERS] = CreateSprite(&sSpriteTemplates_PokeHeaders[i], (i * 24) + 148, 70, 30);
gSprites[spriteId].animPaused = TRUE;
}
for (i = 0; i < ARRAY_COUNT(sSpriteTemplates_ColorHeaders); i++)
{
spriteId = sRoulette->spriteIds[i + SPR_COLOR_HEADERS] = CreateSprite(&sSpriteTemplates_ColorHeaders[i], 126, (i * 24) + 92, 30);
gSprites[spriteId].animPaused = TRUE;
}
}
// Unused
static void DestroyGridSprites(void)
{
u8 i;
for (i = 0; i < NUM_ROULETTE_SLOTS; i++)
{
DestroySprite(&gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]]);
}
}
static void ShowHideGridIcons(bool8 hideAll, u8 hideSquare)
{
u8 i;
switch (hideAll)
{
case TRUE:
// Hide grid icons and headers
for (i = 0; i < NUM_GRID_SELECTIONS; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]].invisible = TRUE;
}
break;
case FALSE:
for (i = 0; i < NUM_ROULETTE_SLOTS; i++)
{
if (!(sRoulette->hitFlags & sRouletteSlots[i].flag))
gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]].invisible = FALSE;
else if (sRouletteSlots[i].gridSquare != hideSquare)
gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]].invisible = TRUE;
else
gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]].invisible = FALSE;
}
// Always show grid headers
for (; i < NUM_GRID_SELECTIONS; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_ICONS]].invisible = FALSE;
}
break;
}
}
static void CreateGridBallSprites(void)
{
u8 i;
for (i = 0; i < BALLS_PER_ROUND; i++)
{
sRoulette->spriteIds[i + SPR_GRID_BALLS] = CreateSprite(&sSpriteTemplate_Ball, 116, 20, 10);
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].data[0] = 1;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].callback = SpriteCB_GridSquare;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].oam.priority = 1;
StartSpriteAnim(&gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]], 8);
}
}
static void ShowHideGridBalls(bool8 hideAll, u8 hideBallId)
{
u8 i = 0;
if (hideAll)
{
for (; i < BALLS_PER_ROUND; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].invisible = TRUE;
}
}
else
{
for (; i < BALLS_PER_ROUND; i++)
{
if (!sRoulette->hitSquares[i] || i == hideBallId)
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].invisible = TRUE;
}
else
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].x = (sGridSelections[sRoulette->hitSquares[i]].x + 1) * 8 + 4;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALLS]].y = (sGridSelections[sRoulette->hitSquares[i]].y + 1) * 8 + 3;
}
}
}
}
static void ShowHideWinSlotCursor(u8 selectionId)
{
if (selectionId == 0)
{
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].invisible = TRUE;
}
else
{
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].invisible = FALSE;
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].x = (sGridSelections[selectionId].x + 2) * 8;
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].y = (sGridSelections[selectionId].y + 2) * 8;
}
}
static void CreateWheelIconSprites(void)
{
u8 i, j;
u16 angle;
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheet_WheelIcons.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_WheelIcons.size;
s.tag = sSpriteSheet_WheelIcons.tag;
LoadSpriteSheet(&s);
angle = 15;
for (i = 0; i < NUM_BOARD_COLORS; i++)
{
for (j = 0; j < NUM_BOARD_POKES; j++)
{
u8 spriteId;
spriteId = sRoulette->spriteIds[(i * NUM_BOARD_POKES) + SPR_WHEEL_ICONS + j] = CreateWheelIconSprite(&sSpriteTemplates_WheelIcons[i * NUM_BOARD_POKES + j], 40, &angle);
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
}
}
}
static void SpriteCB_WheelIcon(struct Sprite *sprite)
{
s16 cos;
s16 sin;
u32 matrixNum;
s16 angle = sRoulette->wheelAngle + sprite->data[0];
if (angle >= 360)
angle -= 360;
sin = Sin2(angle);
cos = Cos2(angle);
sprite->x2 = sin * sprite->data[1] >> 12;
sprite->y2 = -cos * sprite->data[1] >> 12;
matrixNum = sprite->oam.matrixNum;
sin /= 16;
gOamMatrices[matrixNum].d = cos /= 16;
gOamMatrices[matrixNum].a = cos;
gOamMatrices[matrixNum].b = sin;
gOamMatrices[matrixNum].c = -sin;
}
static void CreateInterfaceSprites(void)
{
u8 i;
for (i = 0; i < ARRAY_COUNT(sSpriteSheets_Interface) - 1; i++)
{
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheets_Interface[i].data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheets_Interface[i].size;
s.tag = sSpriteSheets_Interface[i].tag;
LoadSpriteSheet(&s);
}
sRoulette->spriteIds[SPR_CREDIT] = CreateSprite(&sSpriteTemplate_Credit, 208, 16, 4);
gSprites[sRoulette->spriteIds[SPR_CREDIT]].animPaused = TRUE;
for (i = 0; i < MAX_COIN_DIGITS; i++)
{
sRoulette->spriteIds[i + SPR_CREDIT_DIGITS] = CreateSprite(&sSpriteTemplate_CreditDigit, i * 8 + 196, 24, 0);
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].animPaused = TRUE;
}
sRoulette->spriteIds[SPR_MULTIPLIER] = CreateSprite(&sSpriteTemplate_Multiplier, 120, 68, 4);
gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]].animPaused = TRUE;
for (i = 0; i < BALLS_PER_ROUND / 2; i++)
{
// Each ball counter sprite has 2 balls
sRoulette->spriteIds[i + SPR_BALL_COUNTER] = CreateSprite(&sSpriteTemplate_BallCounter, i * 16 + 192, 36, 4);
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].animPaused = TRUE;
}
sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR] = CreateSprite(&sSpriteTemplate_Cursor, 152, 96, 9);
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].oam.priority = 1;
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].animPaused = TRUE;
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].invisible = TRUE;
}
static void SetCreditDigits(u16 num)
{
u8 i;
u16 d = 1000;
bool8 printZero = FALSE;
for (i = 0; i < MAX_COIN_DIGITS; i++)
{
u8 digit = num / d;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].invisible = TRUE;
if (digit > 0 || printZero || i == MAX_COIN_DIGITS - 1)
{
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIGITS]].anims + digit)->type;
printZero = TRUE;
}
num = num % d;
d = d / 10;
}
}
// Identical to GetMultiplier but with different data array
static u8 GetMultiplierAnimId(u8 selectionId)
{
u8 animIds[5] = {0, 1, 2, 3, 4};
if (selectionId > NUM_GRID_SELECTIONS)
selectionId = 0;
switch (sGridSelections[selectionId].baseMultiplier)
{
case NUM_BOARD_COLORS:
selectionId = GET_ROW_IDX(selectionId);
if (sRoulette->colorHits[selectionId] > 3)
return 0;
return animIds[sRoulette->colorHits[selectionId] + 1];
case NUM_BOARD_POKES:
selectionId = GET_COL_IDX(selectionId);
if (sRoulette->pokeHits[selectionId] > 2)
return 0;
return animIds[sRoulette->pokeHits[selectionId] + 2];
case NUM_ROULETTE_SLOTS:
if (sRoulette->hitFlags & sGridSelections[selectionId].flag)
return 0;
return animIds[4];
}
return 0;
}
static void SetMultiplierSprite(u8 selectionId)
{
struct Sprite *sprite = &gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]];
sprite->animCmdIndex = GetMultiplierAnimId(selectionId);
sprite->oam.tileNum = sprite->sheetTileStart + (*sprite->anims + sprite->animCmdIndex)->type;
}
static void SetBallCounterNumLeft(u8 numBalls)
{
u8 i;
u8 t = 0;
if (sRoulette->minBet == 1)
t = 2;
switch (numBalls)
{
case 6:
for (i = 0; i < BALLS_PER_ROUND / 2; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].anims)->type;
}
break;
case 5:
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].oam.tileNum =
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].anims + t + 1)->type;
break;
case 4:
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].oam.tileNum =
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_3]].anims + t + 2)->type;
break;
case 3:
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].oam.tileNum =
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].anims + t + 1)->type;
break;
case 2:
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].oam.tileNum =
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_2]].anims + t + 2)->type;
break;
case 1:
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[SPR_BALL_COUNTER_1]].anims + t + 1)->type;
break;
case 0:
default:
for (i = 0; i < BALLS_PER_ROUND / 2; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER]].anims + t + 2)->type;
}
}
}
static void SpriteCB_GridSquare(struct Sprite *sprite)
{
sprite->x2 = sRoulette->gridX;
}
static void CreateWheelCenterSprite(void)
{
u8 spriteId;
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheet_WheelCenter.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_WheelCenter.size;
s.tag = sSpriteSheet_WheelCenter.tag;
LoadSpriteSheet(&s);
// This sprite id isn't saved because it doesn't need to be referenced again
// but by virtue of creation order it's SPR_WHEEL_CENTER
spriteId = CreateSprite(&sSpriteTemplate_WheelCenter, 116, 80, 81);
gSprites[spriteId].data[0] = sRoulette->wheelAngle;
gSprites[spriteId].data[1] = 0;
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
gSprites[spriteId].coordOffsetEnabled = TRUE;
}
static void SpriteCB_WheelCenter(struct Sprite *sprite)
{
u32 matrixNum = sprite->oam.matrixNum;
struct OamMatrix *matrix = &gOamMatrices[0];
matrix[matrixNum].d = sRoulette->wheelRotation.a;
matrix[matrixNum].a = sRoulette->wheelRotation.a;
matrix[matrixNum].b = sRoulette->wheelRotation.b;
matrix[matrixNum].c = sRoulette->wheelRotation.c;
}
static void CreateWheelBallSprites(void)
{
u8 i;
for (i = 0; i < BALLS_PER_ROUND; i++)
{
sRoulette->spriteIds[i] = CreateSprite(&sSpriteTemplate_Ball, 116, 80, 57 - i);
if (sRoulette->spriteIds[i] != MAX_SPRITES)
{
gSprites[sRoulette->spriteIds[i]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i]].coordOffsetEnabled = TRUE;
}
}
}
static void HideWheelBalls(void)
{
u8 spriteId = sRoulette->spriteIds[SPR_WHEEL_BALLS];
u8 i;
for (i = 0; i < BALLS_PER_ROUND; i++)
{
u8 j;
gSprites[spriteId].invisible = TRUE;
gSprites[spriteId].callback = &SpriteCallbackDummy;
StartSpriteAnim(&gSprites[spriteId], 0);
for (j = 0; j < 8; j++)
gSprites[spriteId].data[j] = 0;
spriteId++;
}
}
// Sprite data for the roulette ball
#define sStuckOnWheelLeft data[0] // if true, ball got stuck in left half of wheel, else got stuck in right half
#define sState data[1]
#define sSlotMidpointDist data[2]
#define sBallAngle data[3]
#define sBallDistToCenter data[4]
#define sBallWheelAngle data[6]
#define LandBall() \
{ \
sRoulette->ballState = BALL_STATE_LANDED; \
sRoulette->ballRolling = FALSE; \
StartSpriteAnim(sprite, sprite->animCmdIndex + 3); \
UpdateSlotBelowBall(sprite); \
sprite->sBallDistToCenter = 30; \
UpdateBallRelativeWheelAngle(sprite); \
sprite->sBallWheelAngle = (sprite->sBallWheelAngle / DEGREES_PER_SLOT) * DEGREES_PER_SLOT + 15; \
sprite->callback = SpriteCB_BallLandInSlot; \
m4aSongNumStartOrChange(SE_BRIDGE_WALK); \
}
// "wheelAngle" and "sBallAngle" are relative to the screen (e.g. 180 degrees for either is always screen bottom)
// "sBallWheelAngle" is the ball's angle relative to the wheel
// e.g. if the ball is screen right (90), but wheel is upside down (180), sBallWheelAngle is 270 (because the ball is wheel left)
static s16 UpdateBallRelativeWheelAngle(struct Sprite *sprite)
{
if (sRoulette->wheelAngle > sprite->sBallAngle)
{
sprite->sBallWheelAngle = 360 - sRoulette->wheelAngle + sprite->sBallAngle;
if (sprite->sBallWheelAngle >= 360)
sprite->sBallWheelAngle -= 360;
}
else
{
sprite->sBallWheelAngle = sprite->sBallAngle - sRoulette->wheelAngle;
}
return sprite->sBallWheelAngle;
}
static u8 UpdateSlotBelowBall(struct Sprite *sprite)
{
sRoulette->hitSlot = UpdateBallRelativeWheelAngle(sprite) / (f32)DEGREES_PER_SLOT;
return sRoulette->hitSlot;
}
static s16 GetBallDistanceToSlotMidpoint(struct Sprite *sprite)
{
s16 angleIntoSlot = UpdateBallRelativeWheelAngle(sprite) % DEGREES_PER_SLOT;
u16 distanceToMidpoint;
if (angleIntoSlot == SLOT_MIDPOINT)
{
// Ball is at midpoint, ok to drop into slot
distanceToMidpoint = 0;
return sprite->sSlotMidpointDist = distanceToMidpoint;
}
else if (angleIntoSlot >= SLOT_MIDPOINT)
{
// Ball has passed midpoint, travel to midpoint of next slot
distanceToMidpoint = (DEGREES_PER_SLOT - 1) + SLOT_MIDPOINT - angleIntoSlot;
return sprite->sSlotMidpointDist = distanceToMidpoint;
}
else
{
// Ball hasn't reached midpoint of this slot yet
distanceToMidpoint = SLOT_MIDPOINT - angleIntoSlot;
return sprite->sSlotMidpointDist = distanceToMidpoint;
}
}
static void UpdateBallPos(struct Sprite *sprite)
{
s16 sin, cos;
sRoulette->ballAngleSpeed += sRoulette->ballAngleAccel;
sRoulette->ballAngle += sRoulette->ballAngleSpeed;
if (sRoulette->ballAngle >= 360)
sRoulette->ballAngle -= 360.0f;
else if (sRoulette->ballAngle < 0.0f)
sRoulette->ballAngle += 360.0f;
sprite->sBallAngle = sRoulette->ballAngle;
sRoulette->ballFallSpeed += sRoulette->ballFallAccel;
sRoulette->ballDistToCenter += sRoulette->ballFallSpeed;
sprite->sBallDistToCenter = sRoulette->ballDistToCenter;
sin = Sin2(sprite->sBallAngle);
cos = Cos2(sprite->sBallAngle);
sprite->x2 = sin * sprite->sBallDistToCenter >> 12;
sprite->y2 = -cos * sprite->sBallDistToCenter >> 12;
if (IsSEPlaying())
{
m4aMPlayPanpotControl(&gMPlayInfo_SE1, TRACKS_ALL, sprite->x2);
m4aMPlayPanpotControl(&gMPlayInfo_SE2, TRACKS_ALL, sprite->x2);
}
}
// Snap to the bottom of the slot and continue to spin with the wheel
static void SpriteCB_BallLandInSlot(struct Sprite *sprite)
{
s16 sin, cos;
sprite->sBallAngle = sRoulette->wheelAngle + sprite->sBallWheelAngle;
if (sprite->sBallAngle >= 360)
sprite->sBallAngle -= 360;
sin = Sin2(sprite->sBallAngle);
cos = Cos2(sprite->sBallAngle);
sprite->x2 = sin * sprite->sBallDistToCenter >> 12;
sprite->y2 = -cos * sprite->sBallDistToCenter >> 12;
sprite->y2 += gSpriteCoordOffsetY;
}
static void SpriteCB_UnstickBall_ShroomishBallFall(struct Sprite *sprite)
{
UpdateBallPos(sprite);
sprite->data[2]++;
if (sprite->sBallDistToCenter < -132 || sprite->sBallDistToCenter > 80)
sprite->invisible = TRUE;
else
sprite->invisible = FALSE;
if (sprite->data[2] >= DEGREES_PER_SLOT)
{
if (!sprite->sStuckOnWheelLeft)
{
if (sRoulette->ballDistToCenter <= sRoulette->varA0 - 2.0f)
{
LandBall()
sRoulette->ballFallAccel = sRoulette->ballFallSpeed = 0.0f;
sRoulette->ballAngleSpeed = -1.0f;
}
}
else
{
if (sRoulette->ballDistToCenter >= sRoulette->varA0 - 2.0f)
{
LandBall()
sRoulette->ballFallAccel = sRoulette->ballFallSpeed = 0.0f;
sRoulette->ballAngleSpeed = -1.0f;
}
}
}
}
static void SpriteCB_UnstickBall_Shroomish(struct Sprite *sprite)
{
f32 slotOffset, ballFallDist, ballFallSpeed;
UpdateBallPos(sprite);
switch (sprite->sBallAngle)
{
case 0:
if (sprite->sStuckOnWheelLeft != TRUE)
{
slotOffset = sprite->data[7];
ballFallDist = (slotOffset * sRouletteTables[sRoulette->tableId].randDistanceHigh + (sRouletteTables[sRoulette->tableId].randDistanceLow - 1));
ballFallSpeed = (slotOffset / sRouletteTables[sRoulette->tableId].shroomish.fallSlowdown);
}
else
{
return;
}
break;
case 180:
if (sprite->sStuckOnWheelLeft)
{
slotOffset = sprite->data[7];
ballFallDist = (slotOffset * sRouletteTables[sRoulette->tableId].randDistanceHigh + (sRouletteTables[sRoulette->tableId].randDistanceLow - 1));
ballFallSpeed = -(slotOffset / sRouletteTables[sRoulette->tableId].shroomish.fallSlowdown);
}
else
{
return;
}
break;
default:
return;
}
sRoulette->varA0 = sRoulette->ballDistToCenter;
sRoulette->ballFallSpeed = ballFallSpeed;
sRoulette->ballFallAccel = -((ballFallSpeed * 2.0f) / ballFallDist + (2.0f / (ballFallDist * ballFallDist)));
sRoulette->ballAngleSpeed = 0.0f;
sprite->animPaused = FALSE;
sprite->animNum = 0;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->callback = SpriteCB_UnstickBall_ShroomishBallFall;
sprite->data[2] = 0;
}
static void SpriteCB_UnstickBall_TaillowDrop(struct Sprite *sprite)
{
sprite->y2 = (s16)(sprite->data[2] * 0.05f * sprite->data[2]) - 45;
sprite->data[2]++;
if (sprite->data[2] >= DEGREES_PER_SLOT && sprite->y2 >= 0)
{
LandBall()
sRoulette->ballUnstuck = TRUE;
}
}
static void SpriteCB_UnstickBall_TaillowPickUp(struct Sprite *sprite)
{
if (sprite->data[2]++ < 45)
{
sprite->y2--;
if (sprite->data[2] == 45)
{
if (gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animCmdIndex == 1)
sprite->y2++;
}
}
else
{
if (sprite->data[2] < sprite->data[7])
{
if (gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animDelayCounter == 0)
{
if (gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animCmdIndex == 1)
sprite->y2++;
else
sprite->y2--;
}
}
else
{
sprite->animPaused = FALSE;
sprite->animNum = 1;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->data[2] = 0;
sprite->callback = SpriteCB_UnstickBall_TaillowDrop;
m4aSongNumStart(SE_BALL_THROW);
}
}
}
static void SpriteCB_UnstickBall_Taillow(struct Sprite *sprite)
{
UpdateBallPos(sprite);
switch (sprite->sBallAngle)
{
case 90:
if (sprite->sStuckOnWheelLeft != TRUE)
{
sprite->callback = &SpriteCB_UnstickBall_TaillowPickUp;
sprite->data[2] = 0;
}
break;
case 270:
if (sprite->sStuckOnWheelLeft)
{
sprite->callback = &SpriteCB_UnstickBall_TaillowPickUp;
sprite->data[2] = 0;
}
break;
}
}
// The below SpriteCB_UnstickBall_* callbacks handle the ball while its being cleared by Shroomish/Taillow
// For what Shroomish/Taillow do during this sequence, see SpriteCB_Shroomish / SpriteCB_Taillow
static void SpriteCB_UnstickBall(struct Sprite *sprite)
{
UpdateBallPos(sprite);
switch (sRoulette->useTaillow)
{
default:
case FALSE:
CreateShroomishSprite(sprite);
sprite->callback = SpriteCB_UnstickBall_Shroomish;
break;
case TRUE:
CreateTaillowSprite(sprite);
sprite->callback = SpriteCB_UnstickBall_Taillow;
break;
}
}
#define sStillStuck data[0]
static void SpriteCB_RollBall_TryLandAdjacent(struct Sprite *sprite)
{
UpdateBallPos(sprite);
if (sprite->data[2]-- == 16)
sRoulette->ballFallSpeed *= -1.0f;
if (sprite->data[2] == 0)
{
if (!sprite->sStillStuck)
{
// Ball can successfully fall into adjacent space
LandBall()
}
else
{
// Ball is stuck, need Shroomish/Taillow to clear ball
sprite->animPaused = TRUE;
m4aSongNumStart(SE_BALL_BOUNCE_1);
SetBallStuck(sprite);
}
}
}
static void SpriteCB_RollBall_TryLand(struct Sprite *sprite)
{
UpdateBallPos(sprite);
sprite->data[2] = 0;
UpdateSlotBelowBall(sprite);
if (!(sRouletteSlots[sRoulette->hitSlot].flag & sRoulette->hitFlags))
{
// Space is empty, land successfully
LandBall()
}
else
{
// Space has already been landed on, try to fall into adjacent space
u8 slotId;
u32 fallRight;
m4aSongNumStart(SE_BALL_BOUNCE_1);
fallRight = Random() & 1;
if (fallRight)
{
sRoulette->ballAngleSpeed = 0.0f;
sRoulette->stuckHitSlot = slotId = (sRoulette->hitSlot + 1) % NUM_ROULETTE_SLOTS;
}
else // fall left
{
f32 temp;
sRoulette->ballAngleSpeed = (temp = sRouletteTables[sRoulette->tableId].var1C) * 2.0f;
slotId = (sRoulette->hitSlot + NUM_ROULETTE_SLOTS - 1) % NUM_ROULETTE_SLOTS;
sRoulette->stuckHitSlot = sRoulette->hitSlot;
}
if (sRouletteSlots[slotId].flag & sRoulette->hitFlags)
{
// Attempted adjacent space has also been landed on
sprite->sStillStuck = TRUE;
sprite->data[2] = sRouletteTables[sRoulette->tableId].randDistanceLow;
}
else
{
sprite->sStillStuck = FALSE;
if (sRoulette->tableId)
{
sprite->data[2] = sRouletteTables[sRoulette->tableId].randDistanceHigh;
}
else
{
sprite->data[2] = sRouletteTables[sRoulette->tableId].randDistanceLow;
if (fallRight)
sRoulette->ballAngleSpeed = 0.5f;
else
sRoulette->ballAngleSpeed = -1.5f;
}
}
sRoulette->ballFallSpeed = 0.085f;
sprite->callback = SpriteCB_RollBall_TryLandAdjacent;
sprite->sState = 5;
}
}
#undef sStillStuck
static void SpriteCB_RollBall_Slow(struct Sprite *sprite)
{
UpdateBallPos(sprite);
if (sRoulette->ballAngleSpeed > 0.5f)
return;
UpdateSlotBelowBall(sprite);
if (GetBallDistanceToSlotMidpoint(sprite) == 0)
{
// Reached slot to land in
sRoulette->ballAngleAccel = 0.0f;
sRoulette->ballAngleSpeed -= (f32)(sRouletteTables[sRoulette->tableId].wheelSpeed)
/ (sRouletteTables[sRoulette->tableId].wheelDelay + 1);
sprite->sState = 4;
sprite->callback = SpriteCB_RollBall_TryLand;
}
else
{
if (sRoulette->ballAngleAccel != 0.0f)
{
if (sRoulette->ballAngleSpeed < 0.0f)
{
sRoulette->ballAngleAccel = 0.0f;
sRoulette->ballAngleSpeed = 0.0f;
sRoulette->ballFallSpeed /= 1.2;
}
}
}
}
static void SpriteCB_RollBall_Medium(struct Sprite *sprite)
{
UpdateBallPos(sprite);
if (sRoulette->ballDistToCenter > 40.0f)
return;
sRoulette->ballFallSpeed = -(4.0f / (f32)(sRoulette->ballTravelDistSlow));
sRoulette->ballAngleAccel = -(sRoulette->ballAngleSpeed / (f32)(sRoulette->ballTravelDistSlow));
sprite->animNum = 2;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->sState = 3;
sprite->callback = SpriteCB_RollBall_Slow;
}
static void SpriteCB_RollBall_Fast(struct Sprite *sprite)
{
UpdateBallPos(sprite);
if (sRoulette->ballDistToCenter > 60.0f)
return;
m4aSongNumStartOrChange(SE_ROULETTE_BALL2);
sRoulette->ballFallSpeed = -(20.0f / (f32)(sRoulette->ballTravelDistMed));
sRoulette->ballAngleAccel = ((1.0f - sRoulette->ballAngleSpeed) / (f32)(sRoulette->ballTravelDistMed));
sprite->animNum = 1;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->sState = 2;
sprite->callback = SpriteCB_RollBall_Medium;
}
static void SpriteCB_RollBall_Start(struct Sprite *sprite)
{
sprite->sState = 1;
sprite->data[2] = 0;
UpdateBallPos(sprite);
sprite->invisible = FALSE;
sprite->callback = SpriteCB_RollBall_Fast;
}
// Sprite data for Shroomish / its shadows
#define sMonSpriteId data[4]
#define sBallShadowSpriteId data[5]
#define sMonShadowSpriteId data[6]
static void CreateShroomishSprite(struct Sprite *ball)
{
u16 t;
u8 i;
s16 coords[2][2] = {
{116, 44},
{116, 112}
};
struct Roulette *roulette;
t = ball->data[7] - 2;
roulette = sRoulette; // Unnecessary, needed to match
sRoulette->spriteIds[SPR_CLEAR_MON] = CreateSprite(&sSpriteTemplate_Shroomish, 36, -12, 50);
sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1] = CreateSprite(&sSpriteTemplate_ShroomishShadow[0], coords[ball->sStuckOnWheelLeft][0], coords[ball->sStuckOnWheelLeft][1], 59);
sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_2] = CreateSprite(&sSpriteTemplate_ShroomishShadow[1], 36, 140, 51);
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_2]].oam.objMode = ST_OAM_OBJ_BLEND;
for (i = 0; i < 3; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].coordOffsetEnabled = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].animPaused = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].affineAnimPaused = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].sMonSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON];
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].sBallShadowSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1];
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].sMonShadowSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_2];
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].data[2] = t;
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].data[3] = (ball->data[7] * sRouletteTables[sRoulette->tableId].randDistanceHigh) +
(sRouletteTables[sRoulette->tableId].randDistanceLow + 0xFFFF);
}
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].coordOffsetEnabled = TRUE;
sRoulette->ball = ball;
}
static void CreateTaillowSprite(struct Sprite *ball)
{
u8 i = 0;
s16 t;
s16 coords[2][2] = {
{256, 84}, // Right approach
{-16, 84} // Left approach
};
t = ball->data[7] - 2;
sRoulette->spriteIds[SPR_CLEAR_MON] = CreateSprite(&sSpriteTemplate_Taillow, coords[ball->sStuckOnWheelLeft][0], coords[ball->sStuckOnWheelLeft][1], 50);
StartSpriteAnim(&gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]], ball->sStuckOnWheelLeft);
sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1] = CreateSprite(&sSpriteTemplate_TaillowShadow, coords[ball->sStuckOnWheelLeft][0], coords[ball->sStuckOnWheelLeft][1], 51);
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].affineAnimPaused = TRUE;
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].animPaused = TRUE;
ball->data[7] = (t * sRouletteTables[sRoulette->tableId].randDistanceHigh) + (sRouletteTables[sRoulette->tableId].taillow.baseDropDelay + 45);
for (; i < 2; i++)
{
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].sMonSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON];
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].sBallShadowSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1];
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].sMonShadowSpriteId = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1];
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].data[2] = t;
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].data[3] = ball->data[7] - 45;
}
sRoulette->ball = ball;
}
static void SetBallStuck(struct Sprite *sprite)
{
u8 slotId;
u16 angle;
u8 numCandidates = 0;
u8 maxSlotToCheck = 5;
u8 betSlotId = 0;
u8 i = 0;
u8 slotsToSkip;
u8 slotCandidates[NUM_ROULETTE_SLOTS - 2] = {}; // - 2 because we know at least 2 are already occupied
u16 rand = Random();
sRoulette->ballState = BALL_STATE_STUCK;
sRoulette->ballStuck = TRUE;
sRoulette->ballUnstuck = FALSE;
sRoulette->hitSlot = 0xFF;
sRoulette->ballAngle = sprite->sBallAngle;
sRoulette->ballFallSpeed = 0.0f;
sRoulette->ballAngleSpeed = sRouletteTables[sRoulette->tableId].var1C;
angle = (sRoulette->tableId * DEGREES_PER_SLOT + 33) + (1 - sRoulette->useTaillow) * 15;
// Determine which quadrant the ball got stuck in
// Use either Shroomish or Taillow to clear the ball depending on where it's stuck
for (i = 0; i < 4; i++)
{
if (angle < sprite->sBallAngle && sprite->sBallAngle <= angle + 90)
{
sprite->sStuckOnWheelLeft = i / 2;
sRoulette->useTaillow = i % 2;
break;
}
if (i == 3)
{
sprite->sStuckOnWheelLeft = TRUE;
sRoulette->useTaillow = TRUE;
break;
}
angle += 90;
}
if (sRoulette->useTaillow)
{
if (sprite->sStuckOnWheelLeft)
PlayCry_Normal(SPECIES_TAILLOW, -63);
else
PlayCry_Normal(SPECIES_TAILLOW, 63);
}
else
{
PlayCry_Normal(SPECIES_SHROOMISH, -63);
}
slotsToSkip = 2;
slotId = (sRoulette->stuckHitSlot + 2) % NUM_ROULETTE_SLOTS;
if (sRoulette->useTaillow == TRUE && sRoulette->tableId == 1)
maxSlotToCheck += 6; // Check all remaining slots
else
maxSlotToCheck += slotsToSkip; // Check enough slots to guarantee an empty will be found
// Identify open slots on the wheel that the stuck ball could be moved to
for (i = slotsToSkip; i < maxSlotToCheck; i++)
{
if (!(sRoulette->hitFlags & sRouletteSlots[slotId].flag))
{
slotCandidates[numCandidates++] = i;
if (betSlotId == 0 && (sRouletteSlots[slotId].flag & sGridSelections[sRoulette->betSelection[sRoulette->curBallNum]].inSelectionFlags))
betSlotId = i;
}
slotId = (slotId + 1) % NUM_ROULETTE_SLOTS;
}
// Determine which identified slot the ball should be moved to
// The below slot ids are relative to the slot the ball got stuck on
if ((sRoulette->useTaillow + 1) & sRoulette->partySpeciesFlags)
{
// If the player has the corresponding pokemon in their party (HAS_SHROOMISH or HAS_TAILLOW),
// there's a 75% chance that the ball will be moved to a spot they bet on
// assuming it was one of the slots identified as a candidate
if (betSlotId && (rand % 256) < 192)
sprite->data[7] = betSlotId;
else
sprite->data[7] = slotCandidates[rand % numCandidates];
}
else
{
sprite->data[7] = slotCandidates[rand % numCandidates];
}
sprite->callback = SpriteCB_UnstickBall;
}
static const u16 sShroomishShadowAlphas[] = {
0x907,
0x808,
0x709,
0x60A,
0x50B,
0x40C,
0x30D,
0x20E,
0x10F,
0x010,
};
static void SpriteCB_ShroomishExit(struct Sprite *sprite)
{
// Delay for screen shaking, then exit left
if (sprite->data[1]++ >= sprite->data[3])
{
sprite->x -= 2;
if (sprite->x < -16)
{
if (!sRoulette->ballUnstuck)
sRoulette->ballUnstuck = TRUE;
DestroySprite(sprite);
sRoulette->shroomishShadowTimer = 0;
sRoulette->shroomishShadowAlpha = sShroomishShadowAlphas[0];
}
}
}
// Handles both the screen shake and ball shadow effect for when Shroomish unsticks the ball
static void SpriteCB_ShroomishShakeScreen(struct Sprite *sprite)
{
int screenShakeIdx;
u16 screenShakeOffsets[][4] = {
{-1, 0, 1, 0},
{-2, 0, 2, 0},
{-3, 0, 3, 0},
};
if (sprite->data[1]++ < sprite->data[3])
{
if (sprite->data[1] & 1)
{
// Shake screen
gSpriteCoordOffsetY = screenShakeOffsets[sprite->data[2] / 2][sprite->data[7]];
screenShakeIdx = sprite->data[7] + 1;
sprite->data[7] = screenShakeIdx - ((screenShakeIdx / 4) * 4);
}
// Flicker shadow
sprite->invisible ^= 1;
}
else
{
gSpriteCoordOffsetY = 0;
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animPaused = FALSE;
DestroySprite(sprite);
}
}
static void SpriteCB_ShroomishFall(struct Sprite *sprite)
{
f32 timer;
sprite->data[1]++;
timer = sprite->data[1];
sprite->y2 = timer * 0.039f * timer;
sRoulette->shroomishShadowAlpha = sShroomishShadowAlphas[(sRoulette->shroomishShadowTimer - 1) / 2];
if (sRoulette->shroomishShadowTimer < ARRAY_COUNT(sShroomishShadowAlphas) * 2 - 1)
sRoulette->shroomishShadowTimer++;
if (sprite->data[1] > 60)
{
sprite->data[1] = 0;
sprite->callback = SpriteCB_ShroomishExit;
gSprites[sprite->sMonShadowSpriteId].callback = SpriteCB_ShroomishExit;
gSprites[sprite->sMonShadowSpriteId].data[1] = -2;
gSprites[sprite->sBallShadowSpriteId].invisible = FALSE;
gSprites[sprite->sBallShadowSpriteId].callback = SpriteCB_ShroomishShakeScreen;
m4aSongNumStart(SE_M_STRENGTH);
}
}
static void SpriteCB_Shroomish(struct Sprite *sprite)
{
if (sprite->data[7] == 0)
{
// Wait for the ball to be a specific angle (or its 180 degree opposite) specified by the table
// Once it is, reveal the shadow for Shroomish falling in
if (!sRoulette->ball->sStuckOnWheelLeft)
{
if (sRoulette->ball->sBallAngle != sRouletteTables[sRoulette->tableId].shroomish.startAngle)
return;
}
else
{
if (sRoulette->ball->sBallAngle != sRouletteTables[sRoulette->tableId].shroomish.startAngle + 180)
return;
}
sprite->invisible = FALSE;
sprite->data[7]++;
m4aSongNumStart(SE_FALL);
sRoulette->shroomishShadowTimer = 1;
sRoulette->shroomishShadowAlpha = sShroomishShadowAlphas[0];
}
else
{
sRoulette->shroomishShadowAlpha = sShroomishShadowAlphas[(sRoulette->shroomishShadowTimer - 1) / 2];
if (sRoulette->shroomishShadowTimer < 19)
sRoulette->shroomishShadowTimer++;
// Wait for the ball to be a specific angle (or its 180 degree opposite) specified by the table
// Once it is, have Shroomish begin to fall in
// On both tables this angle is 15 degrees off the "start" angle
if (!sRoulette->ball->sStuckOnWheelLeft)
{
if (sRoulette->ball->sBallAngle != sRouletteTables[sRoulette->tableId].shroomish.dropAngle)
return;
}
else
{
if (sRoulette->ball->sBallAngle != sRouletteTables[sRoulette->tableId].shroomish.dropAngle + 180)
return;
}
gSprites[sprite->sMonSpriteId].callback = SpriteCB_ShroomishFall;
gSprites[sprite->sMonSpriteId].invisible = FALSE;
sprite->callback = &SpriteCallbackDummy;
sprite->data[7] = 0;
}
}
static void SpriteCB_TaillowShadow_Flash(struct Sprite *sprite)
{
sprite->invisible ^= 1;
}
static void SpriteCB_Taillow_FlyAway(struct Sprite *sprite)
{
if (sprite->y > -16)
{
sprite->y--;
}
else
{
sprite->callback = SpriteCallbackDummy;
sprite->invisible = TRUE;
sprite->animPaused = TRUE;
m4aSongNumStop(SE_TAILLOW_WING_FLAP);
DestroySprite(sprite);
FreeOamMatrix(gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].oam.matrixNum);
DestroySprite(&gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]]);
}
}
static void SpriteCB_Taillow_PickUpBall(struct Sprite *sprite)
{
if (sprite->data[1] >= 0)
{
sprite->data[1]--;
sprite->y--;
if (sprite->data[1] == 0 && sprite->animCmdIndex == 1)
sprite->y2++;
}
else
{
if (sprite->data[3] >= 0)
{
sprite->data[3]--;
if (sprite->animDelayCounter == 0)
{
if (sprite->animCmdIndex == 1)
sprite->y2++;
else
sprite->y2--;
}
}
else
{
m4aSongNumStart(SE_FALL);
StartSpriteAnim(sprite, sRoulette->ball->sStuckOnWheelLeft + 4);
sprite->callback = SpriteCB_Taillow_FlyAway;
gSprites[sprite->sMonShadowSpriteId].affineAnimPaused = FALSE;
}
}
}
static void SpriteCB_Taillow_FlyIn(struct Sprite *sprite)
{
s8 xMoveOffsets[2] = {-1, 1};
s8 yMoveOffsets[][2] = {
{2, 0},
{2, 0},
{2, -1},
{2, -1},
{2, -1},
{2, -1},
{2, -2},
{2, -2},
};
if (sprite->data[1]-- > 7)
{
sprite->x += xMoveOffsets[sRoulette->ball->sStuckOnWheelLeft] * 2;
if (IsSEPlaying())
{
s8 pan = -((116 - sprite->x) / 2);
m4aMPlayPanpotControl(&gMPlayInfo_SE1, TRACKS_ALL, pan);
m4aMPlayPanpotControl(&gMPlayInfo_SE2, TRACKS_ALL, pan);
}
}
else
{
if (sprite->data[1] >= 0)
{
sprite->x += xMoveOffsets[sRoulette->ball->sStuckOnWheelLeft] * yMoveOffsets[7 - sprite->data[1]][0];
sprite->y += yMoveOffsets[7 - sprite->data[1]][1];
}
else
{
m4aSongNumStartOrChange(SE_TAILLOW_WING_FLAP);
if (sRoulette->ball->sStuckOnWheelLeft == 0)
PlayCry_Normal(SPECIES_TAILLOW, 63);
else
PlayCry_Normal(SPECIES_TAILLOW, -63);
StartSpriteAnim(sprite, sRoulette->ball->sStuckOnWheelLeft + 2);
sprite->data[1] = 45;
sprite->callback = SpriteCB_Taillow_PickUpBall;
}
}
}
static void SpriteCB_TaillowShadow_FlyIn(struct Sprite *sprite)
{
s8 moveDir[2] = {-1, 1};
if (sprite->data[1]-- >= 0)
{
sprite->x += moveDir[sRoulette->ball->sStuckOnWheelLeft] * 2;
gSprites[sprite->sMonShadowSpriteId].invisible ^= 1;
}
else
{
sprite->callback = SpriteCB_TaillowShadow_Flash;
}
}
static void SpriteCB_Taillow(struct Sprite *sprite)
{
if (sRoulette->ball->sStuckOnWheelLeft == FALSE)
{
if (sRoulette->ball->sBallAngle == sRouletteTables[sRoulette->tableId].taillow.rightStartAngle + 90)
{
gSprites[sprite->sMonShadowSpriteId].data[1] = 52;
gSprites[sprite->sMonSpriteId].data[1] = 52;
}
else
{
return;
}
}
else
{
if (sRoulette->ball->sBallAngle == sRouletteTables[sRoulette->tableId].taillow.leftStartAngle + 270)
{
gSprites[sprite->sMonShadowSpriteId].data[1] = 46;
gSprites[sprite->sMonSpriteId].data[1] = 46;
}
else
{
return;
}
}
gSprites[sprite->sMonShadowSpriteId].callback = SpriteCB_TaillowShadow_FlyIn;
gSprites[sprite->sMonSpriteId].callback = SpriteCB_Taillow_FlyIn;
m4aSongNumStart(SE_FALL);
}
Reference in New Issue Copy Permalink