sol_sanctum_elemental_star_ring_setup.h

Go to the documentation of this file.

#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 "io_reg.h"
 
// Sol Sanctum's Elemental Star room and its eruption: the lights that float in
// the room (actors 15 to 24), each pulsing and drifting on its own path from
// the tables gSolSanctumRing_* and gSolSanctum_Ring*, by its index.
 
enum { SOL_SANCTUM_RING_MAX = 10 };
 
/// Legacy actor view used only while setting up the sprite flags.
struct SolSanctumRingObject {
  u8 pad00[8];
  s32 x;
  s32 y;
  s32 z;
  u8 pad14[4];
  s32 scaleX;
  s32 scaleY;
  u8 pad20[24];
  s32 baseX;
  s32 baseY;
  s32 baseZ;
  u8 pad44[12];
  u8 *anim;
  u8 pad54;
  u8 state;
};
 
/// One floating light: its actor, its drift and its pulsing scale, and where it
/// is while hidden.
struct SolSanctumRingEntry {
  struct FieldActor *obj;
  s32 x; ///< 16.16 fixed-point pixels
  s32 y; ///< 16.16 fixed-point pixels
  s32 z; ///< 16.16 fixed-point pixels
  s32 speedX;
  s32 speedY;
  s32 speedZ;
  s32 scale;     ///< 16.16 fixed point, where 0x10000 is full size
  s32 scaleStep; ///< 16.16 fixed point
  u8 timer;
  u8 hold;
  u8 pad26[2];
};
 
/// The floating lights' work in work slot 33, one entry per light.
struct SolSanctumRingList {
  struct SolSanctumRingEntry entries[SOL_SANCTUM_RING_MAX];
  u16 count;
};
 
/// A scene callback, the lights' work in work slot 33. Every third frame each
/// light grows to its largest scale and shrinks to a tenth; at the smallest it
/// vanishes for 24 steps while its drift carries on, and comes back where the
/// drift has taken it. Its drift is a random speed on each axis, as its tables
/// allow, turned into a sine swing.
static void SolSanctum_UpdateRing(void) {
  struct SolSanctumRingList *list =
      Runtime_AllocateBlock(33, sizeof(struct SolSanctumRingList));
  struct SolSanctumRingEntry *entry = list->entries;
  u32 i;
 
  i = 0;
  while (i != list->count) {
    struct FieldActor *obj;
    s32 speedX;
    s32 speedY;
    s32 speedZ;
    s32 scale;
    s32 step;
    u8 timer;
    s32 x;
    s32 y;
    s32 z;
    u8 hold;
 
    obj = entry->obj;
    speedX = entry->speedX;
    speedY = entry->speedY;
    speedZ = entry->speedZ;
    scale = entry->scale;
    step = entry->scaleStep;
    hold = entry->hold;
    x = entry->x;
    y = entry->y;
    z = entry->z;
    timer = entry->timer;
    if (--timer == 0) {
      u32 rx;
      u32 ry;
      u32 rz;
      s32 dx;
      s32 dy;
 
      timer = 3;
      if (hold == 0) {
        scale += step;
        if (scale >= gSolSanctumRing_MaxScales[i]) {
          step = -gSolSanctumRing_ScaleSteps[i];
        } else if (scale <= 0x1999) {
          step = gSolSanctumRing_ScaleSteps[i];
          scale = 0x1999;
          hold = 24;
          x = obj->x.fixed;
          y = obj->y.fixed;
          z = obj->z.fixed;
          obj->x.fixed = 0;
          obj->y.fixed = 0;
          obj->z.fixed = 0;
        }
        obj->scaleX = scale;
        obj->scaleY = scale;
      }
      rx = (gSolSanctum_RingDrift[i][0] * (u32)Engine_RandomNext()) >> 16;
      ry = (gSolSanctum_RingDrift[i][1] * (u32)Engine_RandomNext()) >> 16;
      rz = (gSolSanctum_RingDrift[i][2] * (u32)Engine_RandomNext()) >> 16;
      rx = rx != 0 ? (rx << 16) / 1000 : 0;
      ry = ry != 0 ? (ry << 16) / 1000 : 0;
      rz = rz != 0 ? (rz << 16) / 1000 : 0;
      if (gSolSanctum_RingDirection[i][0] == 1)
        speedX += rx;
      else if (gSolSanctum_RingDirection[i][0] == -1)
        speedX -= rx;
      else
        speedX = 0;
      if (gSolSanctum_RingDirection[i][1] == 1)
        speedY += ry;
      else if (gSolSanctum_RingDirection[i][1] == -1)
        speedY -= ry;
      else
        speedY = 0;
      if (gSolSanctum_RingDirection[i][2] == 1)
        speedZ += rz;
      else if (gSolSanctum_RingDirection[i][2] == -1)
        speedZ -= rz;
      else
        speedZ = 0;
      dx = Engine_MathSin(speedX * gSolSanctum_RingSwing[i][0]) * 2;
      dy = Engine_MathSin(speedY * gSolSanctum_RingSwing[i][1]) * 2;
      {
        s32 dz = Engine_MathCos(speedZ * gSolSanctum_RingSwing[i][2]) * 2;
 
        if (hold != 0) {
          x += dx;
          y += dy;
          z += dz;
          if (--hold == 0) {
            obj->x.fixed = x;
            obj->targetX = x;
            if (ry != 0) {
              obj->y.fixed = y;
              obj->targetY = y;
            }
            obj->z.fixed = z;
            obj->targetZ = z;
          }
        } else {
          obj->x.fixed += dx;
          obj->targetX = obj->x.fixed;
          if (ry != 0) {
            obj->y.fixed += dy;
            obj->targetY = obj->y.fixed;
          }
          obj->z.fixed += dz;
          obj->targetZ = obj->z.fixed;
        }
      }
    }
    entry->speedX = speedX;
    entry->speedY = speedY;
    entry->speedZ = speedZ;
    entry->scale = scale;
    entry->scaleStep = step;
    entry->hold = hold;
    entry->x = x;
    entry->y = y;
    entry->z = z;
    entry->timer = timer;
    i++;
    entry++;
  }
}
 
