alchemy-docs/psynergy__effects__internal_8h_source.html

#ifndef ALCHEMY_PSYNERGY_EFFECTS_INTERNAL_H

#define ALCHEMY_PSYNERGY_EFFECTS_INTERNAL_H


/// @file

/// What every part of psynergy_effects.c shares: its includes and the macros

/// and types more than one part uses. psynergy_effects.c includes it before the

/// parts, and each part includes it too, so that a part read on its own

/// resolves. It places no bytes.


#include "vram_tab.h"

#include "unit/object/object.h"

#include "unit/object/psynergy_effects.h"

#include "unit/runtime/runtime.h"

#include "types.h"

#include "scene.h"

#include "battle_type.h"

#include "game_state.h"

#include "field_runtime.h"

#include "battle_system.h"

#include "battle.h"

#include "battle_unit.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 "scene_ids.h"

#include "io_reg.h"

#include "iowrite.h"

#include "irq.h"

#include "callback_scheduler.h"

#include "flags.h"

#include "iwram_call.h"

#include "event_work.h"

#include "resource_ids.h"

#include "battle_effect_runtime.h"

#include "resource.h"

#include "field_scene.h"

#include "map.h"

#include "map_scroll.h"

#include "ram_buffer.h"

#include "global_cells.h"

#include "object_runtime.h"

#include "script_object_runtime.h"

#include "animspr.h"

#include "field_obj.h"

#include "object_dispatch.h"

#include "field_event.h"

#include "heap_state.h"

#include "keystate.h"

#include "owner_value.h"

#include "party_state.h"

#include "songs.h"

#include "fixed_math.h"

#include "item_gift.h"

#include "battle_calc.h"

#include "display_transition.h"

#include "text/msg_ids.h"

#include "object_lookup.h"

#include "objdisp.h"

#include "object_effect.h"

#include "item.h"

#include "motobj.h"

#include "static_assert.h"

#include "frame.h"

#include "io_write_queue.h"

#include "palbuf.h"

#include "vram_block.h"

#include "item_ids.h"

#include "inventory.h"

#include "ui.h"

#include "window.h"

#include "battle_party.h"

#include "b5_context.h"

#include "edition.h"

#include "facing_object.h"

#include "script_motion.h"

#include "tbs_edition.h"

#include "metadata_lookup.h"

#include "field_coordinate.h"

#include "scroll.h"

#include "fxblend.h"

#include "fx_scene.h"

#include "effect_slot.h"

#include "object_effect_scripts.h"

#include "menu_list.h"

#include "field_effect.h"

#include "fixed_point_position.h"

#include "unit/scene/common/effect_spawn.h"

#include "unit/scene/common/scroll_initialize_hblank_dma.h"

#include "macros.h"

#include "ability_ids.h"


/// The effect slots of a Psynergy effect's scene (gEffectWork->slots).

#define PSYNERGY_EFFECT_SLOT_COUNT 24


/// gGameState.pendingDjinnEvent of Djinni 0 (requests.c, djinni.c).

#define DJINNI_0 300


/// A FieldActor seen with its position as one vector, to pass it whole. The

/// gaps are FieldActor fields this view does not use.

struct Object {

  u8 pad0[6];

  u16 angle;

  struct EffectVector pos;

  u8 pad1[14];

  u8 kind;

  u8 pad2[0x2d];

  struct AnimationObject *sprite;

};


/// Per-frame update of an afterimage: closes half the distance to the object

/// it is linked to, on all three axes.

static inline void

BattleFx_MoveAfterimageHalfway(union FieldObject *fieldObject) {

  struct FieldActor *afterimage = (struct FieldActor *)fieldObject;

  struct FieldActor *target = afterimage->linkedObject;


  afterimage->x.fixed += (target->x.fixed - afterimage->x.fixed) / 2;

  afterimage->y.fixed += (target->y.fixed - afterimage->y.fixed) / 2;

  afterimage->z.fixed += (target->z.fixed - afterimage->z.fixed) / 2;

}


/// Runs the update of each of the 24 effect slots.

static __inline__ void FieldFx_UpdateSceneSlots(void) {

  struct EffectSlot *slot;

  s32 remainingSlots;


  slot = ((struct BattleFxScene *)gEffectWork)->slots;

  remainingSlots = PSYNERGY_EFFECT_SLOT_COUNT - 1;

  do {

    remainingSlots -= 1;

    EffectSlot_Update(slot);

    slot++;

  } while (remainingSlots >= 0);

}


