1030 lines
28 KiB
C
1030 lines
28 KiB
C
#include "global.h"
|
|
#include "bike.h"
|
|
#include "event_data.h"
|
|
#include "event_object_movement.h"
|
|
#include "fieldmap.h"
|
|
#include "sound.h"
|
|
#include "sprite.h"
|
|
#include "constants/songs.h"
|
|
|
|
#define ROTATING_GATE_TILE_TAG 0x1300
|
|
#define ROTATING_GATE_PUZZLE_MAX 12
|
|
#define GATE_ARM_MAX_LENGTH 2
|
|
|
|
#define GATE_ROT(rotationDirection, arm, longArm) \
|
|
((rotationDirection & 15) << 4) | ((arm & 7) << 1) | (longArm & 1)
|
|
#define GATE_ROT_CW(arm, longArm) GATE_ROT(ROTATE_CLOCKWISE, arm, longArm)
|
|
#define GATE_ROT_ACW(arm, longArm) GATE_ROT(ROTATE_ANTICLOCKWISE, arm, longArm)
|
|
#define GATE_ROT_NONE 255
|
|
|
|
// static functions
|
|
static void SpriteCallback_RotatingGate(struct Sprite *sprite);
|
|
static u8 RotatingGate_CreateGate(u8 gateId, s16 deltaX, s16 deltaY);
|
|
static void RotatingGate_HideGatesOutsideViewport(struct Sprite *sprite);
|
|
|
|
// enums
|
|
enum
|
|
{
|
|
/*
|
|
* |
|
|
* +--
|
|
*/
|
|
GATE_SHAPE_L1,
|
|
|
|
/*
|
|
* |
|
|
* |
|
|
* +--
|
|
*/
|
|
GATE_SHAPE_L2,
|
|
|
|
/*
|
|
* |
|
|
* +----
|
|
*/
|
|
GATE_SHAPE_L3,
|
|
|
|
/*
|
|
* |
|
|
* |
|
|
* +----
|
|
*/
|
|
GATE_SHAPE_L4,
|
|
|
|
/*
|
|
* |
|
|
* +--
|
|
* |
|
|
*/
|
|
GATE_SHAPE_T1,
|
|
|
|
/*
|
|
* |
|
|
* |
|
|
* +--
|
|
* |
|
|
*/
|
|
GATE_SHAPE_T2,
|
|
|
|
/*
|
|
* |
|
|
* +----
|
|
* |
|
|
*/
|
|
GATE_SHAPE_T3,
|
|
|
|
/*
|
|
* An unused T-shape gate
|
|
* |
|
|
* +--
|
|
* |
|
|
* |
|
|
*/
|
|
GATE_SHAPE_T4,
|
|
|
|
/*
|
|
* An unused T-shape gate
|
|
* |
|
|
* |
|
|
* +----
|
|
* |
|
|
*/
|
|
GATE_SHAPE_UNUSED_T1,
|
|
|
|
/*
|
|
* An unused T-shape gate
|
|
* |
|
|
* |
|
|
* +--
|
|
* |
|
|
* |
|
|
*/
|
|
GATE_SHAPE_UNUSED_T2,
|
|
|
|
/*
|
|
* An unused T-shape gate
|
|
* |
|
|
* +----
|
|
* |
|
|
* |
|
|
*/
|
|
GATE_SHAPE_UNUSED_T3,
|
|
|
|
/*
|
|
* An unused T-shape gate
|
|
* |
|
|
* |
|
|
* +----
|
|
* |
|
|
* |
|
|
*/
|
|
GATE_SHAPE_UNUSED_T4,
|
|
};
|
|
|
|
enum
|
|
{
|
|
/*
|
|
* 0 degrees (clockwise)
|
|
* |
|
|
* +--
|
|
* |
|
|
*/
|
|
GATE_ORIENTATION_0,
|
|
|
|
/*
|
|
* 90 degress (clockwise)
|
|
* --+--
|
|
* |
|
|
*/
|
|
GATE_ORIENTATION_90,
|
|
|
|
/*
|
|
* 180 degrees (clockwise)
|
|
* |
|
|
* --+
|
|
* |
|
|
*/
|
|
GATE_ORIENTATION_180,
|
|
|
|
/*
|
|
* 270 degrees (clockwise)
|
|
* |
|
|
* --+--
|
|
*/
|
|
GATE_ORIENTATION_270,
|
|
|
|
GATE_ORIENTATION_MAX,
|
|
};
|
|
|
|
// Describes the location of the gates "arms" when the gate has not
|
|
// been rotated (i.e. rotated 0 degrees)
|
|
enum
|
|
{
|
|
GATE_ARM_NORTH,
|
|
GATE_ARM_EAST,
|
|
GATE_ARM_SOUTH,
|
|
GATE_ARM_WEST,
|
|
};
|
|
|
|
enum
|
|
{
|
|
ROTATE_NONE,
|
|
ROTATE_ANTICLOCKWISE,
|
|
ROTATE_CLOCKWISE,
|
|
};
|
|
|
|
enum
|
|
{
|
|
PUZZLE_NONE,
|
|
PUZZLE_FORTREE_CITY_GYM,
|
|
PUZZLE_ROUTE110_TRICK_HOUSE_PUZZLE6,
|
|
};
|
|
|
|
// structure
|
|
struct RotatingGatePuzzle
|
|
{
|
|
s16 x;
|
|
s16 y;
|
|
u8 shape;
|
|
u8 orientation;
|
|
};
|
|
|
|
// .rodata
|
|
// Fortree
|
|
static const struct RotatingGatePuzzle sRotatingGate_FortreePuzzleConfig[] =
|
|
{
|
|
{ 6, 7, GATE_SHAPE_T2, GATE_ORIENTATION_90},
|
|
{ 9, 15, GATE_SHAPE_T2, GATE_ORIENTATION_180},
|
|
{ 3, 19, GATE_SHAPE_T2, GATE_ORIENTATION_90},
|
|
{ 2, 6, GATE_SHAPE_T1, GATE_ORIENTATION_90},
|
|
{ 9, 12, GATE_SHAPE_T1, GATE_ORIENTATION_0},
|
|
{ 6, 23, GATE_SHAPE_T1, GATE_ORIENTATION_0},
|
|
{12, 22, GATE_SHAPE_T1, GATE_ORIENTATION_0},
|
|
{ 6, 3, GATE_SHAPE_L4, GATE_ORIENTATION_180},
|
|
};
|
|
|
|
// Trickhouse
|
|
static const struct RotatingGatePuzzle sRotatingGate_TrickHousePuzzleConfig[] =
|
|
{
|
|
{14, 5, GATE_SHAPE_T1, GATE_ORIENTATION_90},
|
|
{10, 6, GATE_SHAPE_L2, GATE_ORIENTATION_180},
|
|
{ 6, 6, GATE_SHAPE_L4, GATE_ORIENTATION_90},
|
|
{14, 8, GATE_SHAPE_T1, GATE_ORIENTATION_90},
|
|
{ 3, 10, GATE_SHAPE_L3, GATE_ORIENTATION_270},
|
|
{ 9, 14, GATE_SHAPE_L1, GATE_ORIENTATION_90},
|
|
{ 3, 15, GATE_SHAPE_T3, GATE_ORIENTATION_0},
|
|
{ 2, 17, GATE_SHAPE_L2, GATE_ORIENTATION_180},
|
|
{12, 18, GATE_SHAPE_T3, GATE_ORIENTATION_270},
|
|
{ 5, 18, GATE_SHAPE_L4, GATE_ORIENTATION_90},
|
|
{10, 19, GATE_SHAPE_L3, GATE_ORIENTATION_180},
|
|
};
|
|
|
|
static const u8 sRotatingGateTiles_1[] = INCBIN_U8("graphics/misc/rotating_gate_1.4bpp");
|
|
static const u8 sRotatingGateTiles_2[] = INCBIN_U8("graphics/misc/rotating_gate_2.4bpp");
|
|
static const u8 sRotatingGateTiles_3[] = INCBIN_U8("graphics/misc/rotating_gate_3.4bpp");
|
|
static const u8 sRotatingGateTiles_4[] = INCBIN_U8("graphics/misc/rotating_gate_4.4bpp");
|
|
static const u8 sRotatingGateTiles_5[] = INCBIN_U8("graphics/misc/rotating_gate_5.4bpp");
|
|
static const u8 sRotatingGateTiles_6[] = INCBIN_U8("graphics/misc/rotating_gate_6.4bpp");
|
|
static const u8 sRotatingGateTiles_7[] = INCBIN_U8("graphics/misc/rotating_gate_7.4bpp");
|
|
static const u8 sRotatingGateTiles_8[] = INCBIN_U8("graphics/misc/rotating_gate_8.4bpp");
|
|
|
|
static const struct OamData sOamData_RotatingGateLarge =
|
|
{
|
|
.y = 0,
|
|
.affineMode = ST_OAM_AFFINE_NORMAL,
|
|
.objMode = ST_OAM_OBJ_NORMAL,
|
|
.mosaic = 0,
|
|
.bpp = ST_OAM_4BPP,
|
|
.shape = SPRITE_SHAPE(64x64),
|
|
.x = 0,
|
|
.matrixNum = 0,
|
|
.size = SPRITE_SIZE(64x64),
|
|
.tileNum = 0,
|
|
.priority = 2,
|
|
.paletteNum = 2,
|
|
.affineParam = 0,
|
|
};
|
|
|
|
static const struct OamData sOamData_RotatingGateRegular =
|
|
{
|
|
.y = 0,
|
|
.affineMode = ST_OAM_AFFINE_NORMAL,
|
|
.objMode = ST_OAM_OBJ_NORMAL,
|
|
.mosaic = 0,
|
|
.bpp = ST_OAM_4BPP,
|
|
.shape = SPRITE_SHAPE(32x32),
|
|
.x = 0,
|
|
.matrixNum = 0,
|
|
.size = SPRITE_SIZE(32x32),
|
|
.tileNum = 0,
|
|
.priority = 2,
|
|
.paletteNum = 2,
|
|
.affineParam = 0,
|
|
};
|
|
|
|
static const struct SpriteSheet sRotatingGatesGraphicsTable[] =
|
|
{
|
|
{sRotatingGateTiles_1, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L1},
|
|
{sRotatingGateTiles_2, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L2},
|
|
{sRotatingGateTiles_3, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L3},
|
|
{sRotatingGateTiles_4, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L4},
|
|
{sRotatingGateTiles_5, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T1},
|
|
{sRotatingGateTiles_6, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T2},
|
|
{sRotatingGateTiles_7, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T3},
|
|
{sRotatingGateTiles_8, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T4},
|
|
{NULL},
|
|
};
|
|
|
|
static const union AnimCmd sSpriteAnim_RotatingGateLarge[] =
|
|
{
|
|
ANIMCMD_FRAME(0, 0),
|
|
ANIMCMD_END,
|
|
};
|
|
|
|
static const union AnimCmd sSpriteAnim_RotatingGateRegular[] =
|
|
{
|
|
ANIMCMD_FRAME(0, 0), ANIMCMD_END,
|
|
};
|
|
|
|
static const union AnimCmd *const sSpriteAnimTable_RotatingGateLarge[] =
|
|
{
|
|
sSpriteAnim_RotatingGateLarge,
|
|
};
|
|
|
|
static const union AnimCmd *const sSpriteAnimTable_RotatingGateRegular[] =
|
|
{
|
|
sSpriteAnim_RotatingGateRegular,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_Rotated0[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
|
|
AFFINEANIMCMD_JUMP(0),
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_Rotated90[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0),
|
|
AFFINEANIMCMD_JUMP(0),
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_Rotated180[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0),
|
|
AFFINEANIMCMD_JUMP(0),
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_Rotated270[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0),
|
|
AFFINEANIMCMD_JUMP(0),
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0Faster[] =
|
|
{
|
|
AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0),
|
|
AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8),
|
|
AFFINEANIMCMD_END,
|
|
};
|
|
|
|
static const union AffineAnimCmd *const sSpriteAffineAnimTable_RotatingGate[] =
|
|
{
|
|
sSpriteAffineAnim_Rotated0,
|
|
sSpriteAffineAnim_Rotated90,
|
|
sSpriteAffineAnim_Rotated180,
|
|
sSpriteAffineAnim_Rotated270,
|
|
sSpriteAffineAnim_RotatingAnticlockwise360to270,
|
|
sSpriteAffineAnim_RotatingAnticlockwise90to0,
|
|
sSpriteAffineAnim_RotatingAnticlockwise180to90,
|
|
sSpriteAffineAnim_RotatingAnticlockwise270to180,
|
|
sSpriteAffineAnim_RotatingClockwise0to90,
|
|
sSpriteAffineAnim_RotatingClockwise90to180,
|
|
sSpriteAffineAnim_RotatingClockwise180to270,
|
|
sSpriteAffineAnim_RotatingClockwise270to360,
|
|
sSpriteAffineAnim_RotatingAnticlockwise360to270Faster,
|
|
sSpriteAffineAnim_RotatingAnticlockwise90to0Faster,
|
|
sSpriteAffineAnim_RotatingAnticlockwise180to90Faster,
|
|
sSpriteAffineAnim_RotatingAnticlockwise270to180Faster,
|
|
sSpriteAffineAnim_RotatingClockwise0to90Faster,
|
|
sSpriteAffineAnim_RotatingClockwise90to180Faster,
|
|
sSpriteAffineAnim_RotatingClockwise180to270Faster,
|
|
sSpriteAffineAnim_RotatingClockwise270to360Faster,
|
|
};
|
|
|
|
|
|
static const struct SpriteTemplate sSpriteTemplate_RotatingGateLarge =
|
|
{
|
|
.tileTag = ROTATING_GATE_TILE_TAG,
|
|
.paletteTag = TAG_NONE,
|
|
.oam = &sOamData_RotatingGateLarge,
|
|
.anims = sSpriteAnimTable_RotatingGateLarge,
|
|
.images = NULL,
|
|
.affineAnims = sSpriteAffineAnimTable_RotatingGate,
|
|
.callback = SpriteCallback_RotatingGate,
|
|
};
|
|
|
|
static const struct SpriteTemplate sSpriteTemplate_RotatingGateRegular =
|
|
{
|
|
.tileTag = ROTATING_GATE_TILE_TAG,
|
|
.paletteTag = TAG_NONE,
|
|
.oam = &sOamData_RotatingGateRegular,
|
|
.anims = sSpriteAnimTable_RotatingGateRegular,
|
|
.images = NULL,
|
|
.affineAnims = sSpriteAffineAnimTable_RotatingGate,
|
|
.callback = SpriteCallback_RotatingGate,
|
|
};
|
|
|
|
// These structures describe what happens to the gate if you hit it at
|
|
// a given coordinate in a 4x4 grid when walking in the specified
|
|
// direction. Either the gate does not rotate, or it rotates in the
|
|
// given direction. This information is compared against the gate
|
|
// "arm" layout to see if there is an arm at the position in order to
|
|
// produce the final rotation.
|
|
static const u8 sRotatingGate_RotationInfoNorth[4 * 4] =
|
|
{
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_CW(GATE_ARM_WEST, 1), GATE_ROT_CW(GATE_ARM_WEST, 0), GATE_ROT_ACW(GATE_ARM_EAST, 0), GATE_ROT_ACW(GATE_ARM_EAST, 1),
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
};
|
|
|
|
static const u8 sRotatingGate_RotationInfoSouth[4 * 4] =
|
|
{
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_ACW(GATE_ARM_WEST, 1), GATE_ROT_ACW(GATE_ARM_WEST, 0), GATE_ROT_CW(GATE_ARM_EAST, 0), GATE_ROT_CW(GATE_ARM_EAST, 1),
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE,
|
|
};
|
|
|
|
static const u8 sRotatingGate_RotationInfoWest[4 * 4] =
|
|
{
|
|
GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_NORTH, 1), GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_NORTH, 0), GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_SOUTH, 0), GATE_ROT_NONE, GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_SOUTH, 1), GATE_ROT_NONE, GATE_ROT_NONE,
|
|
};
|
|
|
|
static const u8 sRotatingGate_RotationInfoEast[4 * 4] =
|
|
{
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_NORTH, 1), GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_NORTH, 0), GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_SOUTH, 0), GATE_ROT_NONE,
|
|
GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_SOUTH, 1), GATE_ROT_NONE,
|
|
};
|
|
|
|
// These tables describe the relative coordinate positions the arms
|
|
// must move through in order to be rotated.
|
|
static const struct Coords8 sRotatingGate_ArmPositionsClockwiseRotation[] = {
|
|
{ 0, -1 }, { 1, -2 }, { 0, 0 }, { 1, 0 }, { -1, 0 }, { -1, 1 }, { -1, -1 }, { -2, -1 },
|
|
};
|
|
|
|
static const struct Coords8 sRotatingGate_ArmPositionsAntiClockwiseRotation[] = {
|
|
{ -1, -1 }, { -1, -2 }, { 0, -1 }, { 1, -1 }, { 0, 0 }, { 0, 1 }, { -1, 0 }, { -2, 0 },
|
|
};
|
|
|
|
// Describes where the gates "arms" are in the order north, east, south, west.
|
|
// These are adjusted using the current orientation to perform collision checking
|
|
static const u8 sRotatingGate_ArmLayout[][4 * 2] =
|
|
{
|
|
// L-shape gates
|
|
{
|
|
1, 0,
|
|
1, 0,
|
|
0, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 1,
|
|
1, 0,
|
|
0, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 0,
|
|
1, 1,
|
|
0, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 1,
|
|
1, 1,
|
|
0, 0,
|
|
0, 0,
|
|
},
|
|
|
|
// T-shape gates
|
|
{
|
|
1, 0,
|
|
1, 0,
|
|
1, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 1,
|
|
1, 0,
|
|
1, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 0,
|
|
1, 1,
|
|
1, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 0,
|
|
1, 0,
|
|
1, 1,
|
|
0, 0,
|
|
},
|
|
|
|
// Unused T-shape gates
|
|
// These have 2-3 long arms and cannot actually be used anywhere
|
|
// since configuration for them is missing from the other tables.
|
|
{
|
|
1, 1,
|
|
1, 1,
|
|
1, 0,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 1,
|
|
1, 0,
|
|
1, 1,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 0,
|
|
1, 1,
|
|
1, 1,
|
|
0, 0,
|
|
},
|
|
{
|
|
1, 1,
|
|
1, 1,
|
|
1, 1,
|
|
0, 0,
|
|
},
|
|
};
|
|
|
|
// ewram
|
|
static EWRAM_DATA u8 gRotatingGate_GateSpriteIds[ROTATING_GATE_PUZZLE_MAX] = {0};
|
|
static EWRAM_DATA const struct RotatingGatePuzzle *gRotatingGate_PuzzleConfig = NULL;
|
|
static EWRAM_DATA u8 gRotatingGate_PuzzleCount = 0;
|
|
|
|
// text
|
|
static s32 GetCurrentMapRotatingGatePuzzleType(void)
|
|
{
|
|
if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(FORTREE_CITY_GYM) &&
|
|
gSaveBlock1Ptr->location.mapNum == MAP_NUM(FORTREE_CITY_GYM))
|
|
{
|
|
return PUZZLE_FORTREE_CITY_GYM;
|
|
}
|
|
|
|
if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(ROUTE110_TRICK_HOUSE_PUZZLE6) &&
|
|
gSaveBlock1Ptr->location.mapNum == MAP_NUM(ROUTE110_TRICK_HOUSE_PUZZLE6))
|
|
{
|
|
return PUZZLE_ROUTE110_TRICK_HOUSE_PUZZLE6;
|
|
}
|
|
|
|
return PUZZLE_NONE;
|
|
}
|
|
|
|
static void RotatingGate_ResetAllGateOrientations(void)
|
|
{
|
|
s32 i;
|
|
u8 *ptr = (u8 *)GetVarPointer(VAR_TEMP_0);
|
|
|
|
for (i = 0; i < gRotatingGate_PuzzleCount; i++)
|
|
{
|
|
ptr[i] = gRotatingGate_PuzzleConfig[i].orientation;
|
|
}
|
|
}
|
|
|
|
static s32 RotatingGate_GetGateOrientation(u8 gateId)
|
|
{
|
|
return ((u8 *)GetVarPointer(VAR_TEMP_0))[gateId];
|
|
}
|
|
|
|
static void RotatingGate_SetGateOrientation(u8 gateId, u8 orientation)
|
|
{
|
|
((u8 *)GetVarPointer(VAR_TEMP_0))[gateId] = orientation;
|
|
}
|
|
|
|
static void RotatingGate_RotateInDirection(u8 gateId, u32 rotationDirection)
|
|
{
|
|
u8 orientation = RotatingGate_GetGateOrientation(gateId);
|
|
|
|
if (rotationDirection == ROTATE_ANTICLOCKWISE)
|
|
{
|
|
if (orientation)
|
|
orientation--;
|
|
else
|
|
orientation = GATE_ORIENTATION_270;
|
|
}
|
|
else
|
|
{
|
|
orientation++;
|
|
orientation = orientation % GATE_ORIENTATION_MAX;
|
|
}
|
|
RotatingGate_SetGateOrientation(gateId, orientation);
|
|
}
|
|
|
|
static void RotatingGate_LoadPuzzleConfig(void)
|
|
{
|
|
s32 puzzleType = GetCurrentMapRotatingGatePuzzleType();
|
|
u32 i;
|
|
|
|
switch (puzzleType)
|
|
{
|
|
case PUZZLE_FORTREE_CITY_GYM:
|
|
gRotatingGate_PuzzleConfig = sRotatingGate_FortreePuzzleConfig;
|
|
gRotatingGate_PuzzleCount =
|
|
sizeof(sRotatingGate_FortreePuzzleConfig) / sizeof(struct RotatingGatePuzzle);
|
|
break;
|
|
case PUZZLE_ROUTE110_TRICK_HOUSE_PUZZLE6:
|
|
gRotatingGate_PuzzleConfig = sRotatingGate_TrickHousePuzzleConfig;
|
|
gRotatingGate_PuzzleCount =
|
|
sizeof(sRotatingGate_TrickHousePuzzleConfig) / sizeof(struct RotatingGatePuzzle);
|
|
break;
|
|
case PUZZLE_NONE:
|
|
default:
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < ROTATING_GATE_PUZZLE_MAX - 1; i++)
|
|
{
|
|
gRotatingGate_GateSpriteIds[i] = MAX_SPRITES;
|
|
}
|
|
}
|
|
|
|
static void RotatingGate_CreateGatesWithinViewport(s16 deltaX, s16 deltaY)
|
|
{
|
|
u8 i;
|
|
|
|
// Calculate the bounding box of the camera
|
|
// Same as RotatingGate_DestroyGatesOutsideViewport
|
|
s16 x = gSaveBlock1Ptr->pos.x - 2;
|
|
s16 x2 = gSaveBlock1Ptr->pos.x + MAP_OFFSET_W + 2;
|
|
s16 y = gSaveBlock1Ptr->pos.y - 2;
|
|
s16 y2 = gSaveBlock1Ptr->pos.y + MAP_OFFSET_H;
|
|
|
|
for (i = 0; i < gRotatingGate_PuzzleCount; i++)
|
|
{
|
|
s16 x3 = gRotatingGate_PuzzleConfig[i].x + MAP_OFFSET;
|
|
s16 y3 = gRotatingGate_PuzzleConfig[i].y + MAP_OFFSET;
|
|
|
|
if (y <= y3 && y2 >= y3 && x <= x3 && x2 >= x3 &&
|
|
gRotatingGate_GateSpriteIds[i] == MAX_SPRITES)
|
|
{
|
|
gRotatingGate_GateSpriteIds[i] = RotatingGate_CreateGate(i, deltaX, deltaY);
|
|
}
|
|
}
|
|
}
|
|
|
|
static u8 RotatingGate_CreateGate(u8 gateId, s16 deltaX, s16 deltaY)
|
|
{
|
|
struct Sprite *sprite;
|
|
struct SpriteTemplate template;
|
|
u8 spriteId;
|
|
s16 x, y;
|
|
|
|
const struct RotatingGatePuzzle *gate = &gRotatingGate_PuzzleConfig[gateId];
|
|
|
|
if (gate->shape == GATE_SHAPE_L1 || gate->shape == GATE_SHAPE_T1)
|
|
template = sSpriteTemplate_RotatingGateRegular;
|
|
else
|
|
template = sSpriteTemplate_RotatingGateLarge;
|
|
|
|
template.tileTag = gate->shape + ROTATING_GATE_TILE_TAG;
|
|
|
|
spriteId = CreateSprite(&template, 0, 0, 0x94);
|
|
if (spriteId == MAX_SPRITES)
|
|
return MAX_SPRITES;
|
|
|
|
x = gate->x + MAP_OFFSET;
|
|
y = gate->y + MAP_OFFSET;
|
|
|
|
sprite = &gSprites[spriteId];
|
|
sprite->data[0] = gateId;
|
|
sprite->coordOffsetEnabled = 1;
|
|
|
|
GetMapCoordsFromSpritePos(x + deltaX, y + deltaY, &sprite->x, &sprite->y);
|
|
RotatingGate_HideGatesOutsideViewport(sprite);
|
|
StartSpriteAffineAnim(sprite, RotatingGate_GetGateOrientation(gateId));
|
|
|
|
return spriteId;
|
|
}
|
|
|
|
static void SpriteCallback_RotatingGate(struct Sprite *sprite)
|
|
{
|
|
u8 affineAnimation;
|
|
u8 rotationDirection = sprite->data[1];
|
|
u8 orientation = sprite->data[2];
|
|
|
|
RotatingGate_HideGatesOutsideViewport(sprite);
|
|
|
|
if (rotationDirection == ROTATE_ANTICLOCKWISE)
|
|
{
|
|
affineAnimation = orientation + 4;
|
|
|
|
if (GetPlayerSpeed() != 1)
|
|
affineAnimation += 8;
|
|
|
|
PlaySE(SE_ROTATING_GATE);
|
|
StartSpriteAffineAnim(sprite, affineAnimation);
|
|
}
|
|
else if (rotationDirection == ROTATE_CLOCKWISE)
|
|
{
|
|
affineAnimation = orientation + 8;
|
|
|
|
if (GetPlayerSpeed() != 1)
|
|
affineAnimation += 8;
|
|
|
|
PlaySE(SE_ROTATING_GATE);
|
|
StartSpriteAffineAnim(sprite, affineAnimation);
|
|
}
|
|
|
|
sprite->data[1] = ROTATE_NONE;
|
|
}
|
|
|
|
static void RotatingGate_HideGatesOutsideViewport(struct Sprite *sprite)
|
|
{
|
|
u16 x, y;
|
|
s16 x2, y2;
|
|
|
|
sprite->invisible = FALSE;
|
|
x = sprite->x + sprite->x2 + sprite->centerToCornerVecX + gSpriteCoordOffsetX;
|
|
y = sprite->y + sprite->y2 + sprite->centerToCornerVecY + gSpriteCoordOffsetY;
|
|
|
|
x2 = x + 64; // Dimensions of the rotating gate
|
|
y2 = y + 64;
|
|
|
|
if ((s16)x > DISPLAY_WIDTH + 16 - 1 || x2 < -16)
|
|
{
|
|
sprite->invisible = TRUE;
|
|
}
|
|
|
|
if ((s16)y > DISPLAY_HEIGHT + 16 - 1 || y2 < -16)
|
|
{
|
|
sprite->invisible = TRUE;
|
|
}
|
|
}
|
|
|
|
static void LoadRotatingGatePics(void)
|
|
{
|
|
LoadSpriteSheets(sRotatingGatesGraphicsTable);
|
|
}
|
|
|
|
static void RotatingGate_DestroyGatesOutsideViewport(void)
|
|
{
|
|
s32 i;
|
|
|
|
// Same as RotatingGate_CreateGatesWithinViewport
|
|
s16 x = gSaveBlock1Ptr->pos.x - 2;
|
|
s16 x2 = gSaveBlock1Ptr->pos.x + MAP_OFFSET_W + 2;
|
|
s16 y = gSaveBlock1Ptr->pos.y - 2;
|
|
s16 y2 = gSaveBlock1Ptr->pos.y + MAP_OFFSET_H;
|
|
|
|
for (i = 0; i < gRotatingGate_PuzzleCount; i++)
|
|
{
|
|
s16 xGate = gRotatingGate_PuzzleConfig[i].x + MAP_OFFSET;
|
|
s16 yGate = gRotatingGate_PuzzleConfig[i].y + MAP_OFFSET;
|
|
|
|
if (gRotatingGate_GateSpriteIds[i] == MAX_SPRITES)
|
|
continue;
|
|
|
|
if (xGate < x || xGate > x2 || yGate < y || yGate > y2)
|
|
{
|
|
struct Sprite *sprite = &gSprites[gRotatingGate_GateSpriteIds[i]];
|
|
FreeSpriteOamMatrix(sprite);
|
|
DestroySprite(sprite);
|
|
gRotatingGate_GateSpriteIds[i] = MAX_SPRITES;
|
|
}
|
|
}
|
|
}
|
|
|
|
static s32 RotatingGate_CanRotate(u8 gateId, s32 rotationDirection)
|
|
{
|
|
const struct Coords8 *armPos;
|
|
u8 orientation;
|
|
s16 x, y;
|
|
u8 shape;
|
|
s32 i, j;
|
|
|
|
if (rotationDirection == ROTATE_ANTICLOCKWISE)
|
|
armPos = sRotatingGate_ArmPositionsAntiClockwiseRotation;
|
|
else if (rotationDirection == ROTATE_CLOCKWISE)
|
|
armPos = sRotatingGate_ArmPositionsClockwiseRotation;
|
|
else
|
|
return FALSE;
|
|
|
|
orientation = RotatingGate_GetGateOrientation(gateId);
|
|
|
|
shape = gRotatingGate_PuzzleConfig[gateId].shape;
|
|
x = gRotatingGate_PuzzleConfig[gateId].x + MAP_OFFSET;
|
|
y = gRotatingGate_PuzzleConfig[gateId].y + MAP_OFFSET;
|
|
|
|
// Loop through the gate's "arms" clockwise (north, south, east, west)
|
|
for (i = GATE_ARM_NORTH; i <= GATE_ARM_WEST; i++)
|
|
{
|
|
// Ensure that no part of the arm collides with the map
|
|
for (j = 0; j < GATE_ARM_MAX_LENGTH; j++)
|
|
{
|
|
u8 armIndex = 2 * ((orientation + i) % 4) + j;
|
|
|
|
if (sRotatingGate_ArmLayout[shape][2 * i + j])
|
|
{
|
|
if (MapGridIsImpassableAt(x + armPos[armIndex].x, y + armPos[armIndex].y) == TRUE)
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static s32 RotatingGate_HasArm(u8 gateId, u8 armInfo)
|
|
{
|
|
s32 arm = armInfo / 2;
|
|
s32 isLongArm = armInfo % 2;
|
|
|
|
s8 armOrientation = (arm - RotatingGate_GetGateOrientation(gateId) + 4) % 4;
|
|
s32 shape = gRotatingGate_PuzzleConfig[gateId].shape;
|
|
return sRotatingGate_ArmLayout[shape][armOrientation * 2 + isLongArm];
|
|
}
|
|
|
|
static void RotatingGate_TriggerRotationAnimation(u8 gateId, s32 rotationDirection)
|
|
{
|
|
if (gRotatingGate_GateSpriteIds[gateId] != MAX_SPRITES)
|
|
{
|
|
struct Sprite *sprite = &gSprites[gRotatingGate_GateSpriteIds[gateId]];
|
|
sprite->data[1] = rotationDirection;
|
|
sprite->data[2] = RotatingGate_GetGateOrientation(gateId);
|
|
}
|
|
}
|
|
|
|
static u8 RotatingGate_GetRotationInfo(u8 direction, s16 x, s16 y)
|
|
{
|
|
const u8 *ptr;
|
|
|
|
if (direction == DIR_NORTH)
|
|
ptr = sRotatingGate_RotationInfoNorth;
|
|
else if (direction == DIR_SOUTH)
|
|
ptr = sRotatingGate_RotationInfoSouth;
|
|
else if (direction == DIR_WEST)
|
|
ptr = sRotatingGate_RotationInfoWest;
|
|
else if (direction == DIR_EAST)
|
|
ptr = sRotatingGate_RotationInfoEast;
|
|
else
|
|
return GATE_ROT_NONE;
|
|
|
|
return ptr[y * 4 + x];
|
|
}
|
|
|
|
void RotatingGate_InitPuzzle(void)
|
|
{
|
|
if (GetCurrentMapRotatingGatePuzzleType())
|
|
{
|
|
RotatingGate_LoadPuzzleConfig();
|
|
RotatingGate_ResetAllGateOrientations();
|
|
}
|
|
}
|
|
|
|
void RotatingGatePuzzleCameraUpdate(u16 deltaX, u16 deltaY)
|
|
{
|
|
if (GetCurrentMapRotatingGatePuzzleType())
|
|
{
|
|
RotatingGate_CreateGatesWithinViewport(deltaX, deltaY);
|
|
RotatingGate_DestroyGatesOutsideViewport();
|
|
}
|
|
}
|
|
|
|
void RotatingGate_InitPuzzleAndGraphics(void)
|
|
{
|
|
if (GetCurrentMapRotatingGatePuzzleType())
|
|
{
|
|
LoadRotatingGatePics();
|
|
RotatingGate_LoadPuzzleConfig();
|
|
RotatingGate_CreateGatesWithinViewport(0, 0);
|
|
}
|
|
}
|
|
|
|
bool8 CheckForRotatingGatePuzzleCollision(u8 direction, s16 x, s16 y)
|
|
{
|
|
s32 i;
|
|
|
|
if (!GetCurrentMapRotatingGatePuzzleType())
|
|
return FALSE;
|
|
for (i = 0; i < gRotatingGate_PuzzleCount; i++)
|
|
{
|
|
s16 gateX = gRotatingGate_PuzzleConfig[i].x + MAP_OFFSET;
|
|
s16 gateY = gRotatingGate_PuzzleConfig[i].y + MAP_OFFSET;
|
|
|
|
if (gateX - 2 <= x && x <= gateX + 1 && gateY - 2 <= y && y <= gateY + 1)
|
|
{
|
|
s16 centerX = x - gateX + 2;
|
|
s16 centerY = y - gateY + 2;
|
|
u8 rotationInfo = RotatingGate_GetRotationInfo(direction, centerX, centerY);
|
|
|
|
if (rotationInfo != GATE_ROT_NONE)
|
|
{
|
|
u8 rotationDirection = ((rotationInfo & 0xF0) >> 4);
|
|
u8 armInfo = rotationInfo & 0xF;
|
|
|
|
if (RotatingGate_HasArm(i, armInfo))
|
|
{
|
|
if (RotatingGate_CanRotate(i, rotationDirection))
|
|
{
|
|
RotatingGate_TriggerRotationAnimation(i, rotationDirection);
|
|
RotatingGate_RotateInDirection(i, rotationDirection);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
bool8 CheckForRotatingGatePuzzleCollisionWithoutAnimation(u8 direction, s16 x, s16 y)
|
|
{
|
|
s32 i;
|
|
|
|
if (!GetCurrentMapRotatingGatePuzzleType())
|
|
return FALSE;
|
|
for (i = 0; i < gRotatingGate_PuzzleCount; i++)
|
|
{
|
|
s16 gateX = gRotatingGate_PuzzleConfig[i].x + MAP_OFFSET;
|
|
s16 gateY = gRotatingGate_PuzzleConfig[i].y + MAP_OFFSET;
|
|
|
|
if (gateX - 2 <= x && x <= gateX + 1 && gateY - 2 <= y && y <= gateY + 1)
|
|
{
|
|
s16 centerX = x - gateX + 2;
|
|
s16 centerY = y - gateY + 2;
|
|
u8 rotationInfo = RotatingGate_GetRotationInfo(direction, centerX, centerY);
|
|
|
|
if (rotationInfo != GATE_ROT_NONE)
|
|
{
|
|
u8 rotationDirection = ((rotationInfo & 0xF0) >> 4);
|
|
u8 armInfo = rotationInfo & 0xF;
|
|
|
|
if (RotatingGate_HasArm(i, armInfo))
|
|
{
|
|
if (!RotatingGate_CanRotate(i, rotationDirection))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|