thrash.c

Go to the documentation of this file.

/// @file
/// Thrash, Quick Strike and Vorpal Slash.
/// Part of effect.c, the battle effect object, compiled only through it.
 
#include "../effect_internal.h"
 
/// One 120x120 picture of a flashing strike; two fill work->imageStorage and
/// two more Ram_MapCellBuffer.
#define FLASHING_STRIKE_PICTURE_BYTES (120 * 120)
 
/// The user leaps high at the first target, then a burst of 32 sparks rises
/// beneath it.
///
/// Abilities: Thrash (kind 388).
///
/// The leap takes the user three quarters of the way in 24 steps, starting up
/// at 12.2 pixels a frame (16.16); after 29 frames the spark group plays with
/// effect->variant set to 4, overriding the ability's own.
void BattleFx_RunThrash(struct BattleEffectArgument *effect) {
  BattleMotion_ApproachTargetFar(effect->actor, effect->actors[0], 24, 0xc3333);
  WaitFrames(29);
  effect->variant = 4;
  BattleFx_RunSparkGroups(effect, 2);
}
 
/// The user leaps at the first target, then a burst of 340 sparks rises
/// beneath it and the canvas flashes.
///
/// Abilities: none (kind 387).
///
/// A lower leap than Thrash's (7.2 pixels a frame up), and the spark group
/// after 12 frames with effect->variant set to 3, overriding the ability's
/// own.
void BattleFx_RunSparkApproachVariant3(struct BattleEffectArgument *effect) {
  BattleMotion_ApproachTargetFar(effect->actor, effect->actors[0], 24, 0x73333);
  WaitFrames(12);
  effect->variant = 3;
  BattleFx_RunSparkGroups(effect, 2);
}
 
/// The user leaps at the first target, four pictures flash across the effect
/// layer, then it fills with one colour as the target is struck.
///
/// Abilities: Quick Strike (kind 52).
void BattleFx_RunQuickStrike(struct BattleEffectArgument *effect) {
  BattleFx_RunFlashingStrike(effect, 1);
}
 
/// The user steps up to the first target, four pictures flash across the
/// effect layer, then it fills with one colour as the target is struck.
///
/// Abilities: Vorpal Slash (kind 65).
void BattleFx_RunVorpalSlash(struct BattleEffectArgument *effect) {
  BattleFx_RunFlashingStrike(effect, 2);
}
 
/// Plays a flashing strike, the runner of BattleFx_RunQuickStrike (mode 1)
/// and BattleFx_RunVorpalSlash (mode 2); nothing passes mode 0.
///
/// The user steps up to the first target over 16 frames. Then four 120x120
/// pictures show for four frames each (mirrored when effect->side is 1), the
/// canvas fills with colour 0x3f on frames 16 to 19, the battle shows the
/// damage on frame 18, and on frame 20 the target reels and the screen
/// shakes. 21 frames.
///
/// Opens and closes the canvas layer; the pictures take work->imageStorage
/// and the start of Ram_MapCellBuffer.
///
/// mode: picks the pictures (RevealMaskE and F for 0, C and D for 1, A and B
/// for 2); mode 1 also makes the step a hop.
void BattleFx_RunFlashingStrike(struct BattleEffectArgument *effect, s32 mode) {
  void **slots;
  struct BattleEffectWork *work;
  void *canvas;
  DrawRectangle draw[2];
  s32 frame;
 
  slots = gBattleFxWork;
  EFFECT_GET_WORK_AND_CANVAS(slots, work, canvas);
  work->effect = effect;
  BattleFx_BeginCanvasLayer(0);
  REG_BLDCNT = 0;
 
  // Each resource holds two pictures: the first fills work->imageStorage, up
  // to the particles, and the second the start of Ram_MapCellBuffer.
  if (mode == 0) {
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskE, work->imageStorage,
                               1, 0);
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskF, Ram_MapCellBuffer,
                               1, 1);
  } else if (mode == 1) {
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskC, work->imageStorage,
                               1, 0);
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskD, Ram_MapCellBuffer,
                               1, 1);
  } else {
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskA, work->imageStorage,
                               1, 0);
    Resource_LoadAndDecompress((s32)&ResourceId_RevealMaskB, Ram_MapCellBuffer,
                               1, 1);
  }
  EFFECT_START_TRANSFER(work, CANVAS_COPY_AND_CLEAR, 0);
 
  // The step: three quarters of the way in 16 steps, a hop of 8 pixels a
  // frame up for Quick Strike.
  if (mode == 1)
    BattleMotion_ApproachTargetFar(effect->actor, effect->actors[0], 16,
                                   0x80000);
  else
    BattleMotion_ApproachTargetFar(effect->actor, effect->actors[0], 16, 0);
  WaitFrames(16);
 
  if (work->effect->side == 1)
    EFFECT_LOAD_BLITTER(HEAP_SLOT_BLITTER,
                        EFFECT_CLIP_BOUNDS | COMPOSITE_FLIP_X, COMPOSITE_COPY);
  else
    EFFECT_LOAD_BLITTER(HEAP_SLOT_BLITTER, EFFECT_CLIP_BOUNDS, COMPOSITE_COPY);
  draw[0] = (DrawRectangle)gWorkSlot[HEAP_SLOT_BLITTER];
  AudioCommand_PlayFar(SE_212);
  for (frame = 0; frame != 21; frame++) {
    if (frame <= 3)
      draw[0](canvas, work->imageStorage, 0, 0, 120, 120);
    else if (frame <= 7)
      draw[0](canvas, work->imageStorage + FLASHING_STRIKE_PICTURE_BYTES, 0, 0,
              120, 120);
    else if (frame <= 11)
      draw[0](canvas, Ram_MapCellBuffer, 0, 0, 120, 120);
    else if (frame <= 15)
      draw[0](canvas, Ram_MapCellBuffer + FLASHING_STRIKE_PICTURE_BYTES, 0, 0,
              120, 120);
    if (frame >= 16 && frame <= 19)
      Iwram_FillWords(canvas, CANVAS_BYTES, 0x3f3f3f3f);
    if (frame == 18)
      EFFECT_SHOW_DAMAGE(SE_HEAVY_IMPACT);
    if (frame == 20) {
      work->shakeFrames = 8;
      BattleMotion_ApplyVariantMotionFar(work->effect->actors[0], 4);
    }
    Camera_ApplyShake(16, 16);
    EFFECT_END_FRAME(work);
  }
  // Releases the blitter before stopping the transfer, the other way round
  // from EFFECT_FINISH_CANVAS_ONE_BLITTER.
  Runtime_ReleaseHeapBlock(HEAP_SLOT_BLITTER);
  Scheduler_RemoveCallback(BattleFx_ProcessPendingGraphicsTransfer);
  BattleFx_EndCanvasLayer();
}
 
#undef FLASHING_STRIKE_PICTURE_BYTES