/// A FieldActor seen with the halfword at 0x64 unsigned and the one at 0x66

/// signed, as the bytes read them (FieldActor's own types change the code).

struct DescendingOrbitObject {

  u8 unk00[8];

  s32 x;

  s32 y;

  s32 z;

  u8 unk14[80];

  u16 timer;

  s16 angle;

};


/// A FieldActor seen with the halfword at 0x5e (lifetime), which FieldActor

/// does not name.

struct CaptureObject {

  u8 unk00[8];

  s32 x;

  s32 y;

  s32 z;

  s32 baseY;

  s32 scaleX;

  s32 scaleY;

  u8 unk20[8];

  s32 gravity;

  u8 unk2c[4];

  s32 speed;

  u8 unk34[33];

  u8 mode;

  u8 unk56[5];

  u8 visible;

  u8 unk5c[2];

  u16 lifetime;

  u8 unk60[4];

  u16 timer;

  u16 angle;

  struct FieldActor *linkedObject;

  void (*callback)(union FieldObject *object);

};


/// Defines a per-frame update that spins an object 1/8 turn a frame while its

/// scale changes by step, releasing the object once the scale falls below

/// 0x3000.

#define DEFINE_SHRINK_AND_DESTROY(name, step)                                  \

  void name(union FieldObject *fieldObject) {                                  \

    void *obj = fieldObject;                                                   \

    s32 scale;                                                                 \

                                                                               \

    scale = ((struct MotionObject *)obj)->scaleX + step;                       \

    ((struct MotionObject *)obj)->scaleY =                                     \

        ((struct MotionObject *)obj)->scaleY + step;                           \

    ((struct MotionObject *)obj)->angle =                                      \

        ((struct MotionObject *)obj)->angle + 0x2000;                          \

    ((struct MotionObject *)obj)->scaleX = scale;                              \

    if (scale < 0x3000) {                                                      \

      ObjectDispatch_ReleaseFar(obj);                                          \

    }                                                                          \

  }


/// the Psynergy effect's work (gWorkSlot[56], gEffectWork)

#define HEAP_SLOT_FX 56


/// A particle's sprite, seen as the two fields Douse and Mind Read set on it.

struct WaveFxSprite {

  u32 unk00[2];

  u8 unk08;

  u32 unk09_0 : 2;

  u32 mode : 2;

  u32 unk09_4 : 4;

  u8 unk0a[0x1c];

  u8 palette;

};


/// A FieldActor seen with the halfword at 0x5e (its lifetime), which

/// FieldActor does not name.

struct ItemBreakFragmentObject {

  u8 reserved00[72];

  s32 gravity;

  u8 reserved4c[9];

  u8 motionFlags;

  u8 reserved56[8];

  u16 lifetime;

};


/// Both item fragments and Lift shed the same short-lived falling particle.

static inline void

BattleFx_InitializeFallingFragment(struct ItemBreakFragmentObject *fragment) {

  // Spawn and choose its position at the call site: combining the spawn here

  // moves the kind load after the coordinate loads in the native English build.

  if (fragment != NULL) {

    fragment->motionFlags = ACTOR_FALLS;

    fragment->gravity = 0x1999;

    ObjectDispatch_SelectAnimationFar(fragment, 0);

    fragment->lifetime = 12;

    ObjectDispatch_InitializeFar((struct DispatchObject *)fragment,

                                 gBattleFx_CommonParticleScript);

  }

}


/// The shards DEFINE_ITEM_BREAK_EFFECT's effects scatter.

#define ITEM_BREAK_SHARD_MAX 24


/// Defines an effect cast with no target: spawn makes an object 16 pixels

/// above the effect's position and 32 pixels to either side; each moves 24

/// pixels its way, then 24 shards scatter 8 to 32 pixels.

