alchemy-docs/src_2scene_2common_2mercury__lighthouse__lights_8h_source.html

#include "battle.h"

#include "debug.h"

#include "field.h"

#include "game.h"

#include "graphics.h"

#include "menu.h"

#include "minigame.h"

#include "sound.h"

#include "system.h"

#include "mem.h"

#include "dma.h"

#include "ram_buffer.h"

#include "field_event.h"

#include "field_scene.h"

#include "object_runtime.h"

#include "animspr.h"

#include "map.h"

#include "io_reg.h"

#include "flags.h"


// Mercury Lighthouse and its entrance: the lights that carry the leader over

// the pool (mercury_lighthouse_pillar.h).


/// Keeps the lights' state st in work slot 35 for the floor's region, the

/// pool's collision code. On an ordinary entrance the leader has no lights.

/// When the party returns to where it was, the column of lights over the leader

/// and the light under them in the pool are made again.

void MercuryLighthouse_RestoreLights(s32 region,

                                     struct MercuryLighthouseLights *st) {

  struct FieldActor *actor;

  struct FieldActor *obj;

  struct AnimationObject *anim;

  struct MapCell *cell;

  s32 z;

  s32 flag;


  *(struct MercuryLighthouseLights **)Runtime_AllocateBlock(35, sizeof(st)) =

      st;

  flag = Engine_GameFlagIsSet(FLAG_KEEP_PARTY_POSITION);

  if (flag == 0) {

    Dma_Fill32(flag, st, sizeof(*st));

    st->terrainCode = region;

    return;

  }

  actor = Engine_ActorLookup(gGameState.selectedActor);

  z = actor->z.fixed;

  cell = (struct MapCell *)Ram_MapCellBuffer + ((z / 0x100000) << 7) +

         actor->x.fixed / 0x100000;

  if (st->levels != 0 && st->pillar != 0) {

    obj = Engine_ObjectCreate(26, actor->x.fixed, actor->y.fixed + 0x180000, z);

    if (obj != 0) {

      obj->terrainHeight = actor->terrainHeight;

      anim = obj->sprite;

      Engine_ObjectSetScript(obj, gMercuryLighthouse_PillarScript);

      obj->linkedObject = actor;

      obj->motionFlags = 4;

      obj->y.fixed += -0x8000;

      if (anim != 0) {

        AnimationObjects_SelectAnimation(anim, 6 - st->levels);

        anim->flags = 0;

        anim->image.priority = 1;

      }

      st->pillar = obj;

    }

  } else {

    st->pillar = 0;

  }

  if (cell->collisionCode == region && st->stepEffect != 0) {

    obj =

        Engine_ObjectCreate(26, actor->x.fixed, actor->y.fixed, actor->z.fixed);

    if (obj == 0)

      return;

    obj->terrainHeight = actor->terrainHeight;

    anim = obj->sprite;

    Engine_ObjectSetScript(obj, gMercuryLighthouse_RampScript);

    obj->motionFlags = 0;

    obj->timer = 0;

    obj->priorityFlags = 2;

    obj->speed = 0x40000;

    if (anim != 0) {

      AnimationObjects_SelectAnimation(anim, 6);

      anim->flags = 0;

    }

    st->stepEffect = obj;

  } else {

    st->stepEffect = 0;

  }

}