/// Starts the floating lights: count actors (at most 10) from first, each drawn
/// translucent and starting at its largest scale.
void SolSanctum_StartFloatingLights(s32 first, u32 count) {
  // The actors are read through struct SolSanctumRingObject, the plain-C view
  // this site matches with (scene/README.md): it keeps the sprite-flags address
  // before the ring-entry store, where FieldActor and AnimationObject swap the
  // two instructions. The callback reads FieldActor.
  struct SolSanctumRingList *list;
  struct SolSanctumRingEntry *entry;
  struct SolSanctumRingObject *obj;
  u32 i;
  s32 none;
  s32 cleared;
 
  list = Runtime_AllocateBlock(33, sizeof(struct SolSanctumRingList));
  entry = list->entries;
  Dma_Fill32(0, list, sizeof(struct SolSanctumRingList));
  if (count > SOL_SANCTUM_RING_MAX)
    count = SOL_SANCTUM_RING_MAX;
  none = 0;
  i = none;
  if (count != 0) {
    cleared = none;
    do {
      obj = (struct SolSanctumRingObject *)Object_GetById(first);
      {
        u8 *frame = &obj->anim[38];
 
        entry->obj = (struct FieldActor *)obj;
        *frame = cleared;
      }
      obj->state = cleared;
      Engine_ObjectSetBlendMode(Object_GetById(first),
                                OBJECT_BLEND_TRANSLUCENT);
      entry->scale = gSolSanctumRing_MaxScales[i];
      entry->scaleStep = -gSolSanctumRing_ScaleSteps[i];
      entry->timer = 3;
      i++;
      entry++;
      first++;
    } while (i != count);
  }
  list->count = count;
  FieldScheduler_AddCallback(SolSanctum_UpdateRing, TASK_PRIORITY_SCENE);
}