1A5830.c File Reference

Go to the source code of this file.

Functions
s32	has_enchanted_part (Actor *actor)
void	dispatch_event_general (Actor *actor, s32 event)
void	play_hit_sound (Actor *actor, f32 x, f32 y, f32 z, u32 hitSound)
void	dispatch_event_actor (Actor *actor, s32 event)
HitResult	calc_enemy_test_target (Actor *actor)
HitResult	calc_enemy_damage_target (Actor *attacker)
s32	dispatch_damage_event_actor (Actor *actor, s32 damageAmount, s32 originalEvent, s32 stopMotion)
s32	dispatch_damage_event_actor_0 (Actor *actor, s32 damageAmount, s32 event)
s32	dispatch_damage_event_actor_1 (Actor *actor, s32 damageAmount, s32 event)
f32	update_lerp_battle (s32 easing, f32 start, f32 end, s32 elapsed, s32 duration)

Variables
s32	StarPointMultiplier []
	Star Point multiplier, indexed by actor count.

Function Documentation

has_enchanted_part()

s32 has_enchanted_part

(

Actor *

actor

)

Definition at line 8 of file 1A5830.c.

                                     {
    ActorPart* partIt = actor->partsTable;
    s32 ret = FALSE;
 
    while (partIt != NULL) {
        if (partIt->eventFlags & (ACTOR_EVENT_FLAG_ENCHANTED | ACTOR_EVENT_FLAG_STAR_ROD_ENCHANTED)) {
            ret = TRUE;
            break;
        } else {
            partIt = partIt->nextPart;
        }
    }
 
    return ret;
}

Referenced by calc_enemy_damage_target().

dispatch_event_general()

void dispatch_event_general	(	Actor *	actor,
		s32	event )

Definition at line 24 of file 1A5830.c.

                                                     {
    switch (actor->actorID & ACTOR_CLASS_MASK) {
        case ACTOR_CLASS_PLAYER:
            dispatch_event_player(event);
            break;
        case ACTOR_CLASS_PARTNER:
            dispatch_event_partner(event);
            break;
        case ACTOR_CLASS_ENEMY:
            dispatch_event_actor(actor, event);
            break;
    }
}

Referenced by calc_enemy_damage_target(), and calc_enemy_test_target().

play_hit_sound()

void play_hit_sound	(	Actor *	actor,
		f32	x,
		f32	y,
		f32	z,
		u32	hitSound )

