ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2025-01-19 18:04:22 +01:00
Code Issues Packages Projects Releases Wiki Activity
pokeemerald/src/roulette.c
GriffinR 22b5b6b074 Start documenting roulette
2020-07-30 19:37:16 -04:00

4645 lines
129 KiB
C
Raw Blame History

#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 "random.h"
#include "roulette.h"
#include "roulette_util.h"
#include "rtc.h"
#include "scanline_effect.h"
#include "script.h"
#include "sound.h"
#include "sprite.h"
#include "string_util.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/species.h"
#include "constants/songs.h"
#define BALLS_PER_ROUND 6
#define NUM_BOARD_COLORS 3 // Grid rows
#define NUM_BOARD_POKES 4 // Grid columns
#define NUM_ROULETTE_SLOTS (NUM_BOARD_COLORS * NUM_BOARD_POKES)
// 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
#define GET_COL(selectionId)((selectionId) % (NUM_BOARD_POKES + 1))
#define GET_ROW(selectionId)((selectionId) / (NUM_BOARD_POKES + 1) * (NUM_BOARD_POKES + 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)
#define MAX_MULTIPLIER 12
#define PALTAG_SHADOW 1
#define PALTAG_BALL 2
#define PALTAG_BALL_COUNTER 3
#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_BOARD_ICONS 0
#define GFXTAG_HEADERS 4
#define GFXTAG_GRID_ICONS 5
#define GFXTAG_BOARD_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_TABLE_ID(var)(((var) & 1) + (((var) >> 7) * 2))
#define HAS_SHROOMISH (1 << 0)
#define HAS_TAILLOW (1 << 1)
enum {
SPR_BALL_1,
SPR_BALL_2,
SPR_BALL_3,
SPR_BALL_4,
SPR_BALL_5,
SPR_BALL_6,
SPR_6,
SPR_BOARD_ICON_ORANGE_WYNAUT,
SPR_BOARD_ICON_GREEN_AZURILL,
SPR_BOARD_ICON_PURPLE_SKITTY,
SPR_BOARD_ICON_ORANGE_MAKUHITA,
SPR_BOARD_ICON_GREEN_WYNAUT,
SPR_BOARD_ICON_PURPLE_AZURILL,
SPR_BOARD_ICON_ORANGE_SKITTY,
SPR_BOARD_ICON_GREEN_MAKUHITA,
SPR_BOARD_ICON_PURPLE_WYNAUT,
SPR_BOARD_ICON_ORANGE_AZURILL,
SPR_BOARD_ICON_GREEN_SKITTY,
SPR_BOARD_ICON_PURPLE_MAKUHITA,
SPR_19,
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_2,
SPR_GRID_ICON_3,
SPR_GRID_ICON_4,
SPR_GRID_ICON_5,
SPR_GRID_ICON_6,
SPR_GRID_ICON_7,
SPR_GRID_ICON_8,
SPR_GRID_ICON_9,
SPR_GRID_ICON_10,
SPR_GRID_ICON_11,
SPR_GRID_ICON_12,
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,
SPR_59,
SPR_60,
SPR_61,
SPR_62,
SPR_63,
};
// Start points for sprite IDs that are looped over
#define SPR_BOARD_ICONS SPR_BOARD_ICON_ORANGE_WYNAUT
#define SPR_GRID_ICONS SPR_GRID_ICON_ORANGE_WYNAUT
struct StructgUnknown_083F8DF4
{
u8 var00;
u8 var01;
u8 var02;
u8 var03;
u8 var04;
u8 filler_05[3];
u16 var08;
u16 var0A;
u16 var0C;
u8 filler_0E[2];
u16 var10;
u16 var12;
u16 var14;
u8 filler_16[2];
u16 var18;
u16 var1A;
float var1C;
};
struct GridSelection
{
u8 var00;
u8 baseMultiplier:4;
u8 column:4; // Never read
u8 row; // Never read
u8 x;
u8 y;
u8 var05; // Never read
u8 var06;
u32 flag;
u32 inSelectionFlags;
u16 var10;
};
struct RouletteSlot
{
u8 id1; // Never read
u8 id2; // Never read
u8 gridSquare;
u32 flag;
};
static EWRAM_DATA struct Roulette
{
u8 var00;
u8 var01;
u8 partySpeciesFlags;
bool8 useTaillow:5;
bool8 var03_5:1;
bool8 var03_6:1;
bool8 var03_7:1;
u8 tableId:2;
u8 var04_2: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
u8 unk: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 var21;
u8 var22;
u8 var23;
s16 var24;
s16 var26;
s16 var28;
s16 var2A;
struct OamMatrix var2C;
u16 var34;
struct Sprite *var38;
u8 spriteIds[MAX_SPRITES]; // Sprite IDs
u8 var7C;
u8 var7D;
u8 var7E;
u8 var7F;
s16 var80;
s16 var82;
u16 var84;
u16 var86;
float var88;
float var8C;
float var90;
float var94;
float var98;
float var9C;
float varA0;
u8 varA4;
u8 varA5;
u8 v51[2];
u16 taskWaitDelay;
u16 taskWaitKey;
TaskFunc nextTask;
u8 v46[4];
TaskFunc varB4;
struct UnkStruct0 varB8;
u16 tilemapBuffers[7][0x400];
u16 *unk_397C;
} *sRoulette = NULL;
static EWRAM_DATA u8 sTextWindowId = 0;
static void Task_SpinBoard(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_RollBall(u8);
static void Task_EndBallRoll(u8);
static void Task_RecordBallHit(u8);
static void Task_SlideGridOnscreen(u8);
static void sub_8141778(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 sub_8141FF4(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 sub_8142814(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 CreateBoardIconSprites(void);
static void SpriteCB_BoardIcon(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 CreateBoardCenterSprite(void);
static void SpriteCB_BoardCenter(struct Sprite *);
static void CreateBoardBallSprites(void);
static void HideBoardBalls(void);
static void sub_81446AC(struct Sprite *);
static void CreateShroomishSprite(struct Sprite *);
static void CreateTaillowSprite(struct Sprite *);
static void sub_8144A24(struct Sprite *);
static void sub_8144E60(struct Sprite *);
static void SpriteCB_Taillow(struct Sprite *);
extern const u8 Roulette_Text_ControlsInstruction[];
extern const u8 Roulette_Text_KeepPlaying[];
extern const u8 Roulette_Text_Jackpot[];
extern const u8 Roulette_Text_ItsAHit[];
extern const u8 Roulette_Text_NothingDoing[];
extern const u8 Roulette_Text_YouveWonXCoins[];
extern const u8 Roulette_Text_BoardWillBeCleared[];
extern const u8 Roulette_Text_CoinCaseIsFull[];
extern const u8 Roulette_Text_NoCoinsLeft[];
extern const u8 Roulette_Text_PlayMinimumWagerIsX[];
extern const u8 Roulette_Text_SpecialRateTable[];
extern const u8 Roulette_Text_NotEnoughCoins[];
static const u16 gUnknown_085B5BFC[] = INCBIN_U16("graphics/roulette/85B5BFC.gbapal");
static const u32 gUnknown_085B5DFC[] = INCBIN_U32("graphics/roulette/85B5DFC.bin.lz");
static const u32 sWheel_Tilemap[] = INCBIN_U32("graphics/roulette/wheel_map.bin.lz");
static const struct BgTemplate sBgTemplates[] =
{
{
.bg = 0,
.charBaseIndex = 2,
.mapBaseIndex = 31,
.screenSize = 0,
.paletteMode = 0,
.priority = 0,
.baseTile = 0
},
{
.bg = 1,
.charBaseIndex = 0,
.mapBaseIndex = 4,
.screenSize = 1,
.paletteMode = 0,
.priority = 1,
.baseTile = 0
},
{
.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
},
// BUG: Array not terminated properly
//DUMMY_WIN_TEMPLATE
};
// var00, sprite id offset (from 7)?
static const struct GridSelection sGridSelections[NUM_GRID_SELECTIONS + 1] =
{
[SELECTION_NONE] = {
.var00 = 0xFF,
.baseMultiplier = 0,
.column = 0,
.row = 0,
.x = 7,
.y = 7,
.var05 = 0,
.var06 = 0,
.flag = 0,
.inSelectionFlags = 0,
.var10 = 0x0,
},
[COL_WYNAUT] = {
.var00 = 12,
.baseMultiplier = NUM_BOARD_POKES,
.column = 1,
.row = 0,
.x = 17,
.y = 7,
.var05 = 0,
.var06 = 0,
.flag = F_WYNAUT_COL,
.inSelectionFlags = F_WYNAUT_COL | F_ORANGE_WYNAUT | F_GREEN_WYNAUT | F_PURPLE_WYNAUT,
.var10 = 0xE000,
},
[COL_AZURILL] = {
.var00 = 13,
.baseMultiplier = NUM_BOARD_POKES,
.column = 2,
.row = 0,
.x = 20,
.y = 7,
.var05 = 0,
.var06 = 0,
.flag = F_AZURILL_COL,
.inSelectionFlags = F_AZURILL_COL | F_ORANGE_AZURILL | F_GREEN_AZURILL | F_PURPLE_AZURILL,
.var10 = 0xE000,
},
[COL_SKITTY] = {
.var00 = 14,
.baseMultiplier = NUM_BOARD_POKES,
.column = 3,
.row = 0,
.x = 23,
.y = 7,
.var05 = 0,
.var06 = 0,
.flag = F_SKITTY_COL,
.inSelectionFlags = F_SKITTY_COL | F_ORANGE_SKITTY | F_GREEN_SKITTY | F_PURPLE_SKITTY,
.var10 = 0xE000,
},
[COL_MAKUHITA] = {
.var00 = 15,
.baseMultiplier = NUM_BOARD_POKES,
.column = 4,
.row = 0,
.x = 26,
.y = 7,
.var05 = 0,
.var06 = 0,
.flag = F_MAKUHITA_COL,
.inSelectionFlags = F_MAKUHITA_COL | F_ORANGE_MAKUHITA | F_GREEN_MAKUHITA | F_PURPLE_MAKUHITA,
.var10 = 0xE000,
},
[ROW_ORANGE] = {
.var00 = 16,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 1,
.x = 14,
.y = 10,
.var05 = 0,
.var06 = 12,
.flag = F_ORANGE_ROW,
.inSelectionFlags = F_ORANGE_ROW | F_ORANGE_WYNAUT | F_ORANGE_AZURILL | F_ORANGE_SKITTY | F_ORANGE_MAKUHITA,
.var10 = 0x249,
},
[SQU_ORANGE_WYNAUT] = {
.var00 = 0,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 1,
.x = 17,
.y = 10,
.var05 = 3,
.var06 = 3,
.flag = F_ORANGE_WYNAUT,
.inSelectionFlags = F_ORANGE_WYNAUT,
.var10 = 0x2001,
},
[SQU_ORANGE_AZURILL] = {
.var00 = 9,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 1,
.x = 20,
.y = 10,
.var05 = 3,
.var06 = 3,
.flag = F_ORANGE_AZURILL,
.inSelectionFlags = F_ORANGE_AZURILL,
.var10 = 0x2200,
},
[SQU_ORANGE_SKITTY] = {
.var00 = 6,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 1,
.x = 23,
.y = 10,
.var05 = 3,
.var06 = 3,
.flag = F_ORANGE_SKITTY,
.inSelectionFlags = F_ORANGE_SKITTY,
.var10 = 0x2040,
},
[SQU_ORANGE_MAKUHITA] = {
.var00 = 3,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 1,
.x = 26,
.y = 10,
.var05 = 3,
.var06 = 3,
.flag = F_ORANGE_MAKUHITA,
.inSelectionFlags = F_ORANGE_MAKUHITA,
.var10 = 0x2008,
},
[ROW_GREEN] = {
.var00 = 17,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 2,
.x = 14,
.y = 13,
.var05 = 3,
.var06 = 15,
.flag = F_GREEN_ROW,
.inSelectionFlags = F_GREEN_ROW | F_GREEN_WYNAUT | F_GREEN_AZURILL | F_GREEN_SKITTY | F_GREEN_MAKUHITA,
.var10 = 0x492,
},
[SQU_GREEN_WYNAUT] = {
.var00 = 4,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 2,
.x = 17,
.y = 13,
.var05 = 6,
.var06 = 6,
.flag = F_GREEN_WYNAUT,
.inSelectionFlags = F_GREEN_WYNAUT,
.var10 = 0x2010,
},
[SQU_GREEN_AZURILL] = {
.var00 = 1,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 2,
.x = 20,
.y = 13,
.var05 = 6,
.var06 = 6,
.flag = F_GREEN_AZURILL,
.inSelectionFlags = F_GREEN_AZURILL,
.var10 = 0x2002,
},
[SQU_GREEN_SKITTY] = {
.var00 = 10,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 2,
.x = 23,
.y = 13,
.var05 = 6,
.var06 = 6,
.flag = F_GREEN_SKITTY,
.inSelectionFlags = F_GREEN_SKITTY,
.var10 = 0x2400,
},
[SQU_GREEN_MAKUHITA] = {
.var00 = 7,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 2,
.x = 26,
.y = 13,
.var05 = 6,
.var06 = 6,
.flag = F_GREEN_MAKUHITA,
.inSelectionFlags = F_GREEN_MAKUHITA,
.var10 = 0x2080,
},
[ROW_PURPLE] = {
.var00 = 18,
.baseMultiplier = NUM_BOARD_COLORS,
.column = 0,
.row = 3,
.x = 14,
.y = 16,
.var05 = 6,
.var06 = 18,
.flag = F_PURPLE_ROW,
.inSelectionFlags = F_PURPLE_ROW | F_PURPLE_WYNAUT | F_PURPLE_AZURILL | F_PURPLE_SKITTY | F_PURPLE_MAKUHITA,
.var10 = 0x924,
},
[SQU_PURPLE_WYNAUT] = {
.var00 = 8,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 1,
.row = 3,
.x = 17,
.y = 16,
.var05 = 9,
.var06 = 9,
.flag = F_PURPLE_WYNAUT,
.inSelectionFlags = F_PURPLE_WYNAUT,
.var10 = 0x2100,
},
[SQU_PURPLE_AZURILL] = {
.var00 = 5,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 2,
.row = 3,
.x = 20,
.y = 16,
.var05 = 9,
.var06 = 9,
.flag = F_PURPLE_AZURILL,
.inSelectionFlags = F_PURPLE_AZURILL,
.var10 = 0x2020,
},
[SQU_PURPLE_SKITTY] = {
.var00 = 2,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 3,
.row = 3,
.x = 23,
.y = 16,
.var05 = 9,
.var06 = 9,
.flag = F_PURPLE_SKITTY,
.inSelectionFlags = F_PURPLE_SKITTY,
.var10 = 0x2004,
},
[SQU_PURPLE_MAKUHITA] = {
.var00 = 11,
.baseMultiplier = NUM_ROULETTE_SLOTS,
.column = 4,
.row = 3,
.x = 26,
.y = 16,
.var05 = 9,
.var06 = 9,
.flag = F_PURPLE_MAKUHITA,
.inSelectionFlags = F_PURPLE_MAKUHITA,
.var10 = 0x2800,
},
};
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 StructgUnknown_083F8DF4 gUnknown_085B6348[] =
{
{
.var00 = 1,
.var01 = 60,
.var02 = 30,
.var03 = 1,
.var04 = 1,
.var08 = 45,
.var0A = 30,
.var0C = 1,
.var10 = 75,
.var12 = 27,
.var14 = 24,
.var18 = 10,
.var1A = 360,
.var1C = -0.5f
},
{
.var00 = 3,
.var01 = 30,
.var02 = 15,
.var03 = 1,
.var04 = 0,
.var08 = 75,
.var0A = 60,
.var0C = 2,
.var10 = 0,
.var12 = 54,
.var14 = 48,
.var18 = 10,
.var1A = 270,
.var1C = -1.0f
}
};
static const struct UnkStruct1 gUnknown_085B6388[] =
{
{
.var00 = 0x8000,
.var02 = 0x0005,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x000A,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0015,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0055,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x005A,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0065,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0075,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x007A,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0085,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x0095,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x009A,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x8000,
.var02 = 0x00A5,
.var04 = 1,
.var05 = 1,
.var06 = 0xFF,
.var07_0 = 8,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x77D6,
.var02 = 0x0028,
.var04 = 2,
.var05 = 10,
.var06 = 0xFF,
.var07_0 = 14,
.var07_5 = -2,
.var07_7 = 0
},
};
static const struct UnkStruct1 gUnknown_085B63F0[] =
{
{
.var00 = 0x53FF,
.var02 = 0x0101,
.var04 = 5,
.var05 = 30,
.var06 = 0xFF,
.var07_0 = 14,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x7FFB,
.var02 = 0x0106,
.var04 = 5,
.var05 = 30,
.var06 = 0xFF,
.var07_0 = 14,
.var07_5 = -2,
.var07_7 = 0
},
{
.var00 = 0x7F7F,
.var02 = 0x010B,
.var04 = 5,
.var05 = 30,
.var06 = 0xFF,
.var07_0 = 14,
.var07_5 = -2,
.var07_7 = 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->varB8.var00)
task_tutorial_controls_fadein(&sRoulette->varB8);
}
static void VBlankCB_Roulette(void)
{
LoadOam();
ProcessSpriteCopyRequests();
TransferPlttBuffer();
sub_8142814();
SetGpuReg(REG_OFFSET_BG1HOFS, 0x200 - sRoulette->var26);
if (sRoulette->var01)
SetGpuReg(REG_OFFSET_BLDALPHA, sRoulette->var34);
if (sRoulette->var2A != 0)
{
DmaCopy16(3, &sRoulette->tilemapBuffers[2][0xE0], (void *)BG_SCREEN_ADDR(4) + 0x1C0, 0x340);
sRoulette->var2A = 0;
}
switch (sRoulette->var28)
{
case 1:
SetBgAttribute(0, BG_ATTR_CHARBASEINDEX, 0);
ShowBg(0);
DmaCopy16(3, &sRoulette->tilemapBuffers[0][0xE0], (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
sRoulette->var28 = 2;
break;
case 2:
DmaCopy16(3, &sRoulette->tilemapBuffers[0][0xE0], (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
break;
case 0xFF:
SetBgAttribute(0, BG_ATTR_CHARBASEINDEX, 2);
ShowBg(0);
DmaFill16(3, 0, (void *)BG_SCREEN_ADDR(31) + 0x1C0, 0x340);
sRoulette->var28 = 0;
case 0:
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->unk_397C = malloc_and_decompress(gUnknown_085B5DFC, &size);
}
static void FreeRoulette(void)
{
FREE_AND_SET_NULL(sRoulette->unk_397C);
FreeAllWindowBuffers();
UnsetBgTilemapBuffer(0);
UnsetBgTilemapBuffer(1);
UnsetBgTilemapBuffer(2);
ResetBgsAndClearDma3BusyFlags(0);
memset(sRoulette, 0, sizeof(*sRoulette));
FREE_AND_SET_NULL(sRoulette);
}
static void sub_8140470(void)
{
u8 i;
u16 arr[3] = {RGB(24, 4, 10), RGB(10, 19, 6), RGB(24, 4, 10)}; // the third is never used ?
sRoulette->tableId = (gSpecialVar_0x8004 & 1);
if (gSpecialVar_0x8004 & ROULETTE_SPECIAL_RATE)
sRoulette->isSpecialRate = TRUE;
sRoulette->var22 = gUnknown_085B6348[sRoulette->tableId].var03;
sRoulette->var23 = gUnknown_085B6348[sRoulette->tableId].var04;
sRoulette->minBet = sTableMinBets[sRoulette->tableId + sRoulette->isSpecialRate * 2];
sRoulette->unk = 1;
if (sRoulette->minBet == 1)
gPlttBufferUnfaded[0] = gPlttBufferUnfaded[0x51] = gPlttBufferFaded[0] = gPlttBufferFaded[0x51] = arr[0];
else
gPlttBufferUnfaded[0] = gPlttBufferUnfaded[0x51] = gPlttBufferFaded[0] = gPlttBufferFaded[0x51] = arr[1];
sub_8151678(&sRoulette->varB8);
for (i = 0; i < 13; i++)
{
sub_815168C(&sRoulette->varB8, i, &gUnknown_085B6388[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 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(&gUnknown_085B5BFC, 0, 0x1C0);
DecompressAndCopyTileDataToVram(1, gRouletteMenu_Gfx, 0, 0, 0);
DecompressAndCopyTileDataToVram(2, gRouletteWheel_Gfx, 0, 0, 0);
break;
case 4:
if (FreeTempTileDataBuffersIfPossible())
return;
sub_8140470();
CopyToBgTilemapBuffer(2, sWheel_Tilemap, 0, 0);
break;
case 5:
LoadOrFreeMiscSpritePalettesAndSheets(FALSE);
CreateBoardBallSprites();
CreateBoardCenterSprite();
CreateInterfaceSprites();
CreateGridSprites();
CreateGridBallSprites();
CreateBoardIconSprites();
break;
case 6:
AnimateSprites();
BuildOamBuffer();
SetCreditDigits(GetCoins());
SetBallCounterNumLeft(BALLS_PER_ROUND);
SetMultiplierSprite(SELECTION_NONE);
DrawGridBackground(SELECTION_NONE);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_ControlsInstruction, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
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->varA4 = CreateTask(Task_StartPlaying, 0);
gTasks[taskId].tBallNum = BALLS_PER_ROUND;
gTasks[taskId].tCoins = GetCoins();
AlertTVThatPlayerPlayedRoulette(GetCoins());
sRoulette->varA5 = CreateTask(Task_SpinBoard, 1);
SetMainCallback2(CB2_Roulette);
return;
}
gMain.state++;
}
static void Task_SpinBoard(u8 taskId)
{
s16 sin;
s16 cos;
if (sRoulette->var21++ == sRoulette->var23)
{
sRoulette->var21 = 0;
if ((sRoulette->var24 -= sRoulette->var22) < 0)
sRoulette->var24 = 360 - sRoulette->var22;
}
sin = Sin2(sRoulette->var24);
cos = Cos2(sRoulette->var24);
sin = sin / 16;
sRoulette->var2C.a = sRoulette->var2C.d = cos / 16;
sRoulette->var2C.b = sin;
sRoulette->var2C.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;
sub_8141FF4(taskId);
ResetHits();
HideBoardBalls();
DrawGridBackground(SELECTION_NONE);
SetBallCounterNumLeft(BALLS_PER_ROUND);
StartTaskAfterDelayOrInput(taskId, Task_ContinuePlaying, 0xFFFF, A_BUTTON | B_BUTTON);
}
}
static void Task_AskKeepPlaying(u8 taskId)
{
DisplayYesNoMenuDefaultYes();
DrawStdWindowFrame(sTextWindowId, 0);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_KeepPlaying, 0, 1, TEXT_SPEED_FF, 0);
CopyWindowToVram(sTextWindowId, 3);
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->varA5);
ExitRoulette(taskId);
}
static void UpdateGridSelectionRect(u8 selectionId)
{
u8 temp0, temp1;
switch (selectionId)
{
case SELECTION_NONE:
ClearGridSelectionRect(&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);
ClearGridSelectionRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetGridSelectionRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->unk_397C[281], temp0, 7, 3, 13);
break;
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
temp1 = ((selectionId - 1) / 5 * 3 + 10);
ClearGridSelectionRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetGridSelectionRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->unk_397C[320], 14, temp1, 16, 3);
break;
// Individual square
default:
temp0 = GET_COL(selectionId) * 3 + 14;
temp1 = ((selectionId - 1) / 5 * 3 + 7);
ClearGridSelectionRect(&sRoulette->tilemapBuffers[0][0], 0, 14, 7, 16, 13);
SetGridSelectionRect(&sRoulette->tilemapBuffers[0][0], &sRoulette->unk_397C[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->var28 = 1;
UpdateGridSelectionRect(gTasks[taskId].tSelectionId);
sRoulette->var23 = 2;
sRoulette->var21 = 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;
sub_8141FF4(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 z = 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] = z;
PlaySE(SE_SELECT);
sub_8151A9C(&sRoulette->varB8, 0xFFFF);
sRoulette->varB8.var04[13].var00_7 = sRoulette->varB8.var04[14].var00_7 = sRoulette->varB8.var04[15].var00_7 = 0;
FlashSelectionOnWheel(gTasks[taskId].tSelectionId);
for (i = 0; i < NUM_BOARD_POKES; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADER_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADER_1]].anims)->type;
}
if ((u16)(gTasks[taskId].tSelectionId - 1) < 4 && !(sRoulette->hitFlags & sGridSelections[gTasks[taskId].tSelectionId].flag) )
{
z = gTasks[taskId].tSelectionId - 1;
gSprites[sRoulette->spriteIds[z + SPR_POKE_HEADER_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[z + SPR_POKE_HEADER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[z + SPR_POKE_HEADER_1]].anims + 1)->type;
}
}
}
static void sub_8140F6C(u8 r0)
{
IncrementDailyRouletteUses();
sRoulette->var28 = 0xFF;
if (sRoulette->minBet == 1)
sRoulette->var23 = 1;
else
sRoulette->var23 = 0;
sRoulette->var21 = 0;
gTasks[r0].data[1] = 32;
gTasks[r0].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 = sub_8140F6C;
}
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_REGI);
gTasks[taskId].func = Task_PlaceBet;
}
}
}
static void Task_SlideGridOffscreen(u8 taskId)
{
if (gTasks[taskId].data[1]-- > 0)
{
if (gTasks[taskId].data[1] > 2)
gSpriteCoordOffsetX += 2;
if ((sRoulette->var26 += 4) == 104)
gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]].callback = &SpriteCallbackDummy;
}
else
{
ShowHideGridIcons(TRUE, -1);
ShowHideGridBalls(TRUE, -1);
gTasks[taskId].func = Task_RollBall;
gTasks[taskId].data[1] = 0;
}
}
static u8 sub_814118C(u16 r0, u16 r1)
{
switch (sRoulette->partySpeciesFlags)
{
case HAS_SHROOMISH:
case HAS_TAILLOW:
// one of the two is in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 10)
{
if (r0 < 12 || (r1 & 1))
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
else
return 1;
}
else if (!(r1 & 0x3))
{
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
}
else
{
return gUnknown_085B6348[sRoulette->tableId].var02;
}
break;
case HAS_SHROOMISH | HAS_TAILLOW:
// both are in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 11)
{
if (r0 < 6 || (r1 & 1))
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
else
return 1;
}
else if ((r1 & 1) && r0 > 6)
{
return gUnknown_085B6348[sRoulette->tableId].var02 / 4;
}
else
{
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
}
break;
case 0:
default:
// neither is in party
if (gLocalTime.hours > 3 && gLocalTime.hours < 10)
{
if (!(r1 & 3))
return 1;
else
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
}
else if (!(r1 & 3))
{
if (r0 > 12)
return gUnknown_085B6348[sRoulette->tableId].var02 / 2;
else
return gUnknown_085B6348[sRoulette->tableId].var02;
}
else if (r1 & 0x8000)
{
if (r0 > 12)
return gUnknown_085B6348[sRoulette->tableId].var02;
else
return gUnknown_085B6348[sRoulette->tableId].var01;
}
else
{
return gUnknown_085B6348[sRoulette->tableId].var01 * 2;
}
break;
}
}
static void Task_RollBall(u8 taskId)
{
u8 randf;
s8 randfinal;
s8 r5;
u16 g = 0;
u16 rand;
u16 randmod;
u16 angles[4] = {0, 180, 90, 270}; // angles in 90 degree steps
rand = Random();
randmod = rand % 100;
sRoulette->var7C = gTasks[taskId].tBallNum;
sRoulette->var7D = sRoulette->var7E = sRoulette->var7F = g;
randf = sub_814118C(gTasks[taskId].data[8], rand);
randfinal = (rand % randf) - (randf / 2);
if (gLocalTime.hours < 13)
r5 = 0;
else
r5 = 1;
if (randmod < 80)
r5 *= 2;
else
r5 = (1 - r5) * 2;
sRoulette->var80 = g = gUnknown_085B6348[sRoulette->tableId].var1A + randfinal;
g = S16TOPOSFLOAT(g) / 5.0f;
sRoulette->var82 = g * 3;
sRoulette->var86 = sRoulette->var84 = g;
sRoulette->var88 = S16TOPOSFLOAT(angles[(rand & 1) + r5]);
sRoulette->var8C = S16TOPOSFLOAT(gUnknown_085B6348[sRoulette->tableId].var18);
sRoulette->var90 = ((sRoulette->var8C * 0.5f) - sRoulette->var8C) / S16TOPOSFLOAT(sRoulette->var82);
sRoulette->var94 = 68.0f;
sRoulette->var9C = 0.0f;
sRoulette->var98 = -(8.0f / S16TOPOSFLOAT(sRoulette->var82));
sRoulette->varA0 = 36.0f;
gTasks[taskId].func = Task_EndBallRoll;
}
static void Task_EndBallRoll(u8 taskId)
{
u8 index;
sRoulette->var03_7 = TRUE;
index = sRoulette->spriteIds[sRoulette->var7C];
sRoulette->var38 = &gSprites[index];
sRoulette->var38->callback = sub_81446AC;
gTasks[taskId].tBallNum++;
gTasks[taskId].data[8]++;
SetBallCounterNumLeft(BALLS_PER_ROUND - gTasks[taskId].tBallNum);
m4aSongNumStart(SE_TAMAKORO);
gTasks[taskId].func = Task_RecordBallHit;
}
static void Task_RecordBallHit(u8 taskId)
{
if (sRoulette->var7D)
{
if (sRoulette->var03_5)
{
if (sRoulette->var03_6)
{
sRoulette->var03_6 = FALSE;
sRoulette->var03_5 = FALSE;
}
}
else
{
if (!gTasks[taskId].data[1])
{
bool8 temp = IsHitInBetSelection(RecordHit(taskId, sRoulette->var7E), sRoulette->betSelection[sRoulette->curBallNum]);
gTasks[taskId].tWonBet = temp;
if (temp == TRUE)
sub_8151A48(&sRoulette->varB8, 0x1000);
}
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)
{
if (gTasks[taskId].data[1] > 2)
gSpriteCoordOffsetX -= 2;
if ((sRoulette->var26 -= 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 = sub_8141778;
}
}
static void sub_8141778(u8 taskId)
{
if (gTasks[taskId].data[1]-- > 1)
{
switch (gTasks[taskId].data[1] % 16)
{
case 8:
ShowHideGridIcons(FALSE, -1);
ShowHideGridBalls(FALSE, -1);
break;
case 0:
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, 0xFFFF, A_BUTTON | B_BUTTON);
}
break;
case FALSE:
default:
if (!IsSEPlaying())
{
gTasks[taskId].tConsecutiveWins = 0;
StartTaskAfterDelayOrInput(taskId, Task_EndTurn, 0xFFFF, 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_ME_B_BIG);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_Jackpot, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
}
else
{
PlayFanfare(MUS_ME_B_SMALL);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_ItsAHit, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
}
break;
case FALSE:
default:
m4aSongNumStart(SE_HAZURE);
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_NothingDoing, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
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, 0xFFFF, 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, 1, gStringVar4, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
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)
{
sub_8151A9C(&sRoulette->varB8, 0xFFFF);
sRoulette->varB8.var04[13].var00_7 = sRoulette->varB8.var04[14].var00_7 = sRoulette->varB8.var04[15].var00_7 = 0;
gSprites[sRoulette->spriteIds[SPR_BOARD_ICONS + sGridSelections[gTasks[taskId].tWinningSquare].var00]].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_HEADER_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_POKE_HEADER_1]].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, 1, Roulette_Text_BoardWillBeCleared, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
StartTaskAfterDelayOrInput(taskId, Task_ClearBoard, 0xFFFF, A_BUTTON | B_BUTTON);
}
else if (gTasks[taskId].tCoins == MAX_COINS)
{
// Player maxed out coins
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_CoinCaseIsFull, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
StartTaskAfterDelayOrInput(taskId, Task_AskKeepPlaying, 0xFFFF, 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, 1, Roulette_Text_NoCoinsLeft, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
StartTaskAfterDelayOrInput(taskId, Task_StopPlaying, 60, A_BUTTON | B_BUTTON);
}
}
static void Task_ClearBoard(u8 taskId)
{
u8 i = 0;
gTasks[taskId].tBallNum = 0;
sub_8141FF4(taskId);
ResetHits();
HideBoardBalls();
DrawGridBackground(SELECTION_NONE);
SetBallCounterNumLeft(BALLS_PER_ROUND);
for (i = 0; i < NUM_ROULETTE_SLOTS; i++)
{
gSprites[sRoulette->spriteIds[i + SPR_BOARD_ICONS]].invisible = FALSE;
}
if (gTasks[taskId].tCoins == MAX_COINS)
{
DrawStdWindowFrame(sTextWindowId, FALSE);
AddTextPrinterParameterized(sTextWindowId, 1, Roulette_Text_CoinCaseIsFull, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(sTextWindowId, 3);
StartTaskAfterDelayOrInput(taskId, Task_AskKeepPlaying, 0xFFFF, A_BUTTON | B_BUTTON);
}
else
{
gTasks[taskId].func = Task_AskKeepPlaying;
}
}
static void ExitRoulette(u8 taskId)
{
sub_8151A9C(&sRoulette->varB8, 0xFFFF);
sub_8151678(&sRoulette->varB8);
SetCoins(gTasks[taskId].tCoins);
if (GetCoins() < sRoulette->minBet)
gSpecialVar_0x8004 = TRUE;
else
gSpecialVar_0x8004 = FALSE;
AlertTVOfNewCoinTotal(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 != 0xFFFF)
sRoulette->taskWaitDelay--;
}
static void StartTaskAfterDelayOrInput(u8 taskId, TaskFunc task, u16 delay, u16 key)
{
sRoulette->varB4 = gTasks[taskId].func;
if (task == NULL)
task = sRoulette->varB4;
sRoulette->nextTask = task;
sRoulette->taskWaitDelay = delay;
if (delay == 0xFFFF && key == 0)
sRoulette->taskWaitKey = 0xFFFF;
else
sRoulette->taskWaitKey = key;
gTasks[taskId].func = Task_WaitForNextTask;
}
static void sub_8141FF4(u8 taskId)
{
u8 i = 0;
sRoulette->var00 = i;
sRoulette->var03_7 = FALSE;
sRoulette->var03_5 = FALSE;
sRoulette->var03_6 = 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 var0 = 0;
u8 var2;
u16 var3;
u8 i;
switch (selectionId)
{
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
for (i = (selectionId + 1); i < (selectionId + 5); i++)
{
if (!(sRoulette->hitFlags & sGridSelections[i].flag))
var0 |= sGridSelections[i].var10;
}
sub_8151A48(&sRoulette->varB8, var0 &= 0xDFFF);
break;
default:
{
struct UnkStruct1 var1[3];
memcpy(var1, gUnknown_085B63F0, sizeof(var1));
if (selectionId >= COL_WYNAUT && selectionId <= COL_MAKUHITA)
var2 = 3;
else
var2 = 1;
var3 = selectionId / 5 - 1;
switch (GET_COL(selectionId))
{
// The specific color of the poke it references doesn't matter, because the icons themelves all share a palette
// So it just uses the first sprite ID of each
case COL_WYNAUT:
var3 = gSprites[sRoulette->spriteIds[SPR_BOARD_ICON_ORANGE_WYNAUT]].oam.paletteNum * 16;
break;
case COL_AZURILL:
var3 = gSprites[sRoulette->spriteIds[SPR_BOARD_ICON_GREEN_AZURILL]].oam.paletteNum * 16;
break;
case COL_SKITTY:
var3 = gSprites[sRoulette->spriteIds[SPR_BOARD_ICON_PURPLE_SKITTY]].oam.paletteNum * 16;
break;
case COL_MAKUHITA:
var3 = gSprites[sRoulette->spriteIds[SPR_BOARD_ICON_ORANGE_MAKUHITA]].oam.paletteNum * 16;
break;
}
if (var2 == 1)
{
if (!(sRoulette->hitFlags & sGridSelections[selectionId].flag))
{
var1[selectionId / 5 - 1].var02 += var3;
sub_815168C(&sRoulette->varB8, 13, &var1[selectionId / 5 - 1]);
}
else
{
break;
}
}
else
{
for (i = 0; i < 3; i++)
{
u8 var4 = i * 5 + selectionId + 5;
if (!(sRoulette->hitFlags & sGridSelections[var4].flag))
{
var1[var4 / 5 - 1].var02 += var3;
sub_815168C(&sRoulette->varB8, i + 13, &var1[var4 / 5 - 1]);
if (var2 == 3)
var0 = sGridSelections[var4].var10;
var2--;
}
}
if (var2 != 2)
var0 = 0;
}
sub_8151A48(&sRoulette->varB8, var0 |= sGridSelections[selectionId].var10);
break;
}
}
}
static void DrawGridBackground(u8 selectionId)
{
vu8 i;
vu8 z;
vu16 var1;
vu16 var2;
vu8 var0;
u8 v[5];
u8 l;
sRoulette->var2A = 1;
ShowHideGridIcons(FALSE, 0);
SetGridSelectionRect(sRoulette->tilemapBuffers[2], sRoulette->unk_397C, 14, 7, 16, 13);
switch (selectionId)
{
case SELECTION_NONE:
return;
case COL_WYNAUT:
case COL_AZURILL:
case COL_SKITTY:
case COL_MAKUHITA:
l = 4;
for (i = 0; i < l; i++)
{
v[i] = i * 5 + selectionId;
}
break;
case ROW_ORANGE:
case ROW_GREEN:
case ROW_PURPLE:
l = 5;
for (i = 0; i < l; i++)
{
v[i] = i + selectionId;
}
break;
// Individual square
default:
l = 1;
v[0] = selectionId;
}
for (i = 0; i < l; i++)
{
var0 = sGridSelections[v[i]].var06;
var1 = sGridSelections[v[i]].x;
for (z = 0; z < 3; z++)
{
var2 = (sGridSelections[v[i]].y + z) * 32;
sRoulette->tilemapBuffers[2][var1 + var2 + 0] = sRoulette->unk_397C[(var0 + z) * 3 + 208];
sRoulette->tilemapBuffers[2][var1 + var2 + 1] = sRoulette->unk_397C[(var0 + z) * 3 + 209];
sRoulette->tilemapBuffers[2][var1 + var2 + 2] = sRoulette->unk_397C[(var0 + z) * 3 + 210];
}
}
}
static u8 GetMultiplier(u8 selectionId)
{
u8 multipliers[5] = {0, 3, 4, 6, 12};
if (selectionId > NUM_GRID_SELECTIONS)
selectionId = 0;
switch (sGridSelections[selectionId].baseMultiplier)
{
case NUM_BOARD_COLORS:
selectionId = selectionId / 5 - 1;
// 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--;
// 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[4];
}
return 0;
}
static void sub_8142814(void)
{
s32 x1;
s32 x2;
SetGpuReg(REG_OFFSET_BG2PA, sRoulette->var2C.a);
SetGpuReg(REG_OFFSET_BG2PB, sRoulette->var2C.b);
SetGpuReg(REG_OFFSET_BG2PC, sRoulette->var2C.c);
SetGpuReg(REG_OFFSET_BG2PD, sRoulette->var2C.d);
x1 = 0x7400 - sRoulette->var2C.a * (gSpriteCoordOffsetX + 116)
- sRoulette->var2C.b * (gSpriteCoordOffsetY + 80);
x2 = 0x5400 - sRoulette->var2C.c * (gSpriteCoordOffsetX + 116)
- sRoulette->var2C.d * (gSpriteCoordOffsetY + 80);
SetGpuReg(REG_OFFSET_BG2X_L, x1);
SetGpuReg(REG_OFFSET_BG2X_H, (x1 & 0x0fff0000) >> 16);
SetGpuReg(REG_OFFSET_BG2Y_L, x2);
SetGpuReg(REG_OFFSET_BG2Y_H, (x2 & 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 sBoardIcons_Gfx[] = INCBIN_U32("graphics/roulette/board_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 = 4 },
{ .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 gOamData_85B73EC =
{
.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_BoardIcon =
{
.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_BoardIcons =
{
.data = sBoardIcons_Gfx,
.size = 0xC00,
.tag = GFXTAG_BOARD_ICONS
};
static const union AnimCmd sAnim_BoardIcons[] =
{
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_BoardIcon_OrangeWynaut[] =
{
&sAnim_BoardIcons[0]
};
static const union AnimCmd *const sAnim_BoardIcon_GreenAzurill[] =
{
&sAnim_BoardIcons[1]
};
static const union AnimCmd *const sAnim_BoardIcon_PurpleSkitty[] =
{
&sAnim_BoardIcons[2]
};
static const union AnimCmd *const sAnim_BoardIcon_OrangeMakuhita[] =
{
&sAnim_BoardIcons[3]
};
static const union AnimCmd *const sAnim_BoardIcon_GreenWynaut[] =
{
&sAnim_BoardIcons[4]
};
static const union AnimCmd *const sAnim_BoardIcon_PurpleAzurill[] =
{
&sAnim_BoardIcons[5]
};
static const union AnimCmd *const sAnim_BoardIcon_OrangeSkitty[] =
{
&sAnim_BoardIcons[6]
};
static const union AnimCmd *const sAnim_BoardIcon_GreenMakuhita[] =
{
&sAnim_BoardIcons[7]
};
static const union AnimCmd *const sAnim_BoardIcon_PurpleWynaut[] =
{
&sAnim_BoardIcons[8]
};
static const union AnimCmd *const sAnim_BoardIcon_OrangeAzurill[] =
{
&sAnim_BoardIcons[9]
};
static const union AnimCmd *const sAnim_BoardIcon_GreenSkitty[] =
{
&sAnim_BoardIcons[10]
};
static const union AnimCmd *const sAnim_BoardIcon_PurpleMakuhita[] =
{
&sAnim_BoardIcons[11]
};
static const struct CompressedSpriteSheet sSpriteSheet_Headers =
{
.data = gRouletteHeaders_Gfx,
.size = 0x1600,
.tag = GFXTAG_HEADERS
};
static const struct CompressedSpriteSheet sSpriteSheet_PokeIcons =
{
.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 = &gOamData_85B73EC,
.anims = sAnim_WynautHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &gOamData_85B73EC,
.anims = sAnim_AzurillHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &gOamData_85B73EC,
.anims = sAnim_SkittyHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &gOamData_85B73EC,
.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 = &gOamData_85B73EC,
.anims = sAnim_OrangeHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &gOamData_85B73EC,
.anims = sAnim_GreenHeader,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_GridSquare
},
{
.tileTag = GFXTAG_HEADERS,
.paletteTag = PALTAG_GRID_ICONS,
.oam = &gOamData_85B73EC,
.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
}
};
// Board icons are listed clockwise starting from 1 oclock on the roulette board (with pokeball upside right)
// They go Wynaut -> Azurill -> Skitty -> Makuhita, and Orange -> Green -> Purple
static const struct SpriteTemplate sSpriteTemplates_BoardIcons[NUM_ROULETTE_SLOTS] =
{
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_OrangeWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_GreenAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_PurpleSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_OrangeMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_GreenWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_PurpleAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_OrangeSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_GreenMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_WYNAUT,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_PurpleWynaut,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_AZURILL,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_OrangeAzurill,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_SKITTY,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_GreenSkitty,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
},
{
.tileTag = GFXTAG_BOARD_ICONS,
.paletteTag = PALTAG_MAKUHITA,
.oam = &sOam_BoardIcon,
.anims = sAnim_BoardIcon_PurpleMakuhita,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardIcon
}
};
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 gSpriteAnim_85B7780[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_FRAME(2, 0),
ANIMCMD_FRAME(4, 0),
ANIMCMD_FRAME(6, 0),
ANIMCMD_FRAME(8, 0),
ANIMCMD_FRAME(10, 0),
ANIMCMD_FRAME(12, 0),
ANIMCMD_FRAME(14, 0),
ANIMCMD_FRAME(16, 0),
ANIMCMD_FRAME(18, 0),
// BUG: Animation not terminated properly
//ANIMCMD_END
};
static const union AnimCmd *const gSpriteAnimTable_85B77A8[] =
{
gSpriteAnim_85B7780
};
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 = gSpriteAnimTable_85B77A8,
.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 = &gOamData_85B73EC,
.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 gSpriteAnim_85B786C[] =
{
ANIMCMD_FRAME(0, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B7880[] =
{
ANIMCMD_FRAME(0, 10),
ANIMCMD_FRAME(4, 10),
ANIMCMD_FRAME(8, 10),
ANIMCMD_FRAME(4, 10),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B7894[] =
{
ANIMCMD_FRAME(0, 15),
ANIMCMD_FRAME(4, 15),
ANIMCMD_FRAME(8, 15),
ANIMCMD_FRAME(4, 15),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B78A8[] =
{
ANIMCMD_FRAME(4, 2),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(12, 5),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B78BC[] =
{
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 gSpriteAnim_85B78D4[] =
{
ANIMCMD_FRAME(0, 2),
ANIMCMD_FRAME(4, 5),
ANIMCMD_FRAME(8, 5),
ANIMCMD_FRAME(12, 5),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B78E8[] =
{
ANIMCMD_FRAME(12, 0),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B78F0[] =
{
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[] =
{
gSpriteAnim_85B786C,
gSpriteAnim_85B7880,
gSpriteAnim_85B7894,
gSpriteAnim_85B78A8,
gSpriteAnim_85B78F0,
gSpriteAnim_85B78BC,
gSpriteAnim_85B78D4,
gSpriteAnim_85B78D4,
gSpriteAnim_85B78E8
};
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_BoardCenter =
{
.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_BoardCenter =
{
.data = gRouletteCenter_Gfx,
.size = 0x800,
.tag = GFXTAG_BOARD_CENTER
};
static const struct SpriteTemplate sSpriteTemplate_BoardCenter =
{
.tileTag = GFXTAG_BOARD_CENTER,
.paletteTag = PALTAG_BALL,
.oam = &sOam_BoardCenter,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCB_BoardCenter
};
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 gSpriteAnim_85B799C[] =
{
ANIMCMD_FRAME(80, 10),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B79A4[] =
{
ANIMCMD_FRAME(80, 10, .hFlip = TRUE),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B79AC[] =
{
ANIMCMD_FRAME(80, 20),
ANIMCMD_FRAME(96, 20),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B79B8[] =
{
ANIMCMD_FRAME(80, 20, .hFlip = TRUE),
ANIMCMD_FRAME(96, 20, .hFlip = TRUE),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B79C4[] =
{
ANIMCMD_FRAME(80, 10),
ANIMCMD_FRAME(96, 10),
ANIMCMD_JUMP(0)
};
static const union AnimCmd gSpriteAnim_85B79D0[] =
{
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[] =
{
gSpriteAnim_85B799C,
gSpriteAnim_85B79A4,
gSpriteAnim_85B79AC,
gSpriteAnim_85B79B8,
gSpriteAnim_85B79C4,
gSpriteAnim_85B79D0
};
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 gOamData_85B7A28 =
{
.affineMode = ST_OAM_AFFINE_OFF,
.objMode = ST_OAM_OBJ_NORMAL,
.shape = SPRITE_SHAPE(16x16),
.size = SPRITE_SIZE(16x16),
.priority = 2,
};
static const struct OamData gOamData_85B7A30 =
{
.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 gSpriteAffineAnim_85B7A48[] =
{
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 gSpriteAffineAnimTable_85B7A88[] =
{
gSpriteAffineAnim_85B7A48
};
static const union AffineAnimCmd *const sAffineAnims_TaillowShadow[] =
{
sAffineAnim_TaillowShadow
};
static const union AffineAnimCmd gSpriteAffineAnim_85B7A90[] =
{
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
AFFINEANIMCMD_END
};
static const union AffineAnimCmd *const gSpriteAffineAnimTable_85B7AA0[] =
{
gSpriteAffineAnim_85B7A90
};
static const union AnimCmd gSpriteAnim_85B7AA4[] =
{
ANIMCMD_FRAME(0, 0),
ANIMCMD_END
};
static const union AnimCmd gSpriteAnim_85B7AAC[] =
{
ANIMCMD_FRAME(4, 0),
ANIMCMD_END
};
static const union AnimCmd *const gSpriteAnimTable_85B7AB4[] =
{
gSpriteAnim_85B7AA4
};
static const union AnimCmd *const gSpriteAnimTable_85B7AB8[] =
{
gSpriteAnim_85B7AAC
};
static const struct SpriteTemplate sSpriteTemplate_ShroomishShadow[] =
{
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &gOamData_85B7A28,
.anims = gSpriteAnimTable_85B7AB4,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
},
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &gOamData_85B7A30,
.anims = gSpriteAnimTable_85B7AB8,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = sub_8144E60
}
};
static const struct SpriteTemplate sSpriteTemplate_TaillowShadow =
{
.tileTag = GFXTAG_SHADOW,
.paletteTag = PALTAG_SHADOW,
.oam = &sOam_TaillowShadow,
.anims = gSpriteAnimTable_85B7AB8,
.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(0xFFFFFFFF, 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_TABLE_ID(gSpecialVar_0x8004)];
ConvertIntToDecimalStringN(gStringVar1, minBet, STR_CONV_MODE_LEADING_ZEROS, 1);
StringExpandPlaceholders(gStringVar4, Roulette_Text_PlayMinimumWagerIsX);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, 1, gStringVar4, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(0, 3);
gTasks[taskId].func = Task_ShowMinBetYesNo;
}
}
static void Task_PrintRouletteEntryMsg(u8 taskId)
{
s32 minBet;
PrintCoinsString(gTasks[taskId].tCoins);
minBet = sTableMinBets[GET_TABLE_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, 1, Roulette_Text_SpecialRateTable, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(0, 3);
gTasks[taskId].func = Task_PrintMinBet;
}
else
{
// Print minimum bet
StringExpandPlaceholders(gStringVar4, Roulette_Text_PlayMinimumWagerIsX);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, 1, gStringVar4, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(0, 3);
gTasks[taskId].func = Task_ShowMinBetYesNo;
}
}
else
{
// Not enough for minimum bet
StringExpandPlaceholders(gStringVar4, Roulette_Text_NotEnoughCoins);
DrawStdWindowFrame(0, FALSE);
AddTextPrinterParameterized(0, 1, gStringVar4, 0, 1, TEXT_SPEED_FF, NULL);
CopyWindowToVram(0, 3);
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 CreateBoardIconSprite(const struct SpriteTemplate *r0, u8 r1, u16 *r2)
{
u16 temp;
u8 spriteId = CreateSprite(r0, 116, 80, r0->oam->y);
gSprites[spriteId].data[0] = *r2;
gSprites[spriteId].data[1] = r1;
gSprites[spriteId].coordOffsetEnabled = TRUE;
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
temp = *r2;
*r2 += 30;
if (*r2 >= 360)
*r2 = temp - 330;
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_PokeIcons.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_PokeIcons.size;
s.tag = sSpriteSheet_PokeIcons.tag;
LoadSpriteSheet(&s);
for (i = 0; i < NUM_BOARD_COLORS; i++)
{
u8 o = 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, o + 92, 30);
gSprites[spriteId].animPaused = TRUE;
o += 24;
if (o >= 72)
o = 0;
}
}
for (i = 0; i < ARRAY_COUNT(sSpriteTemplates_PokeHeaders); i++)
{
spriteId = sRoulette->spriteIds[i + SPR_POKE_HEADER_1] = 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_HEADER_1] = 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_BALL_1] = CreateSprite(&sSpriteTemplate_Ball, 116, 20, 10);
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].data[0] = 1;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].callback = SpriteCB_GridSquare;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].oam.priority = 1;
StartSpriteAnim(&gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]], 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_BALL_1]].invisible = TRUE;
}
}
else
{
for (; i < BALLS_PER_ROUND; i++)
{
if (!sRoulette->hitSquares[i] || i == hideBallId)
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].invisible = TRUE;
}
else
{
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].pos1.x = (sGridSelections[sRoulette->hitSquares[i]].x + 1) * 8 + 4;
gSprites[sRoulette->spriteIds[i + SPR_GRID_BALL_1]].pos1.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]].pos1.x = (sGridSelections[selectionId].x + 2) * 8;
gSprites[sRoulette->spriteIds[SPR_WIN_SLOT_CURSOR]].pos1.y = (sGridSelections[selectionId].y + 2) * 8;
}
}
static void CreateBoardIconSprites(void)
{
u8 i, j;
u16 k;
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheet_BoardIcons.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_BoardIcons.size;
s.tag = sSpriteSheet_BoardIcons.tag;
LoadSpriteSheet(&s);
k = 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_BOARD_ICONS + j] = CreateBoardIconSprite(&sSpriteTemplates_BoardIcons[i * NUM_BOARD_POKES + j], 40, &k);
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
}
}
}
static void SpriteCB_BoardIcon(struct Sprite *sprite)
{
s16 cos;
s16 sin;
u32 matrixNum;
s16 angle = sRoulette->var24 + sprite->data[0];
if (angle >= 360)
angle -= 360;
sin = Sin2(angle);
cos = Cos2(angle);
sprite->pos2.x = sin * sprite->data[1] >> 12;
sprite->pos2.y = -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_DIG_1] = CreateSprite(&sSpriteTemplate_CreditDigit, i * 8 + 196, 24, 0);
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].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_1] = CreateSprite(&sSpriteTemplate_BallCounter, i * 16 + 192, 36, 4);
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].invisible = TRUE;
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].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 r0)
{
u8 i;
u16 d = 1000;
bool8 v = FALSE;
for (i = 0; i < MAX_COIN_DIGITS; i++)
{
u8 t = r0 / d;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].invisible = TRUE;
if (t > 0 || v || i == MAX_COIN_DIGITS - 1)
{
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_CREDIT_DIG_1]].anims + t)->type;
v = TRUE;
}
r0 = r0 % 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 = selectionId / 5 - 1;
if (sRoulette->colorHits[selectionId] > 3)
return 0;
return animIds[sRoulette->colorHits[selectionId] + 1];
case NUM_BOARD_POKES:
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 *s = &gSprites[sRoulette->spriteIds[SPR_MULTIPLIER]];
s->animCmdIndex = GetMultiplierAnimId(selectionId);
s->oam.tileNum = s->sheetTileStart + (*s->anims + s->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_1]].invisible = FALSE;
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].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_1]].oam.tileNum =
gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].sheetTileStart
+ (*gSprites[sRoulette->spriteIds[i + SPR_BALL_COUNTER_1]].anims + t + 2)->type;
}
}
}
static void SpriteCB_GridSquare(struct Sprite *sprite)
{
sprite->pos2.x = sRoulette->var26;
}
static void CreateBoardCenterSprite(void)
{
u8 spriteId;
struct SpriteSheet s;
LZ77UnCompWram(sSpriteSheet_BoardCenter.data, gDecompressionBuffer);
s.data = gDecompressionBuffer;
s.size = sSpriteSheet_BoardCenter.size;
s.tag = sSpriteSheet_BoardCenter.tag;
LoadSpriteSheet(&s);
spriteId = CreateSprite(&sSpriteTemplate_BoardCenter, 116, 80, 81);
gSprites[spriteId].data[0] = sRoulette->var24;
gSprites[spriteId].data[1] = 0;
gSprites[spriteId].animPaused = TRUE;
gSprites[spriteId].affineAnimPaused = TRUE;
gSprites[spriteId].coordOffsetEnabled = TRUE;
}
static void SpriteCB_BoardCenter(struct Sprite *sprite)
{
u32 t = sprite->oam.matrixNum;
struct OamMatrix *m = &gOamMatrices[0];
m[t].d = sRoulette->var2C.a;
m[t].a = sRoulette->var2C.a;
m[t].b = sRoulette->var2C.b;
m[t].c = sRoulette->var2C.c;
}
static void CreateBoardBallSprites(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 HideBoardBalls(void)
{
u8 t = sRoulette->spriteIds[SPR_BALL_1];
u8 i;
for (i = 0; i < BALLS_PER_ROUND; i++)
{
u8 j;
gSprites[t].invisible = TRUE;
gSprites[t].callback = &SpriteCallbackDummy;
StartSpriteAnim(&gSprites[t], 0);
for (j = 0; j < 8; j++)
{
gSprites[t].data[j] = 0;
}
t++;
}
}
static s16 sub_8143AC8(struct Sprite *sprite)
{
if (sRoulette->var24 > sprite->data[3])
{
sprite->data[6] = 360 - sRoulette->var24 + sprite->data[3];
if (sprite->data[6] >= 360)
sprite->data[6] -= 360;
}
else
{
sprite->data[6] = sprite->data[3] - sRoulette->var24;
}
return sprite->data[6];
}
static u8 sub_8143B14(struct Sprite *sprite)
{
sRoulette->var7E = sub_8143AC8(sprite) / 30.0f;
return sRoulette->var7E;
}
static s16 sub_8143B48(struct Sprite *sprite)
{
s16 t = sub_8143AC8(sprite) % 30;
u16 z;
if (t == 14)
{
z = 0;
return sprite->data[2] = z;
}
else if (t > 13)
{
z = 43 - t;
return sprite->data[2] = z;
}
else
{
z = 14 - t;
return sprite->data[2] = z;
}
}
static void sub_8143B84(struct Sprite *sprite)
{
s16 sin, cos;
sRoulette->var8C += sRoulette->var90;
sRoulette->var88 += sRoulette->var8C;
if (sRoulette->var88 >= 360)
sRoulette->var88 -= 360.0f;
else if (sRoulette->var88 < 0.0f)
sRoulette->var88 += 360.0f;
sprite->data[3] = sRoulette->var88;
sRoulette->var98 += sRoulette->var9C;
sRoulette->var94 += sRoulette->var98;
sprite->data[4] = sRoulette->var94;
sin = Sin2(sprite->data[3]);
cos = Cos2(sprite->data[3]);
sprite->pos2.x = sin * sprite->data[4] >> 12;
sprite->pos2.y = -cos * sprite->data[4] >> 12;
if (IsSEPlaying())
{
m4aMPlayPanpotControl(&gMPlayInfo_SE1, 0xFFFF, sprite->pos2.x);
m4aMPlayPanpotControl(&gMPlayInfo_SE2, 0xFFFF, sprite->pos2.x);
}
}
static void sub_8143C90(struct Sprite *sprite)
{
s16 sin, cos;
sprite->data[3] = sRoulette->var24 + sprite->data[6];
if (sprite->data[3] >= 360)
sprite->data[3] -= 360;
sin = Sin2(sprite->data[3]);
cos = Cos2(sprite->data[3]);
sprite->pos2.x = sin * sprite->data[4] >> 12;
sprite->pos2.y = -cos * sprite->data[4] >> 12;
sprite->pos2.y += gSpriteCoordOffsetY;
}
static void sub_8143CFC(struct Sprite *sprite)
{
sub_8143B84(sprite);
sprite->data[2]++;
if (sprite->data[4] < -132 || sprite->data[4] > 80)
sprite->invisible = TRUE;
else
sprite->invisible = FALSE;
if (sprite->data[2] >= 30)
{
if (!sprite->data[0])
{
if (sRoulette->var94 <= sRoulette->varA0 - 2.0f)
{
sRoulette->var7D = 0xFF;
sRoulette->var03_7 = FALSE;
StartSpriteAnim(sprite, sprite->animCmdIndex + 0x3);
sub_8143B14(sprite);
sprite->data[4] = 30;
sub_8143AC8(sprite);
sprite->data[6] = (sprite->data[6] / 30) * 30 + 15;
sprite->callback = sub_8143C90;
m4aSongNumStartOrChange(SE_HASHI);
sRoulette->var9C = sRoulette->var98 = 0.0f;
sRoulette->var8C = -1.0f;
}
}
else
{
if (sRoulette->var94 >= sRoulette->varA0 - 2.0f)
{
sRoulette->var7D = 0xFF;
sRoulette->var03_7 = FALSE;
StartSpriteAnim(sprite, sprite->animCmdIndex + 3);
sub_8143B14(sprite);
sprite->data[4] = 30;
sub_8143AC8(sprite);
sprite->data[6] = (sprite->data[6] / 30) * 30 + 15;
sprite->callback = sub_8143C90;
m4aSongNumStartOrChange(SE_HASHI);
sRoulette->var9C = sRoulette->var98 = 0.0f;
sRoulette->var8C = -1.0f;
}
}
}
}
static void SpriteCB_Shroomish(struct Sprite *sprite)
{
float f0, f1, f2;
sub_8143B84(sprite);
switch (sprite->data[3])
{
case 0:
if (sprite->data[0] != 1)
{
f0 = sprite->data[7];
f1 = (f0 * gUnknown_085B6348[sRoulette->tableId].var01 + (gUnknown_085B6348[sRoulette->tableId].var02 - 1));
f2 = (f0 / gUnknown_085B6348[sRoulette->tableId].var0C);
}
else
{
return;
}
break;
case 180:
if (sprite->data[0] != 0)
{
f0 = sprite->data[7];
f1 = (f0 * gUnknown_085B6348[sRoulette->tableId].var01 + (gUnknown_085B6348[sRoulette->tableId].var02 - 1));
f2 = -(f0 / gUnknown_085B6348[sRoulette->tableId].var0C);
}
else
{
return;
}
break;
default:
return;
}
sRoulette->varA0 = sRoulette->var94;
sRoulette->var98 = f2;
sRoulette->var9C = -((f2 * 2.0f) / f1 + (2.0f / (f1 * f1)));
sRoulette->var8C = 0.0f;
sprite->animPaused = FALSE;
sprite->animNum = 0;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->callback = sub_8143CFC;
sprite->data[2] = 0;
}
static void sub_8143FA4(struct Sprite *sprite)
{
sprite->pos2.y = (s16)(sprite->data[2] * 0.05f * sprite->data[2]) - 45;
sprite->data[2]++;
if (sprite->data[2] > 29 && sprite->pos2.y >= 0)
{
sRoulette->var7D = 0xFF;
sRoulette->var03_7 = FALSE;
StartSpriteAnim(sprite, sprite->animCmdIndex + 3);
sub_8143B14(sprite);
sprite->data[4] = 30;
sub_8143AC8(sprite);
sprite->data[6] = (sprite->data[6] / 30) * 30 + 15;
sprite->callback = sub_8143C90;
m4aSongNumStartOrChange(SE_HASHI);
sRoulette->var03_6 = TRUE;
}
}
static void sub_8144050(struct Sprite *sprite)
{
if (sprite->data[2]++ < 45)
{
sprite->pos2.y--;
if (sprite->data[2] == 45)
{
if (gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animCmdIndex == 1)
sprite->pos2.y++;
}
}
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->pos2.y++;
else
sprite->pos2.y--;
}
}
else
{
sprite->animPaused = FALSE;
sprite->animNum = 1;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->data[2] = 0;
sprite->callback = sub_8143FA4;
m4aSongNumStart(SE_NAGERU);
}
}
}
static void sub_8144128(struct Sprite *sprite)
{
sub_8143B84(sprite);
switch (sprite->data[3])
{
case 90:
if (sprite->data[0] != 1)
{
sprite->callback = &sub_8144050;
sprite->data[2] = 0;
}
break;
case 270:
if (sprite->data[0] != 0)
{
sprite->callback = &sub_8144050;
sprite->data[2] = 0;
}
break;
}
}
static void CreateClearSpeciesSprite(struct Sprite *sprite)
{
sub_8143B84(sprite);
switch (sRoulette->useTaillow)
{
default:
case FALSE:
CreateShroomishSprite(sprite);
sprite->callback = SpriteCB_Shroomish;
break;
case TRUE:
CreateTaillowSprite(sprite);
sprite->callback = sub_8144128;
break;
}
}
static void prev_quest_read_x24_hm_usage(struct Sprite *sprite)
{
sub_8143B84(sprite);
if (sprite->data[2]-- == 16)
sRoulette->var98 *= -1.0f;
if (sprite->data[2] == 0)
{
if (!sprite->data[0])
{
sRoulette->var7D = 0xFF;
sRoulette->var03_7 = FALSE;
StartSpriteAnim(sprite, sprite->animCmdIndex + 3);
sub_8143B14(sprite);
sprite->data[4] = 30;
sub_8143AC8(sprite);
sprite->data[6] = (sprite->data[6] / 30) * 30 + 15;
sprite->callback = sub_8143C90;
m4aSongNumStartOrChange(SE_HASHI);
}
else
{
sprite->animPaused = TRUE;
m4aSongNumStart(SE_KON);
sub_8144A24(sprite);
}
}
}
static void sub_8144264(struct Sprite *sprite)
{
sub_8143B84(sprite);
sprite->data[2] = 0;
sub_8143B14(sprite);
if (!(sRouletteSlots[sRoulette->var7E].flag & sRoulette->hitFlags))
{
sRoulette->var7D = 0xFF;
sRoulette->var03_7 = FALSE;
StartSpriteAnim(sprite, sprite->animCmdIndex + 3);
sub_8143B14(sprite);
sprite->data[4] = 30;
sub_8143AC8(sprite);
sprite->data[6] = (sprite->data[6] / 30) * 30 + 15;
sprite->callback = sub_8143C90;
m4aSongNumStartOrChange(SE_HASHI);
}
else
{
u8 slotId;
u32 z;
m4aSongNumStart(SE_KON);
z = Random() & 1;
if (z)
{
sRoulette->var8C = 0.0f;
sRoulette->var7F = slotId = (sRoulette->var7E + 1) % NUM_ROULETTE_SLOTS;
}
else
{
float temp;
sRoulette->var8C = (temp = gUnknown_085B6348[sRoulette->tableId].var1C) * 2.0f;
slotId = (sRoulette->var7E + NUM_ROULETTE_SLOTS - 1) % NUM_ROULETTE_SLOTS;
sRoulette->var7F = sRoulette->var7E;
}
if (sRouletteSlots[slotId].flag & sRoulette->hitFlags)
{
sprite->data[0] = 1;
sprite->data[2] = gUnknown_085B6348[sRoulette->tableId].var02;
}
else
{
sprite->data[0] = sRouletteSlots[slotId].flag & sRoulette->hitFlags;
if (sRoulette->tableId)
{
sprite->data[2] = gUnknown_085B6348[sRoulette->tableId].var01;
}
else
{
sprite->data[2] = gUnknown_085B6348[sRoulette->tableId].var02;
if (z)
sRoulette->var8C = 0.5f;
else
sRoulette->var8C = -1.5f;
}
}
sRoulette->var98 = 0.085f;
sprite->callback = prev_quest_read_x24_hm_usage;
sprite->data[1] = 5;
}
}
static void sub_8144410(struct Sprite *sprite)
{
sub_8143B84(sprite);
if (sRoulette->var8C > 0.5f)
return;
sub_8143B14(sprite);
if (!sub_8143B48(sprite))
{
sRoulette->var90 = 0.0f;
sRoulette->var8C -= (float)(gUnknown_085B6348[sRoulette->tableId].var03)
/ (gUnknown_085B6348[sRoulette->tableId].var04 + 1);
sprite->data[1] = 4;
sprite->callback = sub_8144264;
}
else
{
if (sRoulette->var90 != 0.0f)
{
if (sRoulette->var8C < 0.0f)
{
sRoulette->var90 = 0.0f;
sRoulette->var8C = 0.0f;
sRoulette->var98 /= 1.2;
}
}
}
}
static void sub_8144514(struct Sprite *sprite)
{
sub_8143B84(sprite);
if (sRoulette->var94 > 40.f)
return;
sRoulette->var98 = -(4.0f / (float)(sRoulette->var86));
sRoulette->var90 = -(sRoulette->var8C / (float)(sRoulette->var86));
sprite->animNum = 2;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->data[1] = 3;
sprite->callback = sub_8144410;
}
static void sub_81445D8(struct Sprite *sprite)
{
sub_8143B84(sprite);
if (sRoulette->var94 > 60.0f)
return;
m4aSongNumStartOrChange(SE_TAMAKORO_E);
sRoulette->var98 = -(20.0f / (float)(sRoulette->var84));
sRoulette->var90 = ((1.0f - sRoulette->var8C) / (float)(sRoulette->var84));
sprite->animNum = 1;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
sprite->data[1] = 2;
sprite->callback = sub_8144514;
}
static void sub_81446AC(struct Sprite *sprite)
{
sprite->data[1] = 1;
sprite->data[2] = 0;
sub_8143B84(sprite);
sprite->invisible = FALSE;
sprite->callback = sub_81445D8;
}
static void CreateShroomishSprite(struct Sprite *sprite)
{
u16 t;
u8 i;
s16 s[2][2] = {
{116, 44},
{116, 112}
};
struct Roulette *p;
t = sprite->data[7] - 2;
p = sRoulette; // why???
sRoulette->spriteIds[SPR_CLEAR_MON] = CreateSprite(&sSpriteTemplate_Shroomish, 36, -12, 50);
sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1] = CreateSprite(&sSpriteTemplate_ShroomishShadow[0], s[sprite->data[0]][0], s[sprite->data[0]][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]].data[4] = sRoulette->spriteIds[SPR_CLEAR_MON];
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].data[5] = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1];
gSprites[sRoulette->spriteIds[i + SPR_CLEAR_MON]].data[6] = 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] = (sprite->data[7] * gUnknown_085B6348[sRoulette->tableId].var01) +
(gUnknown_085B6348[sRoulette->tableId].var02 + 0xFFFF);
}
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].coordOffsetEnabled = TRUE;
sRoulette->var38 = sprite;
}
static void CreateTaillowSprite(struct Sprite *sprite)
{
u8 i = 0;
s16 t;
s16 s[2][2] = {
{256, 84},
{-16, 84}
};
t = sprite->data[7] - 2;
sRoulette->spriteIds[SPR_CLEAR_MON] = CreateSprite(&sSpriteTemplate_Taillow, s[sprite->data[0]][0], s[sprite->data[0]][1], 50);
StartSpriteAnim(&gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]], sprite->data[0]);
sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1] = CreateSprite(&sSpriteTemplate_TaillowShadow, s[sprite->data[0]][0], s[sprite->data[0]][1], 51);
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].affineAnimPaused = TRUE;
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].animPaused = TRUE;
sprite->data[7] = (t * gUnknown_085B6348[sRoulette->tableId].var01) + (gUnknown_085B6348[sRoulette->tableId].var10 + 45);
for (; i < 2; i++)
{
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].data[4] = sRoulette->spriteIds[SPR_CLEAR_MON];
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].data[5] = sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1];
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON + i]].data[6] = 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] = sprite->data[7] - 45;
}
sRoulette->var38 = sprite;
}
static void sub_8144A24(struct Sprite *sprite)
{
u8 z;
u16 o;
u8 h = 0;
u8 j = 5;
u8 p = 0;
u8 i = 0;
u8 val;
u8 s[10] = {};
u16 rand = Random();
sRoulette->var7D = 1;
sRoulette->var03_5 = TRUE;
sRoulette->var03_6 = FALSE;
sRoulette->var7E = 0xFF;
sRoulette->var88 = sprite->data[3];
sRoulette->var98 = 0.0f;
sRoulette->var8C = gUnknown_085B6348[sRoulette->tableId].var1C;
o = (sRoulette->tableId * 30 + 33) + (1 - sRoulette->useTaillow) * 15;
for (i = 0; i < 4; i++)
{
if (o < sprite->data[3] && sprite->data[3] <= o + 90)
{
sprite->data[0] = i / 2;
sRoulette->useTaillow = i % 2;
break;
}
if (i == 3)
{
sprite->data[0] = 1;
sRoulette->useTaillow = TRUE;
break;
}
o += 90;
}
if (sRoulette->useTaillow)
{
if (sprite->data[0])
PlayCry1(SPECIES_TAILLOW, -63);
else
PlayCry1(SPECIES_TAILLOW, 63);
}
else
{
PlayCry1(SPECIES_SHROOMISH, -63);
}
val = 2;
z = (sRoulette->var7F + 2) % 12;
if (sRoulette->useTaillow == TRUE && sRoulette->tableId == 1)
j += 6;
else
j += val;
for (i = val; i < j; i++)
{
if (!(sRoulette->hitFlags & sRouletteSlots[z].flag))
{
s[h++] = i;
if (p == 0 && (sRouletteSlots[z].flag & sGridSelections[sRoulette->betSelection[sRoulette->curBallNum]].inSelectionFlags))
p = i;
}
z = (z + 1) % 12;
}
if ((sRoulette->useTaillow + 1) & sRoulette->partySpeciesFlags)
{
if (p && (rand & 0xFF) < 0xc0)
sprite->data[7] = p;
else
sprite->data[7] = s[rand % h];
}
else
{
sprite->data[7] = s[rand % h];
}
sprite->callback = CreateClearSpeciesSprite;
}
static const u16 gUnknown_085B7B1A[] = {
0x907,
0x808,
0x709,
0x60A,
0x50B,
0x40C,
0x30D,
0x20E,
0x10F,
0x010,
};
static void sub_8144C70(struct Sprite *sprite)
{
if (sprite->data[1]++ >= sprite->data[3])
{
sprite->pos1.x -= 2;
if (sprite->pos1.x < -16)
{
if (!sRoulette->var03_6)
sRoulette->var03_6 = TRUE;
DestroySprite(sprite);
sRoulette->var01 = 0;
sRoulette->var34 = gUnknown_085B7B1A[0];
}
}
}
static void sub_8144CD0(struct Sprite *sprite)
{
int p;
u16 t[][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)
{
gSpriteCoordOffsetY = t[sprite->data[2] / 2][sprite->data[7]];
p = sprite->data[7] + 1;
sprite->data[7] = p - ((p / 4) * 4);
}
sprite->invisible ^= 1;
}
else
{
gSpriteCoordOffsetY = 0;
gSprites[sRoulette->spriteIds[SPR_CLEAR_MON]].animPaused = FALSE;
DestroySprite(sprite);
}
}
static void sub_8144D94(struct Sprite *sprite)
{
float t;
sprite->data[1]++;
t = sprite->data[1];
sprite->pos2.y = t * 0.039f * t;
sRoulette->var34 = gUnknown_085B7B1A[(sRoulette->var01 - 1) / 2];
if (sRoulette->var01 < 19)
sRoulette->var01++;
if (sprite->data[1] > 60)
{
sprite->data[1] = 0;
sprite->callback = sub_8144C70;
gSprites[sprite->data[6]].callback = sub_8144C70;
gSprites[sprite->data[6]].data[1] = -2;
gSprites[sprite->data[5]].invisible = FALSE;
gSprites[sprite->data[5]].callback = sub_8144CD0;
m4aSongNumStart(SE_W070);
}
}
static void sub_8144E60(struct Sprite *sprite)
{
if (sprite->data[7] == 0)
{
if (sRoulette->var38->data[0] == 0)
{
if (sRoulette->var38->data[3] != gUnknown_085B6348[sRoulette->tableId].var08)
return;
}
else
{
if (sRoulette->var38->data[3] != gUnknown_085B6348[sRoulette->tableId].var08 + 180)
return;
}
sprite->invisible = FALSE;
sprite->data[7]++;
m4aSongNumStart(SE_RU_HYUU);
sRoulette->var01 = 1;
sRoulette->var34 = gUnknown_085B7B1A[0];
}
else
{
sRoulette->var34 = gUnknown_085B7B1A[(sRoulette->var01 - 1) / 2];
if (sRoulette->var01 < 19)
sRoulette->var01++;
if (sRoulette->var38->data[0] == 0)
{
if (sRoulette->var38->data[3] != gUnknown_085B6348[sRoulette->tableId].var0A)
return;
}
else
{
if (sRoulette->var38->data[3] != gUnknown_085B6348[sRoulette->tableId].var0A + 180)
return;
}
gSprites[sprite->data[4]].callback = sub_8144D94;
gSprites[sprite->data[4]].invisible = FALSE;
sprite->callback = &SpriteCallbackDummy;
sprite->data[7] = 0;
}
}
static void sub_8144F94(struct Sprite *sprite)
{
sprite->invisible ^= 1;
}
static void sub_8144FB0(struct Sprite *sprite)
{
if (sprite->pos1.y > -16)
{
sprite->pos1.y--;
}
else
{
sprite->callback = SpriteCallbackDummy;
sprite->invisible = TRUE;
sprite->animPaused = TRUE;
m4aSongNumStop(SE_BASABASA);
DestroySprite(sprite);
FreeOamMatrix(gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]].oam.matrixNum);
DestroySprite(&gSprites[sRoulette->spriteIds[SPR_CLEAR_MON_SHADOW_1]]);
}
}
static void sub_8145030(struct Sprite *sprite)
{
if (sprite->data[1] >= 0)
{
sprite->data[1]--;
sprite->pos1.y--;
if (sprite->data[1] == 0 && sprite->animCmdIndex == 1)
sprite->pos2.y++;
}
else
{
if (sprite->data[3] >= 0)
{
sprite->data[3]--;
if (sprite->animDelayCounter == 0)
{
if (sprite->animCmdIndex == 1)
sprite->pos2.y++;
else
sprite->pos2.y--;
}
}
else
{
m4aSongNumStart(SE_RU_HYUU);
StartSpriteAnim(sprite, sRoulette->var38->data[0] + 4);
sprite->callback = sub_8144FB0;
gSprites[sprite->data[6]].affineAnimPaused = FALSE;
}
}
}
static void sub_81450D8(struct Sprite *sprite)
{
s8 t[2] = {-1, 1};
s8 z[][2] = {
{2, 0},
{2, 0},
{2, -1},
{2, -1},
{2, -1},
{2, -1},
{2, -2},
{2, -2},
};
if (sprite->data[1]-- > 7)
{
sprite->pos1.x += t[sRoulette->var38->data[0]] * 2;
if (IsSEPlaying())
{
s8 pan = -((116 - sprite->pos1.x) / 2);
m4aMPlayPanpotControl(&gMPlayInfo_SE1, 0xFFFF, pan);
m4aMPlayPanpotControl(&gMPlayInfo_SE2, 0xFFFF, pan);
}
}
else
{
if (sprite->data[1] >= 0)
{
sprite->pos1.x += t[sRoulette->var38->data[0]] * z[7 - sprite->data[1]][0];
sprite->pos1.y += z[7 - sprite->data[1]][1];
}
else
{
m4aSongNumStartOrChange(SE_BASABASA);
if (sRoulette->var38->data[0] == 0)
PlayCry1(SPECIES_TAILLOW, 63);
else
PlayCry1(SPECIES_TAILLOW, -63);
StartSpriteAnim(sprite, sRoulette->var38->data[0] + 2);
sprite->data[1] = 45;
sprite->callback = sub_8145030;
}
}
}
static void sub_8145218(struct Sprite *sprite)
{
s8 t[2] = {-1, 1};
if (sprite->data[1]-- >= 0)
{
sprite->pos1.x += t[sRoulette->var38->data[0]] * 2;
gSprites[sprite->data[6]].invisible ^= 1;
}
else
{
sprite->callback = sub_8144F94;
}
}
static void SpriteCB_Taillow(struct Sprite *sprite)
{
if (sRoulette->var38->data[0] == 0)
{
if (sRoulette->var38->data[3] == gUnknown_085B6348[sRoulette->tableId].var12 + 90)
{
gSprites[sprite->data[6]].data[1] = 52;
gSprites[sprite->data[4]].data[1] = 52;
}
else
{
return;
}
}
else
{
if (sRoulette->var38->data[3] == gUnknown_085B6348[sRoulette->tableId].var14 + 270)
{
gSprites[sprite->data[6]].data[1] = 46;
gSprites[sprite->data[4]].data[1] = 46;
}
else
{
return;
}
}
gSprites[sprite->data[6]].callback = sub_8145218;
gSprites[sprite->data[4]].callback = sub_81450D8;
m4aSongNumStart(SE_RU_HYUU);
}
View Git Blame Copy Permalink