#define DEFINE_ITEM_BREAK_EFFECT(name, spawn)                                  \

  void name(void) {                                                            \

    struct BattleFxScene *work;                                                \

    struct MotionObject *obj;                                                  \

    struct MotionObject *pair[2];                                              \

    struct ScatterPosition pos;                                                \

    struct MotionObject **walk;                                                \

    s32 n;                                                                     \

    s32 dist;                                                                  \

                                                                               \

    work = gEffectWork;                                                        \

    BattleEffect_InitializeSharedScene();                                      \

    pos.x = work->x;                                                           \

    pos.y = work->y + 0x100000;                                                \

    pos.z = work->z;                                                           \

    pair[0] = spawn(pos.x + 0x200000, pos.y, pos.z, 0x8000);                   \

    pair[1] = spawn(pos.x - 0x200000, pos.y, pos.z, 0);                        \

                                                                               \

    WaitFrames(15);                                                            \

    walk = pair;                                                               \

    for (n = 0; n < 2; n++) {                                                  \

      obj = *walk++;                                                           \

      if (obj != 0)                                                            \

        Motion_SetTargetPositionFromMagnitudeAngle(                            \

            (struct ObjectRuntime *)obj, 0x180000, obj->angle);                \

    }                                                                          \

                                                                               \

    FieldObject_WaitForMoveFar(pair[0]);                                       \

    AudioCommand_PlayFar(SE_HEAVY_IMPACT);                                     \

    for (n = 0; n < ITEM_BREAK_SHARD_MAX; n++) {                               \

      pos.x = work->x;                                                         \

      pos.y = work->y + 0x100000;                                              \

      pos.z = work->z;                                                         \

      obj = (struct MotionObject *)Object_Spawn(285, pos.x, pos.y, pos.z);     \

      if (obj != 0) {                                                          \

        ObjectDispatch_InitializeFar((struct DispatchObject *)obj,             \

                                     gBattleFx_FragmentScript);                \

        obj->speedLimit = Random16() + 0x20000;                                \

        obj->acceleration = 0x20000;                                           \

        obj->motionFlags = 0;                                                  \

        dist = Random16() * 24 + 0x80000;                                      \

        Motion_SetTargetPositionFromMagnitudeAngle(                            \

            (struct ObjectRuntime *)obj, dist, Random16());                    \

      }                                                                        \

    }                                                                          \

                                                                               \

    ObjectDispatch_ReleaseFar((struct DispatchObject *)pair[0]);               \

    ObjectDispatch_ReleaseFar((struct DispatchObject *)pair[1]);               \

    BattleFx_PrepareBufferInterpolation();                                     \

  }


#define ABOVE (16 << 16) ///< 16 pixels up


/// A FieldActor seen with the halfword at 0x5e (its lifetime), which

/// FieldActor does not name.

struct SparkObject {

  u8 unk00[8];

  s32 x;

  s32 y;

  s32 z;

  u8 unk14[4];

  s32 scaleX;

  s32 scaleY;

  u8 unk20[24];

  s32 anchorX; ///< centre of the sway (FieldActor's targetX)

  u8 unk3c[12];

  s32 gravity; ///< as in FieldActor

  u8 unk4c[9];

  u8 motionFlags; ///< as in FieldActor

  u8 unk56[8];

  u16 lifetime;

  u8 unk60[4];

  s16 phase; ///< phase of the sway (128 frames a cycle)

  u8 unk66[6];

  void (*update)(union FieldObject *object);

};


#endif

ability_ids.h
Ability numbers, named from the English release.

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

b5_context.h
B5Context, the object context a battle routine reads; most of its fields are still unnamed.

battle_calc.h
The battle calculation tables: hit chances, HP and PP damage and recovery.

battle_effect_runtime.h
The battle animation state, render objects and effect entries, and the palette buffer work.

battle_party.h
Which units are in a battle, and the Djinn recovery list.

battle_system.h
BattleUnit_Recalculate, which recalculates a unit's stats.

battle_type.h
BattlePlan, an action planned for its targets: the hits, criticals and multipliers rolled.

battle_unit.h
BattleUnit, a party member's or enemy's battle state, with the elements, abilities and actions it use...

callback_scheduler.h
The task scheduler: tasks, their order and the scheduler's state.

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

display_transition.h
The display transition's frames, windows and state.

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

edition.h
The edition's language, for C to compare (LANGUAGE == LANGUAGE_GERMAN).

EffectSlot_Update
void EffectSlot_Update(struct EffectSlot *effect)
Updates one effect slot: counts its age, runs its callback (after any delay), moves it and draws it.
Definition effect_slot.c:9

effect_slot.h
Effect slots: the particles Psynergy effects move and draw.

event_work.h
EventWork, the running scene's event work.

facing_object.h
FacingObject, the view of an object that turns to face a target.

ObjectDispatch_SelectAnimationFar
void ObjectDispatch_SelectAnimationFar(void *raw, s32 no)

ObjectDispatch_InitializeFar
void ObjectDispatch_InitializeFar(struct DispatchObject *obj, const s32 *script)

field_coordinate.h
FieldCoordinate, a position on the field.

field_effect.h
Field effects, their scripts and the flags that spawn them.

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

field_obj.h
Field objects and actors, and the scene transition styles.