AnimationObjects_SelectAnimation
s32 AnimationObjects_SelectAnimation(struct AnimationObject *sprite, s32 animation)
Starts animation flags & 0x7f on every layer of a sprite (bit 7 keeps each layer's place and timer),...
Definition animation.c:317

animspr.h
Animated sprites: their layers, frames and colour modes, and the resource slots they draw from.

Engine_ObjectCreate
struct FieldActor * Engine_ObjectCreate(s32, s32, s32, s32)

debug.h
The engine calls the debug menus import, and their palette swatch tiles.

dma.h
DMA channel registers, and the DMA and CPU fills.

Dma_Fill32
#define Dma_Fill32(value, destination, size)
Fills size bytes at destination with the word value by DMA3.
Definition dma.h:30

field_event.h
The scene script layer: the engine services a scene's events call, declared once (Engine_EventBegin,...

Engine_ActorLookup
struct FieldActor * Engine_ActorLookup(s32 actor)

Engine_ObjectSetScript
void Engine_ObjectSetScript(struct FieldActor *object, const s32 *script)

Engine_GameFlagIsSet
s32 Engine_GameFlagIsSet(s32 flag)

field_scene.h
The scene table formats: entrances, exits, placements and events, and the macros that write them.

flags.h
Game flags, named where their meaning is shown.

FLAG_KEEP_PARTY_POSITION
#define FLAG_KEEP_PARTY_POSITION
Definition flags.h:93

gGameState
struct GameState gGameState

graphics.h
The screen blend's globals and the graphics routines.

Runtime_AllocateBlock
void * Runtime_AllocateBlock(s32 kind, s32 size)
As Runtime_AllocateHeapBlock, but tries EWRAM first, for blocks that need room more than speed: the b...
Definition heap.c:80

io_reg.h
The hardware's I/O registers and their bits, as pret names them.

map.h
Maps: their cells, layers, animations and blend scripts, and the map state.

mem.h
The heaps: allocating and freeing blocks.

gMercuryLighthouse_PillarScript
s32 gMercuryLighthouse_PillarScript[]
Definition mercury_lighthouse.c:2742

gMercuryLighthouse_RampScript
s32 gMercuryLighthouse_RampScript[]
Definition mercury_lighthouse.c:2732

minigame.h
The reel game's title lettering.

object_runtime.h
ObjectRuntime, a field object's runtime state, and the object snapshots.

ram_buffer.h
The work pointers in the gWorkSlot table, by name.

Ram_MapCellBuffer
#define Ram_MapCellBuffer
Definition ram_buffer.h:10

MercuryLighthouse_RestoreLights
void MercuryLighthouse_RestoreLights(s32 region, struct MercuryLighthouseLights *st)
Keeps the lights' state st in work slot 35 for the floor's region, the pool's collision code.
Definition mercury_lighthouse_lights.h:28

AnimationObject
An animated sprite: its image and shadow, scale, rotation, size and up to four animation layers.
Definition animspr.h:108

AnimationObject::image
struct AnimationSpritePart image
Definition animspr.h:109

AnimationObject::flags
u8 flags
bits: 1 outlined in ObjectSystemWork's edge and fill colours | 0 shadow drawn (set when created)
Definition animspr.h:128

AnimationSpritePart::priority
u16 priority
2 when created
Definition animspr.h:100

FieldActor
A field actor: a person or thing on the field with a position, motion toward a target,...
Definition field_obj.h:30

FieldActor::timer
s16 timer
The parameter its action script reads (a follow distance or an angle to face), the player's frames to...
Definition field_obj.h:109

FieldActor::speed
s32 speed
speed limit, 16.16 fixed-point pixels per frame
Definition field_obj.h:55

FieldActor::linkedObject
struct FieldActor * linkedObject
The object its action script follows or faces.
Definition field_obj.h:114

FieldActor::motionFlags
u8 motionFlags
ActorMotionFlag bits; zero is free flight in 3D, and 3 is set on creation.
Definition field_obj.h:83

FieldActor::x
union FieldCoordinate x
16.16 fixed-point pixels
Definition field_obj.h:35

FieldActor::y
union FieldCoordinate y
16.16 fixed-point pixels
Definition field_obj.h:36

FieldActor::priorityFlags
u8 priorityFlags
ActorPriorityFlag bits, read by the scrolling camera.
Definition field_obj.h:51

FieldActor::terrainHeight
s32 terrainHeight
16.16 fixed-point pixels
Definition field_obj.h:38

FieldActor::z
union FieldCoordinate z
16.16 fixed-point pixels
Definition field_obj.h:37

GameState::selectedActor
s32 selectedActor
the leader: its unit and its actor
Definition game_state.h:59

MapCell
One cell of a map layer: its metatile and flags, its collision code and an attribute indexing the col...
Definition map.h:13

MapCell::collisionCode
u8 collisionCode
The step code: 1 to 239 scene events, 240 and 241 encounter ground, 250 hazard, 252 to 254 for Field_...
Definition map.h:18

MercuryLighthouseLights
Published in the scene's light-controller slot while the pillar is active.
Definition mercury_lighthouse_lights.h:10

MercuryLighthouseLights::terrainCode
s32 terrainCode
the pool's collision code, the floor's region
Definition mercury_lighthouse_lights.h:14

MercuryLighthouseLights::levels
s32 levels
The leader's lights, 0 to 3: the heart gives three and each hop into the pool spends one.
Definition mercury_lighthouse_lights.h:13

MercuryLighthouseLights::pillar
struct FieldActor * pillar
the column of light over the leader, or null
Definition mercury_lighthouse_lights.h:21

MercuryLighthouseLights::stepEffect
struct FieldActor * stepEffect
The light holding the leader up where they landed in the pool, or null.
Definition mercury_lighthouse_lights.h:23

system.h
The system's routines and globals: interrupts, BIOS sound bias, random numbers and sleep.

s32
signed int s32
Definition types.h:14

FieldCoordinate::fixed
s32 fixed
16.16 fixed-point pixels
Definition field_coordinate.h:12