Definition at line 38 of file 1A5830.c.

                                                                     {
    s32 actorClass = actor->actorID & ACTOR_CLASS_MASK;
 
    switch (hitSound) {
        case HIT_SOUND_MISS:
            sfx_play_sound_at_position(SOUND_IMMUNE, SOUND_SPACE_DEFAULT, x, y, z);
            break;
        case HIT_SOUND_BONES:
            sfx_play_sound_at_position(SOUND_HIT_BONES, SOUND_SPACE_DEFAULT, x, y, z);
            break;
        case HIT_SOUND_NORMAL:
            switch (actorClass) {
                case ACTOR_CLASS_PLAYER:
                    sfx_play_sound_at_position(SOUND_HIT_PLAYER_NORMAL, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_PARTNER:
                    sfx_play_sound_at_position(SOUND_HIT_NORMAL, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_ENEMY:
                    sfx_play_sound_at_position(SOUND_HIT_NORMAL, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
            }
            break;
        case HIT_SOUND_FIRE:
            switch (actorClass) {
                case ACTOR_CLASS_PLAYER:
                    sfx_play_sound_at_position(SOUND_HIT_PLAYER_FIRE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_PARTNER:
                    sfx_play_sound_at_position(SOUND_HIT_FIRE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_ENEMY:
                    sfx_play_sound_at_position(SOUND_HIT_FIRE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
            }
            break;
        case HIT_SOUND_ICE:
            switch (actorClass) {
                case ACTOR_CLASS_PLAYER:
                    sfx_play_sound_at_position(SOUND_HIT_PLAYER_ICE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_PARTNER:
                    sfx_play_sound_at_position(SOUND_HIT_ICE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_ENEMY:
                    sfx_play_sound_at_position(SOUND_HIT_ICE, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
            }
            break;
        case HIT_SOUND_SHOCK:
            switch (actorClass) {
                case ACTOR_CLASS_PLAYER:
                    sfx_play_sound_at_position(SOUND_HIT_PLAYER_SHOCK, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_PARTNER:
                    sfx_play_sound_at_position(SOUND_HIT_SHOCK, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
                case ACTOR_CLASS_ENEMY:
                    sfx_play_sound_at_position(SOUND_HIT_SHOCK, SOUND_SPACE_DEFAULT, x, y, z);
                    break;
            }
            break;
    }
}

Referenced by calc_enemy_damage_target().

dispatch_event_actor()

void dispatch_event_actor	(	Actor *	actor,
		s32	event )

Definition at line 103 of file 1A5830.c.

                                                   {
    Evt* handleEventScript = actor->handleEventScript;
    s32 onHitID = actor->handleEventScriptID;
 
    if (actor->handleEventSource != NULL) {
        Evt* newScript;
 
        actor->lastEventType = event;
        newScript = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
        actor->handleEventScript = newScript;
        actor->handleEventScriptID = newScript->id;
        newScript->owner1.actorID = actor->actorID;
    }
 
    if (actor->takeTurnScript != NULL) {
        get_script_by_index(actor->takeTurnScriptID);
        kill_script_by_ID(actor->takeTurnScriptID);
        actor->takeTurnScript = NULL;
    }
 
    if (handleEventScript != NULL) {
        kill_script_by_ID(onHitID);
    }
}

Referenced by btl_state_update_9(), calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_partner_test_enemy(), calc_player_damage_enemy(), calc_player_test_enemy(), dispatch_damage_event_actor(), and dispatch_event_general().

calc_enemy_test_target()

HitResult calc_enemy_test_target

(

Actor *

actor

)

Definition at line 128 of file 1A5830.c.

                                               {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    s32 targetID = battleStatus->curTargetID;
    s32 targetPartIdx = battleStatus->curTargetPart;
    Actor* target;
    Actor* target2;
    ActorPart* targetPart;
    s32 actorClass;
    s32 hitResult;
 
    battleStatus->curTargetID2 = battleStatus->curTargetID;
    battleStatus->curTargetPart2 = battleStatus->curTargetPart;
 
    target = get_actor(targetID);
    if (target == NULL) {
        return HIT_RESULT_HIT;
    }
 
    targetPart = get_actor_part(target, targetPartIdx);
    ASSERT(targetPart != NULL);
 
    actorClass = targetID & ACTOR_CLASS_MASK;
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            target->curHP = playerData->curHP;
            break;
        case ACTOR_CLASS_PARTNER:
            target->curHP = 127;
            break;
        case ACTOR_CLASS_ENEMY:
            break;
    }
 
    if (battleStatus->curAttackElement & DAMAGE_TYPE_TRIGGER_LUCKY) {
        dispatch_event_general(target, EVENT_LUCKY);
        return HIT_RESULT_HIT;
    }
 
    hitResult = HIT_RESULT_HIT;
    target2 = target;
    if (targetPart->eventFlags & ACTOR_EVENT_FLAG_ILLUSORY || battleStatus->outtaSightActive || target2->transparentStatus == STATUS_KEY_TRANSPARENT) {
        if (!(battleStatus->curAttackElement & DAMAGE_TYPE_MAGIC)) {
            hitResult = HIT_RESULT_MISS;
        }
    }
 
    if (hitResult == HIT_RESULT_MISS) {
        return HIT_RESULT_MISS;
    }
    hitResult = HIT_RESULT_HIT;
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            if (battleStatus->cloudNineTurnsLeft) {
                if (rand_int(100) < battleStatus->cloudNineDodgeChance) {
                    hitResult = HIT_RESULT_MISS;
                    break;
                }
            } else {
                if (player_team_is_ability_active(target2, ABILITY_PRETTY_LUCKY)) {
                    if (rand_int(100) < 10) {
                        hitResult = HIT_RESULT_LUCKY;
                        break;
                    }
                }
                if (player_team_is_ability_active(target2, ABILITY_CLOSE_CALL) && (target2->curHP < 6)) {
                    if (rand_int(100) < 30) {
                        hitResult = HIT_RESULT_LUCKY;
                        break;
                    }
                }
                if (player_team_is_ability_active(target2, ABILITY_LUCKY_DAY)) {
                    if (rand_int(100) < 20) {
                        hitResult = HIT_RESULT_LUCKY;
                        break;
                    }
                }
            }
            break;
        case ACTOR_CLASS_PARTNER:
            break;
        case ACTOR_CLASS_ENEMY:
            break;
    }
 
    if (hitResult == HIT_RESULT_MISS) {
        return HIT_RESULT_MISS;
    }
 
    if (hitResult == HIT_RESULT_LUCKY) {
        return HIT_RESULT_LUCKY;
    }
 
    if (target2->stoneStatus == STATUS_KEY_STONE) {
        return HIT_RESULT_IMMUNE;
    }
 
    if (target2->staticStatus == STATUS_KEY_STATIC) {
        return HIT_RESULT_HIT_STATIC;
    }
 
    return HIT_RESULT_HIT;
}

calc_enemy_damage_target()

HitResult calc_enemy_damage_target

(

Actor *

attacker

)

Bug

? repeated paralyze and dizzy infliction

Definition at line 232 of file 1A5830.c.

                                                    {
    BattleStatus* battleStatus = &gBattleStatus;
    ActorState* state = &attacker->state;
    s32 targetID = battleStatus->curTargetID;
    s32 targetPartIdx = battleStatus->curTargetPart;
    s32 actorClass;
    Actor* target;
    ActorPart* targetPart;
    s32 hitResult;
    s32 one = TRUE;
    s32 statusInflicted = FALSE;
    s32 statusInflicted2 = FALSE;
    s32 isFire = FALSE;
    s32 isWater = FALSE;
    s32 isIce = FALSE;
    s32 isElectric = FALSE;
    s32 madeElectricContact = FALSE;
    s32 isPlayer;
    s32 defense;
    s32 event;
    s32 damage;
    Evt* script;
 
    battleStatus->wasStatusInflicted = FALSE;
    battleStatus->lastAttackDamage = 0;
 
    battleStatus->attackerActorID = attacker->actorID;
    battleStatus->curTargetID2 = targetID;
    battleStatus->curTargetPart2 = targetPartIdx;
 
    target = get_actor(targetID);
    if (target == NULL) {
        return HIT_RESULT_HIT;
    }
 
    targetPart = get_actor_part(target, targetPartIdx);
    ASSERT(targetPart != NULL);
 
    actorClass = targetID & ACTOR_CLASS_MASK;
    target->lastDamageTaken = 0;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            target->curHP = gPlayerData.curHP;
            break;
        case ACTOR_CLASS_PARTNER:
            target->curHP = 127;
            break;
        case ACTOR_CLASS_ENEMY:
            break;
    }
 
    // handle defender status
 
    if (targetPart->eventFlags & ACTOR_EVENT_FLAG_ILLUSORY) {
        return HIT_RESULT_MISS;
    }
 
    if (target->transparentStatus == STATUS_KEY_TRANSPARENT
        || (targetPart->eventFlags & ACTOR_EVENT_FLAG_BURIED && !(battleStatus->curAttackElement & DAMAGE_TYPE_QUAKE))
    ) {
        return HIT_RESULT_MISS;
    }
 
    if (target->stoneStatus == STATUS_KEY_STONE) {
        show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, -1);
        show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 0);
        play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 0);
        dispatch_event_general(target, EVENT_IMMUNE);
        return HIT_RESULT_HIT;
    }
 
    // handle attack element
 
    if (battleStatus->curAttackElement & DAMAGE_TYPE_BLAST) {
        if (!(battleStatus->curAttackElement & DAMAGE_TYPE_NO_CONTACT)
            && (targetPart->eventFlags & ACTOR_EVENT_FLAG_EXPLODE_ON_IGNITION)
        ) {
            play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 3);
            dispatch_event_general(target, EVENT_EXPLODE_TRIGGER);
            return HIT_RESULT_BACKFIRE;
        }
    }
    if ((battleStatus->curAttackElement & DAMAGE_TYPE_QUAKE) && (target->flags & ACTOR_FLAG_FLYING)) {
        play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 1);
        return HIT_RESULT_NO_DAMAGE;
    }
    if (battleStatus->curAttackElement & DAMAGE_TYPE_FIRE) {
        fx_ring_blast(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f, 1.0f, 24);
        isFire = TRUE;
    }
    if (battleStatus->curAttackElement & DAMAGE_TYPE_SHOCK) {
        apply_shock_effect(target);
        isElectric = TRUE;
    }
    if (battleStatus->curAttackElement & DAMAGE_TYPE_WATER) {
        fx_water_splash(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f, 1.0f, 24);
        isWater = TRUE;
    }
    if (battleStatus->curAttackElement & DAMAGE_TYPE_ICE) {
        fx_big_snowflakes(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f);
        isIce = TRUE;
    }
 
    if (!(attacker->staticStatus == STATUS_KEY_STATIC)
        && ((target->staticStatus == STATUS_KEY_STATIC) || (targetPart->eventFlags & ACTOR_EVENT_FLAG_ELECTRIFIED))
        && !(battleStatus->curAttackElement & (DAMAGE_TYPE_SHOCK | DAMAGE_TYPE_NO_CONTACT))
        && !(battleStatus->curAttackEventSuppression & SUPPRESS_EVENT_SHOCK_CONTACT)
        && !has_enchanted_part(attacker)) // enchanted attacks ignore electrified defenders
    {
        madeElectricContact = TRUE;
        gBattleStatus.flags1 |= BS_FLAGS1_TRIGGER_EVENTS;
    }
 
    // ------------------------------------------------------------------------
    // damage calculation
 
    gBattleStatus.flags1 &= ~BS_FLAGS1_ATK_BLOCKED;
 
    // determine target defense
 
    defense = get_defense(target, targetPart->defenseTable, battleStatus->curAttackElement);
 
    if (!(battleStatus->curAttackElement & DAMAGE_TYPE_IGNORE_DEFENSE)) {
        defense += target->defenseBoost;
 
        if (actorClass == ACTOR_CLASS_PLAYER) {
            if (battleStatus->waterBlockTurnsLeft > 0) {
                if ((battleStatus->curAttackElement & (DAMAGE_TYPE_BLAST | DAMAGE_TYPE_FIRE))) {
                    defense += 2;
                } else {
                    defense += 1;
                }
            }
 
            if (gBattleStatus.flags1 & BS_FLAGS1_PLAYER_DEFENDING) {
                defense += 1;
            }
        }
    }
 
    // apply attacker damage modifiers
 
    damage = battleStatus->curAttackDamage;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            damage -= battleStatus->merleeDefenseBoost;
            break;
        case ACTOR_CLASS_PARTNER:
        case ACTOR_CLASS_ENEMY:
            break;
    }
 
    damage += attacker->attackBoost;
 
    if (attacker->chillOutTurns != 0) {
        damage -= attacker->chillOutAmount;
    }
 
    if (attacker->debuff == STATUS_KEY_SHRINK) {
        if (damage > 0) {
            damage /= 2;
        }
    }
 
    if (damage > 99) {
        damage = 99;
    }
    if (damage < 1) {
        defense = 0;
    }
 
    target->hpChangeCounter = 0;
    damage -= defense;
 
    // apply damage mitigation from defensive badges
 
    isPlayer = actorClass == ACTOR_CLASS_PLAYER;
    if (isPlayer) {
        if (player_team_is_ability_active(target, ABILITY_FIRE_SHIELD)) {
            if (battleStatus->curAttackElement & DAMAGE_TYPE_FIRE) {
                damage--;
            }
        }
 
        damage -= player_team_is_ability_active(target, ABILITY_DEFEND_PLUS);
        damage -= player_team_is_ability_active(target, ABILITY_P_DOWN_D_UP);
        damage += player_team_is_ability_active(target, ABILITY_P_UP_D_DOWN);
 
        if (target->curHP <= 5) {
            if (player_team_is_ability_active(target, ABILITY_LAST_STAND)) {
                damage /= 2;
            }
        }
    }
 
    // apply damage mitigation from blocking
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            // TODO figure out how to better write target->debuff >= STATUS_KEY_POISON
            if ((target->debuff == 0 || target->debuff >= STATUS_KEY_POISON)
                && (target->stoneStatus == 0)
                && !(battleStatus->curAttackElement & DAMAGE_TYPE_UNBLOCKABLE)
            ) {
                s32 blocked;
 
                if (player_team_is_ability_active(target, ABILITY_BERSERKER)) {
                    blocked = rand_int(1);
                } else {
                    blocked = check_block_input(BUTTON_A);
                }
 
                if (blocked) {
                    damage--;
                    damage -= player_team_is_ability_active(target, ABILITY_DAMAGE_DODGE);
                    sfx_play_sound_at_position(SOUND_DAMAGE_STARS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
                    show_action_rating(ACTION_RATING_NICE, target, state->goalPos.x, state->goalPos.y, state->goalPos.z);
                    gBattleStatus.flags1 |= BS_FLAGS1_ATK_BLOCKED;
                    break;
                }
                func_80266970(target);
            }
            break;
        case ACTOR_CLASS_PARTNER:
            if (target->stoneStatus == 0) {
                if (target->koStatus == 0 && !(battleStatus->curAttackElement & DAMAGE_TYPE_UNBLOCKABLE)) {
                    if (check_block_input(BUTTON_A)) {
                        damage = 0;
                        sfx_play_sound_at_position(SOUND_DAMAGE_STARS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
                        show_action_rating(ACTION_RATING_NICE, target, state->goalPos.x, state->goalPos.y, state->goalPos.z);
                        gBattleStatus.flags1 |= BS_FLAGS1_ATK_BLOCKED;
                        break;
                    }
                    func_80266970(target);
                }
            }
            break;
    }
 
    if (gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS) {
        func_80266970(target);
    }
 
    // deal damage and determine resulting battle event
 
    event = EVENT_HIT_COMBO;
    if (damage < 1) {
        target->hpChangeCounter = 0;
        if (!(battleStatus->curAttackElement & DAMAGE_TYPE_STATUS_ALWAYS_HITS)) {
            hitResult = HIT_RESULT_NO_DAMAGE;
            event = EVENT_ZERO_DAMAGE;
        } else {
            hitResult = HIT_RESULT_NO_DAMAGE;
            event = EVENT_ZERO_DAMAGE;
            if (target->curHP < 1) {
                event = EVENT_DEATH;
            }
        }
        battleStatus->lastAttackDamage = 0;
    } else {
        target->damageCounter += damage;
        target->hpChangeCounter -= damage;
        battleStatus->lastAttackDamage = 0;
        hitResult = HIT_RESULT_HIT;
        if (!(targetPart->flags & ACTOR_PART_FLAG_DAMAGE_IMMUNE)
            && !(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE)
        ) {
            if (!(target->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                target->curHP -= damage;
            }
 
            if (target->curHP < 1) {
                target->curHP = 0;
                event = EVENT_DEATH;
            }
        }
        battleStatus->lastAttackDamage += damage;
        target->lastDamageTaken = battleStatus->lastAttackDamage;
        target->hpChangeCounter = 0;
 
        if (actorClass == ACTOR_CLASS_PLAYER) {
            battleStatus->damageTaken += damage;
            gPlayerData.curHP = target->curHP;
        }
    }
 
    if (gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS) {
        if (event == EVENT_HIT_COMBO) {
            event = EVENT_HIT;
        }
        if (event == EVENT_ZERO_DAMAGE) {
            event = EVENT_IMMUNE;
        }
        if (target->curHP < 1 && event == EVENT_IMMUNE) {
            event = EVENT_DEATH;
        }
    } else if (event == EVENT_DEATH) {
        event = EVENT_HIT_COMBO;
    }
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS)) {
        clear_part_pal_adjustment(targetPart);
    }
 
    if ((gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS)
        && (battleStatus->curAttackElement & (DAMAGE_TYPE_POW | DAMAGE_TYPE_QUAKE | DAMAGE_TYPE_JUMP))
        && (targetPart->eventFlags & ACTOR_EVENT_FLAG_FLIPABLE)
    ) {
        if (event == EVENT_HIT) {
            event = EVENT_FLIP_TRIGGER;
        }
        if (event == EVENT_IMMUNE) {
            event = EVENT_FLIP_TRIGGER;
        }
    }
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS)
        && (battleStatus->curAttackElement & (DAMAGE_TYPE_POW | DAMAGE_TYPE_QUAKE | DAMAGE_TYPE_JUMP))
        && (targetPart->eventFlags & ACTOR_EVENT_FLAG_FLIPABLE)
    ) {
        if (event == EVENT_HIT_COMBO) {
            event = EVENT_FLIP_TRIGGER;
        }
        if (event == EVENT_ZERO_DAMAGE) {
            event = EVENT_FLIP_TRIGGER;
        }
    }
 
    if ((gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS)
        && (battleStatus->curAttackElement & (DAMAGE_TYPE_FIRE | DAMAGE_TYPE_BLAST | DAMAGE_TYPE_4000))
    ) {
        if (event == EVENT_HIT) {
            event = EVENT_BURN_HIT;
        }
        if (event == EVENT_DEATH) {
            event = EVENT_FIRE_DEATH;
        }
        isFire = TRUE;
    }
 
    if (gBattleStatus.flags1 & BS_FLAGS1_ATK_BLOCKED) {
        if (event == EVENT_HIT_COMBO) {
            event = EVENT_18;
        }
        if (event == EVENT_HIT) {
            event = EVENT_BLOCK;
        }
        if (event == EVENT_ZERO_DAMAGE) {
            event = EVENT_18;
        }
        if (event == EVENT_IMMUNE) {
            event = EVENT_BLOCK;
        }
        if (event == EVENT_BURN_HIT) {
            event = EVENT_BLOCK;
        }
    }
 
    // try inflicting status effect
 
    if (gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS
        && battleStatus->lastAttackDamage >= 0
        && event != EVENT_DEATH
        && event != EVENT_SPIN_SMASH_DEATH
        && event != EVENT_EXPLODE_TRIGGER
        && !(gBattleStatus.flags1 & BS_FLAGS1_ATK_BLOCKED)
        && !(gBattleStatus.flags2 & BS_FLAGS2_IS_FIRST_STRIKE)
        && !(actorClass == ACTOR_PLAYER && is_ability_active(ABILITY_HEALTHY_HEALTHY) && (rand_int(100) < 50)))
    {
        if (battleStatus->curAttackStatus & STATUS_FLAG_SHRINK && try_inflict_status(target, STATUS_KEY_SHRINK, STATUS_TURN_MOD_SHRINK)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_POISON && try_inflict_status(target, STATUS_KEY_POISON, STATUS_TURN_MOD_POISON)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_STONE && try_inflict_status(target, STATUS_KEY_STONE, STATUS_TURN_MOD_STONE)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_SLEEP && try_inflict_status(target, STATUS_KEY_SLEEP, STATUS_TURN_MOD_SLEEP)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_DIZZY && try_inflict_status(target, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_STOP && try_inflict_status(target, STATUS_KEY_STOP, STATUS_TURN_MOD_STOP)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_STATIC && try_inflict_status(target, STATUS_KEY_STATIC, STATUS_TURN_MOD_STATIC)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_PARALYZE && try_inflict_status(target, STATUS_KEY_PARALYZE, STATUS_TURN_MOD_PARALYZE)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_FEAR && try_inflict_status(target, STATUS_KEY_FEAR, STATUS_TURN_MOD_FEAR)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
 
        if (battleStatus->curAttackStatus & STATUS_FLAG_PARALYZE && try_inflict_status(target, STATUS_KEY_PARALYZE, STATUS_TURN_MOD_PARALYZE)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
        if (battleStatus->curAttackStatus & STATUS_FLAG_DIZZY && try_inflict_status(target, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
 
        if (battleStatus->curAttackStatus & STATUS_FLAG_FROZEN && target->debuff != STATUS_KEY_FROZEN && try_inflict_status(target, STATUS_KEY_FROZEN, STATUS_TURN_MOD_FROZEN)) {
            statusInflicted = one;
            statusInflicted2 = one;
        }
 
        if (statusInflicted) {
            if (event == EVENT_ZERO_DAMAGE) {
                event = EVENT_HIT_COMBO;
            }
            if (event == EVENT_IMMUNE) {
                event = EVENT_HIT;
            }
        }
    }
 
    // dispatch events and play damage effects
 
    battleStatus->wasStatusInflicted = statusInflicted;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            dispatch_event_player(event);
            break;
        case ACTOR_CLASS_PARTNER:
            dispatch_event_partner(event);
            break;
        case ACTOR_CLASS_ENEMY:
            dispatch_event_actor(target, event);
            break;
    }
 
    if (actorClass == ACTOR_CLASS_PARTNER
        && battleStatus->lastAttackDamage > 0
        && gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS
        && !(target->flags & ACTOR_FLAG_NO_DMG_APPLY))
    {
        inflict_partner_ko(target, STATUS_KEY_DAZE, battleStatus->lastAttackDamage);
    }
 
    if (!(target->flags & ACTOR_FLAG_NO_DMG_POPUP)) {
        switch (actorClass) {
            case ACTOR_CLASS_PLAYER:
            case ACTOR_CLASS_PARTNER:
                if (battleStatus->lastAttackDamage == 0) {
                    if (!statusInflicted2 && !statusInflicted) {
                        // immune star fx?
                        show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, -3);
                    }
                } else if (battleStatus->curAttackElement & (DAMAGE_TYPE_MULTIPLE_POPUPS | DAMAGE_TYPE_SMASH)) {
                    show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 1);
                    show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
                } else {
                    show_primary_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 1);
                    show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
                    break;
                }
                break;
            case ACTOR_CLASS_ENEMY:
                if (battleStatus->lastAttackDamage == 0) {
                    if (!statusInflicted2 && !statusInflicted) {
                        show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, 3);
                    }
                } else if (battleStatus->curAttackElement & (DAMAGE_TYPE_MULTIPLE_POPUPS | DAMAGE_TYPE_SMASH)) {
                    show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
                    show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
                } else {
                    show_primary_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
                    show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
                }
                break;
        }
    }
 
    if (battleStatus->lastAttackDamage > 0) {
        u32 hitSound;
 
        set_actor_flash_mode(target, 1);
 
        if (attacker->actorTypeData1[5] != SOUND_NONE) {
            sfx_play_sound_at_position(attacker->actorTypeData1[5], SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
        }
 
        if (isFire) {
            hitSound = HIT_SOUND_FIRE;
        } else if (!isElectric) {
            hitSound = HIT_SOUND_NORMAL;
        } else {
            hitSound = HIT_SOUND_SHOCK;
        }
 
        play_hit_sound(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, hitSound);
    }
 
    if ((battleStatus->lastAttackDamage < 1 && !statusInflicted2 && !madeElectricContact) || targetPart->flags & ACTOR_PART_FLAG_DAMAGE_IMMUNE) {
        sfx_play_sound_at_position(SOUND_IMMUNE, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
 
    if ((battleStatus->curAttackStatus & STATUS_FLAG_SLEEP) && statusInflicted) {
        script = start_script(&EVS_PlaySleepHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        sfx_play_sound_at_position(SOUND_INFLICT_SLEEP, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_DIZZY) && statusInflicted) {
        script = start_script(&EVS_PlayDizzyHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        sfx_play_sound_at_position(SOUND_INFLICT_STATUS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_PARALYZE) && statusInflicted) {
        script = start_script(&EVS_PlayParalyzeHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        sfx_play_sound_at_position(SOUND_INFLICT_STATUS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_POISON) && statusInflicted) {
        script = start_script(&EVS_PlayPoisonHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        sfx_play_sound_at_position(SOUND_INFLICT_STATUS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_STOP) && statusInflicted) {
        script = start_script(&EVS_PlayStopHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        sfx_play_sound_at_position(SOUND_INFLICT_STATUS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_FROZEN) && statusInflicted) {
        script = start_script(&EVS_PlayFreezeHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        script->varTablePtr[3] = target;
        sfx_play_sound_at_position(SOUND_HIT_ICE, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
    if ((battleStatus->curAttackStatus & STATUS_FLAG_SHRINK) && statusInflicted) {
        script = start_script(&EVS_PlayShrinkHitFX, EVT_PRIORITY_A, 0);
        script->varTable[0] = state->goalPos.x;
        script->varTable[1] = state->goalPos.y;
        script->varTable[2] = state->goalPos.z;
        script->varTablePtr[3] = target;
        sfx_play_sound_at_position(SOUND_INFLICT_STATUS, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
 
    if ((battleStatus->curAttackElement & DAMAGE_TYPE_SMASH) && target->actorType == ACTOR_TYPE_GOOMNUT_TREE) {
        sfx_play_sound_at_position(SOUND_SMACK_TREE, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
    }
 
    show_actor_health_bar(target);
 
    if (attacker->staticStatus != STATUS_KEY_STATIC
        && (target->staticStatus == STATUS_KEY_STATIC || targetPart->eventFlags & ACTOR_EVENT_FLAG_ELECTRIFIED)
        && !(battleStatus->curAttackElement & DAMAGE_TYPE_NO_CONTACT)
        && !(battleStatus->curAttackEventSuppression & SUPPRESS_EVENT_SHOCK_CONTACT)
        && (attacker->transparentStatus != STATUS_KEY_TRANSPARENT)
        && !has_enchanted_part(attacker))
    {
        sfx_play_sound_at_position(SOUND_HIT_SHOCK, SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
        apply_shock_effect(attacker);
        dispatch_damage_event_actor_1(attacker, 1, EVENT_SHOCK_HIT);
        return HIT_RESULT_BACKFIRE;
    }
 
    return hitResult;
}

dispatch_damage_event_actor()

s32 dispatch_damage_event_actor	(	Actor *	actor,
		s32	damageAmount,
		s32	originalEvent,
		s32	stopMotion )

Definition at line 821 of file 1A5830.c.

                                                                                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    ActorState* state = &actor->state;
    s32 dispatchEvent = originalEvent;
    s32 currentAttackDamage;
    s32 hpChangeCounter;
    s32 hpChange;
    s32 flagCheck;
    s32 new_var;
 
    battleStatus->curAttackDamage = damageAmount;
    hpChange = (s16) damageAmount;
    actor->hpChangeCounter += hpChange;
    new_var = actor->hpChangeCounter;
    hpChange = new_var;
    actor->damageCounter += hpChange;
    actor->hpChangeCounter -= hpChange;
    battleStatus->lastAttackDamage = 0;
    actor->curHP -= hpChange;
 
    if (actor->curHP <= 0) {
        dispatchEvent = EVENT_DEATH;
        battleStatus->lastAttackDamage += actor->curHP;
        actor->curHP = 0;
    }
 
    battleStatus->lastAttackDamage += hpChange;
    actor->lastDamageTaken = battleStatus->lastAttackDamage;
    battleStatus->curDamageSource = DMG_SRC_DEFAULT;
    if (battleStatus->flags1 & BS_FLAGS1_TRIGGER_EVENTS) {
        if (dispatchEvent == EVENT_HIT_COMBO) {
            dispatchEvent = EVENT_HIT;
        }
        if (dispatchEvent == EVENT_ZERO_DAMAGE) {
            dispatchEvent = EVENT_IMMUNE;
        }
    }
    if (dispatchEvent == EVENT_DEATH) {
        if (originalEvent == EVENT_SPIN_SMASH_LAUNCH_HIT) {
            dispatchEvent = EVENT_SPIN_SMASH_LAUNCH_DEATH;
        }
        if (originalEvent == EVENT_SHOCK_HIT) {
            dispatchEvent = EVENT_SHOCK_DEATH;
        }
    }
 
    if (!stopMotion) {
        s32 savedTargetActorID = actor->targetActorID;
 
        if (func_80263230(actor, actor) != 0) {
            show_next_damage_popup(actor->targetData[0].truePos.x, actor->targetData[0].truePos.y, actor->targetData[0].truePos.z, battleStatus->lastAttackDamage, 0);
            show_damage_fx(actor, actor->targetData[0].truePos.x, actor->targetData[0].truePos.y, actor->targetData[0].truePos.z, battleStatus->lastAttackDamage);
        }
        actor->targetActorID = savedTargetActorID;
 
    } else {
        show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
        show_damage_fx(actor, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
    }
 
    if (battleStatus->lastAttackDamage > 0) {
        set_actor_flash_mode(actor, 1);
    }
    actor->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
    dispatch_event_actor(actor, dispatchEvent);
    return 0;
}

Referenced by dispatch_damage_event_actor_0(), and dispatch_damage_event_actor_1().

dispatch_damage_event_actor_0()

s32 dispatch_damage_event_actor_0	(	Actor *	actor,
		s32	damageAmount,
		s32	event )

Definition at line 889 of file 1A5830.c.

                                                                             {
    return dispatch_damage_event_actor(actor, damageAmount, event, FALSE);
}

Referenced by btl_state_update_9().

dispatch_damage_event_actor_1()

s32 dispatch_damage_event_actor_1	(	Actor *	actor,
		s32	damageAmount,
		s32	event )

Definition at line 893 of file 1A5830.c.

                                                                             {
    return dispatch_damage_event_actor(actor, damageAmount, event, TRUE);
}

Referenced by calc_enemy_damage_target().

update_lerp_battle()

f32 update_lerp_battle	(	s32	easing,
		f32	start,
		f32	end,
		s32	elapsed,
		s32	duration )

Definition at line 2093 of file 1A5830.c.

                                                                                  {
    s32 timeLeft;
    f32 absMag;
    f64 start1;
    f64 start2;
    f32 len1;
    f32 len2;
    f32 len3;
    f32 len4;
    f64 len5;
    f32 len6;
    f64 len7;
 
    switch (easing) {
        case EASING_LINEAR:
            return start + (end - start) * elapsed / duration;
        case EASING_QUADRATIC_IN:
            return start + SQ(elapsed) * (end - start) / SQ(duration);
        case EASING_CUBIC_IN:
            return start + CUBE(elapsed) * (end - start) / CUBE(duration);
        case EASING_QUARTIC_IN:
            return start + QUART(elapsed) * (end - start) / QUART(duration);
        case EASING_COS_SLOW_OVERSHOOT:
            len1 = end - start;
            return end - (len1 * cos_rad(((f32)elapsed / duration) * PI_D * 4.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_COS_FAST_OVERSHOOT:
            len2 = end - start;
            return end - (len2 * cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 15.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_QUADRATIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((SQ(timeLeft) * (end - start))) / SQ(duration);
        case EASING_CUBIC_OUT:
            len3 = end - start;
            timeLeft = duration - elapsed;
            return start + len3 - ((CUBE(timeLeft) * len3)) / CUBE(duration);
        case EASING_QUARTIC_OUT:
            len4 = end - start;
            timeLeft = duration - elapsed;
            return start + len4 - ((QUART(timeLeft) * len4)) / QUART(duration);
        case EASING_COS_BOUNCE:
            absMag = cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 40.0) * (duration - elapsed) *
                    (duration - elapsed) / SQ((f32)duration);
            if (absMag < 0.0f) {
                absMag = -absMag;
            }
            return end - (end - start) * absMag;
        case EASING_COS_IN_OUT:
            len5 = end - start;
            start1 = start;
            return start1 + (len5 * (1.0 - cos_rad(((f32)elapsed * PI_D) / (f32)duration)) / 2);
        case EASING_SIN_OUT:
            len6 = end - start;
            return start + (len6 * sin_rad((((f32) elapsed) * (PI_D / 2)) / ((f32) duration)));
        case EASING_COS_IN:
            len7 = end - start;
            start2 = start;
            return start2 + (len7 * (1.0 - cos_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration)));
    }
 
    return 0.0f;
}

Variable Documentation

StarPointMultiplier

s32 StarPointMultiplier[]

Initial value:

= {
    100, 100, 100,
    110,
    130, 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
}

Star Point multiplier, indexed by actor count.

+10% multiplier for three actors +30% multiplier for four or more actors

Definition at line 2704 of file 1A5830.c.

                            {
    100, 100, 100,
    110,
    130, 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
};