ACTOR_FALLS
@ ACTOR_FALLS
falls by its gravity and bounces
Definition field_obj.h:161

field_runtime.h
The field's runtime work: map cells, scene records and regions, map markers and FieldWork.

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

fixed_math.h
16.16 fixed-point constants, sine and cosine, and the library division.

fixed_point_position.h
FixedPointPosition, a position in 16.16 fixed point.

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

frame.h
The frame loop's globals: lag counts, the CPU load display and the VBlank flags.

fx_scene.h
BattleFxScene, the work of a battle or field Psynergy effect scene, and its arc objects.

fxblend.h
FieldBlendWork, the field's colour blend work.

gBattleFx_CommonParticleScript
const s32 gBattleFx_CommonParticleScript[]
[0] only frees the actor, +1 waits for it to arrive and frees it; +3 is gBattleFx_SourceHoldScript,...
Definition fxdata.c:444

game_state.h
GameState, the game's state: play time, coins, the scene and the leader's position,...

global_cells.h
The work slots of gWorkSlot, read through their own names.

gEffectWork
void * gEffectWork
Slot 56: points to a scene-specific structure.

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

heap_state.h
The heap's work slots and HeapState.

effect_spawn.h

scroll_initialize_hblank_dma.h

inventory.h
gOverflowItem, an item slot the spoils code uses when items are handed out.

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

io_write_queue.h
The register write queue that VBlank carries out after each finished frame.

iowrite.h
Io_Write16, a 16-bit write to a register or memory.

irq.h
The hardware's interrupt sources and the interrupt handler table.

item.h
Items: their definitions, types, flags and effects.

item_gift.h
Declares nothing of its own: it only includes types.h, edition.h and farcall.h.

item_ids.h
Item numbers, named from the English release.

iwram_call.h
The IWRAM call layer: the routines the game keeps resident in IWRAM, each at its fixed address,...

keystate.h
The keypad state the VBlank interrupt keeps.

macros.h
Small statement macros both games use for positions, velocities and bounds.

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

map_scroll.h
The map layers' scroll work and the background scroll values.

mem.h
The heaps: allocating and freeing blocks.

menu_list.h
Menu lists: sprites, cursors, the party status window and paged selections.

metadata_lookup.h
Animation metadata and its lookup by resource.

minigame.h
The reel game's title lettering.

motobj.h
MotionObject, an effect object that moves and draws one sprite.

objdisp.h
The object dispatcher's forward declaration.

object_dispatch.h
The object dispatcher's scripts: key checks, the player, the world map and the camera.

object_effect.h
The fade overlay, the weather particles and the actor effect work.

object_effect_scripts.h
The object scripts effects give their particles and fragments.

object_lookup.h
Declares nothing: an empty header kept for the files that include it.

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

owner_value.h
Declares nothing of its own: it only includes types.h, edition.h and farcall.h.

palbuf.h
Palette fades, the battle effect palette buffers and the colour channel curves.

party_state.h
Declares nothing of its own: it only includes static_assert.h and game_state.h.

psynergy_effects.h

BattleFx_InitializeFallingFragment
static void BattleFx_InitializeFallingFragment(struct ItemBreakFragmentObject *fragment)
Both item fragments and Lift shed the same short-lived falling particle.
Definition psynergy_effects_internal.h:228

BattleFx_MoveAfterimageHalfway
static void BattleFx_MoveAfterimageHalfway(union FieldObject *fieldObject)
Per-frame update of an afterimage: closes half the distance to the object it is linked to,...
Definition psynergy_effects_internal.h:120

FieldFx_UpdateSceneSlots
static __inline__ void FieldFx_UpdateSceneSlots(void)
Runs the update of each of the 24 effect slots.
Definition psynergy_effects_internal.h:130

PSYNERGY_EFFECT_SLOT_COUNT
#define PSYNERGY_EFFECT_SLOT_COUNT
The effect slots of a Psynergy effect's scene (gEffectWork->slots).
Definition psynergy_effects_internal.h:100

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

resource_ids.h
Resource numbers, named where their contents are known.

scene.h
FIELD_AT_OFFSET and the entity and camera views older scene code reads.

scene_ids.h
Scene numbers, named after their places.

script_motion.h
ScriptMotionObject, an object moved by a field script.

script_object_runtime.h
ScriptObjectRuntime, the work of an object a script moves.

scroll.h
The display scroll work, the HBlank scroll work and its wave.

songs.h
Song and sound effect ids, indices into gSound_SongTable.

NULL
#define NULL
Definition bilibin.h:6

static_assert.h
STATIC_ASSERT, a compile-time check that emits nothing.

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

BattleFxScene
The work of a Psynergy effect scene: its caster and target, where it takes place, the map state it re...
Definition fx_scene.h:31

BattleFxScene::slots
struct EffectSlot slots[24]
Definition fx_scene.h:73

CaptureObject
A FieldActor seen with the halfword at 0x5e (lifetime), which FieldActor does not name.
Definition psynergy_effects_internal.h:157

CaptureObject::x
s32 x
Definition psynergy_effects_internal.h:159

CaptureObject::unk60
u8 unk60[4]
Definition psynergy_effects_internal.h:175

CaptureObject::visible
u8 visible
Definition psynergy_effects_internal.h:172

CaptureObject::mode
u8 mode
Definition psynergy_effects_internal.h:170

CaptureObject::angle
u16 angle
Definition psynergy_effects_internal.h:177

CaptureObject::scaleY
s32 scaleY
Definition psynergy_effects_internal.h:164

CaptureObject::timer
u16 timer
Definition psynergy_effects_internal.h:176

CaptureObject::unk34
u8 unk34[33]
Definition psynergy_effects_internal.h:169

CaptureObject::lifetime
u16 lifetime
Definition psynergy_effects_internal.h:174

CaptureObject::unk2c
u8 unk2c[4]
Definition psynergy_effects_internal.h:167

CaptureObject::z
s32 z
Definition psynergy_effects_internal.h:161

CaptureObject::speed
s32 speed
Definition psynergy_effects_internal.h:168

CaptureObject::unk56
u8 unk56[5]
Definition psynergy_effects_internal.h:171

CaptureObject::linkedObject
struct FieldActor * linkedObject
Definition psynergy_effects_internal.h:178

CaptureObject::unk5c
u8 unk5c[2]
Definition psynergy_effects_internal.h:173

CaptureObject::unk00
u8 unk00[8]
Definition psynergy_effects_internal.h:158

CaptureObject::callback
void(*) callback(union FieldObject *object)
Definition psynergy_effects_internal.h:179

CaptureObject::y
s32 y
Definition psynergy_effects_internal.h:160

CaptureObject::scaleX
s32 scaleX
Definition psynergy_effects_internal.h:163

CaptureObject::unk20
u8 unk20[8]
Definition psynergy_effects_internal.h:165

CaptureObject::baseY
s32 baseY
Definition psynergy_effects_internal.h:162

CaptureObject::gravity
s32 gravity
Definition psynergy_effects_internal.h:166

DescendingOrbitObject
A FieldActor seen with the halfword at 0x64 unsigned and the one at 0x66 signed, as the bytes read th...
Definition psynergy_effects_internal.h:145

DescendingOrbitObject::timer
u16 timer
Definition psynergy_effects_internal.h:151

DescendingOrbitObject::unk00
u8 unk00[8]
Definition psynergy_effects_internal.h:146

DescendingOrbitObject::x
s32 x
Definition psynergy_effects_internal.h:147

DescendingOrbitObject::angle
s16 angle
Definition psynergy_effects_internal.h:152

DescendingOrbitObject::y
s32 y
Definition psynergy_effects_internal.h:148

DescendingOrbitObject::z
s32 z
Definition psynergy_effects_internal.h:149

DescendingOrbitObject::unk14
u8 unk14[80]
Definition psynergy_effects_internal.h:150

DispatchObject
A field object as the object dispatcher's far calls take it.
Definition object_dispatch.h:12

EffectSlot
A particle a Psynergy effect moves and draws: its sprite, its position and target,...
Definition effect_slot.h:18

EffectVector
A world position, as Camera_WorldToScreen converts it to the screen.
Definition battle.h:73

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

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

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::z
union FieldCoordinate z
16.16 fixed-point pixels
Definition field_obj.h:37

ItemBreakFragmentObject
A FieldActor seen with the halfword at 0x5e (its lifetime), which FieldActor does not name.
Definition psynergy_effects_internal.h:217

ItemBreakFragmentObject::motionFlags
u8 motionFlags
Definition psynergy_effects_internal.h:221

ItemBreakFragmentObject::gravity
s32 gravity
Definition psynergy_effects_internal.h:219

ItemBreakFragmentObject::reserved56
u8 reserved56[8]
Definition psynergy_effects_internal.h:222

ItemBreakFragmentObject::lifetime
u16 lifetime
Definition psynergy_effects_internal.h:223

ItemBreakFragmentObject::reserved00
u8 reserved00[72]
Definition psynergy_effects_internal.h:218

ItemBreakFragmentObject::reserved4c
u8 reserved4c[9]
Definition psynergy_effects_internal.h:220

Object
A field actor (struct FieldActor), seen with its position as one vector.
Definition run_scene.c:389

Object::pad2
u8 pad2[0x2d]
Definition run_scene.c:395

Object::kind
u8 kind
Definition run_scene.c:394

Object::pos
struct EffectVector pos
Definition run_scene.c:392

Object::sprite
struct AnimationObject * sprite
Definition run_scene.c:396

Object::pad1
u8 pad1[14]
Definition run_scene.c:393

Object::pad0
u8 pad0[6]
Definition run_scene.c:390

Object::angle
u16 angle
Definition run_scene.c:391

SparkObject
A FieldActor seen with the halfword at 0x5e (its lifetime), which FieldActor does not name.
Definition psynergy_effects_internal.h:302

SparkObject::scaleY
s32 scaleY
Definition psynergy_effects_internal.h:309

SparkObject::unk60
u8 unk60[4]
Definition psynergy_effects_internal.h:318

SparkObject::unk00
u8 unk00[8]
Definition psynergy_effects_internal.h:303

SparkObject::phase
s16 phase
phase of the sway (128 frames a cycle)
Definition psynergy_effects_internal.h:319

SparkObject::unk14
u8 unk14[4]
Definition psynergy_effects_internal.h:307

SparkObject::y
s32 y
Definition psynergy_effects_internal.h:305

SparkObject::anchorX
s32 anchorX
centre of the sway (FieldActor's targetX)
Definition psynergy_effects_internal.h:311

SparkObject::lifetime
u16 lifetime
Definition psynergy_effects_internal.h:317

SparkObject::scaleX
s32 scaleX
Definition psynergy_effects_internal.h:308

SparkObject::z
s32 z
Definition psynergy_effects_internal.h:306

SparkObject::unk4c
u8 unk4c[9]
Definition psynergy_effects_internal.h:314

SparkObject::unk3c
u8 unk3c[12]
Definition psynergy_effects_internal.h:312

SparkObject::x
s32 x
Definition psynergy_effects_internal.h:304

SparkObject::gravity
s32 gravity
as in FieldActor
Definition psynergy_effects_internal.h:313

SparkObject::unk66
u8 unk66[6]
Definition psynergy_effects_internal.h:320

SparkObject::update
void(*) update(union FieldObject *object)
Definition psynergy_effects_internal.h:321

SparkObject::unk56
u8 unk56[8]
Definition psynergy_effects_internal.h:316

SparkObject::unk20
u8 unk20[24]
Definition psynergy_effects_internal.h:310

SparkObject::motionFlags
u8 motionFlags
as in FieldActor
Definition psynergy_effects_internal.h:315

WaveFxSprite
A particle's sprite, seen as the two fields Douse and Mind Read set on it.
Definition psynergy_effects_internal.h:205

WaveFxSprite::unk09_4
u32 unk09_4
Definition psynergy_effects_internal.h:210

WaveFxSprite::mode
u32 mode
Definition psynergy_effects_internal.h:209

WaveFxSprite::unk09_0
u32 unk09_0
Definition psynergy_effects_internal.h:208

WaveFxSprite::unk00
u32 unk00[2]
Definition psynergy_effects_internal.h:206

WaveFxSprite::unk0a
u8 unk0a[0x1c]
Definition psynergy_effects_internal.h:211

WaveFxSprite::unk08
u8 unk08
Definition psynergy_effects_internal.h:207

WaveFxSprite::palette
u8 palette
Definition psynergy_effects_internal.h:212

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

tbs_edition.h
Values that differ by patch level or language, chosen once for their code.

types.h
The integer types, TRUE, UNUSED and the fixed-address macros.

s32
signed int s32
Definition types.h:14

u32
unsigned int u32
Definition types.h:15

s16
signed short s16
Definition types.h:12

u16
unsigned short u16
Definition types.h:13

u8
unsigned char u8
Definition types.h:11

ui.h
UiWork, the window system's work, and the status screen's cursors.

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

FieldObject
An object on the field, read as an actor or as an effect.
Definition field_effect.h:63

object.h

runtime.h

vram_block.h
Declares nothing of its own: it only includes the window, battle command, resource and VRAM table hea...

vram_tab.h
The sprite VRAM block cache and its owners.

window.h
The window renderer's work.