Paper Mario DX
Paper Mario (N64) modding
 
Loading...
Searching...
No Matches
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 7 of file 1A5830.c.

7 {
9 s32 ret = FALSE;
10
11 while (partIt != NULL) {
13 ret = TRUE;
14 break;
15 } else {
17 }
18 }
19
20 return ret;
21}
BSS s32 PopupMenu_SelectedIndex
struct ActorPart * partsTable
struct ActorPart * nextPart
@ ACTOR_EVENT_FLAG_STAR_ROD_ENCHANTED
Actor glows and listens for Star Beam and Peach Beam events.
Definition enums.h:3386
@ ACTOR_EVENT_FLAG_ENCHANTED
Actor glows and listens for the Star Beam event.
Definition enums.h:3385

Referenced by calc_enemy_damage_target().

◆ dispatch_event_general()

void dispatch_event_general ( Actor * actor,
s32 event )

Definition at line 23 of file 1A5830.c.

23 {
24 switch (actor->actorID & ACTOR_CLASS_MASK) {
27 break;
30 break;
33 break;
34 }
35}
void dispatch_event_actor(Actor *actor, s32 event)
Definition 1A5830.c:102
@ ACTOR_CLASS_ENEMY
Definition enums.h:2079
@ ACTOR_CLASS_PLAYER
Definition enums.h:2077
@ ACTOR_CLASS_PARTNER
Definition enums.h:2078
@ ACTOR_CLASS_MASK
Definition enums.h:2080
void dispatch_event_player(s32)
Definition dmg_player.c:131
void dispatch_event_partner(s32)
Definition dmg_partner.c:7

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 37 of file 1A5830.c.

37 {
38 s32 actorClass = actor->actorID & ACTOR_CLASS_MASK;
39
40 switch (hitSound) {
41 case HIT_SOUND_MISS:
43 break;
44 case HIT_SOUND_BONES:
46 break;
48 switch (actorClass) {
51 break;
54 break;
57 break;
58 }
59 break;
60 case HIT_SOUND_FIRE:
61 switch (actorClass) {
64 break;
67 break;
70 break;
71 }
72 break;
73 case HIT_SOUND_ICE:
74 switch (actorClass) {
77 break;
80 break;
83 break;
84 }
85 break;
86 case HIT_SOUND_SHOCK:
87 switch (actorClass) {
90 break;
93 break;
96 break;
97 }
98 break;
99 }
100}
#define sfx_play_sound_at_position
@ HIT_SOUND_NORMAL
Definition enums.h:2187
@ HIT_SOUND_FIRE
Definition enums.h:2188
@ HIT_SOUND_SHOCK
Definition enums.h:2190
@ HIT_SOUND_BONES
Definition enums.h:2186
@ HIT_SOUND_ICE
Definition enums.h:2189
@ HIT_SOUND_MISS
Definition enums.h:2185
@ SOUND_IMMUNE
Definition enums.h:745
@ SOUND_HIT_PLAYER_ICE
Definition enums.h:721
@ SOUND_HIT_PLAYER_SHOCK
Definition enums.h:1194
@ SOUND_HIT_PLAYER_FIRE
Definition enums.h:720
@ SOUND_HIT_NORMAL
Definition enums.h:724
@ SOUND_HIT_SHOCK
Definition enums.h:1195
@ SOUND_HIT_ICE
Definition enums.h:726
@ SOUND_HIT_FIRE
Definition enums.h:725
@ SOUND_HIT_BONES
Definition enums.h:746
@ SOUND_HIT_PLAYER_NORMAL
Definition enums.h:719
@ SOUND_SPACE_DEFAULT
Definition enums.h:1737

Referenced by calc_enemy_damage_target().

◆ dispatch_event_actor()

void dispatch_event_actor ( Actor * actor,
s32 event )

Definition at line 102 of file 1A5830.c.

102 {
103 Evt* handleEventScript = actor->handleEventScript;
104 s32 onHitID = actor->handleEventScriptID;
105
106 if (actor->handleEventSource != NULL) {
107 Evt* newScript;
108
109 actor->lastEventType = event;
112 actor->handleEventScriptID = newScript->id;
113 newScript->owner1.actorID = actor->actorID;
114 }
115
116 if (actor->takeTurnScript != NULL) {
119 actor->takeTurnScript = NULL;
120 }
121
122 if (handleEventScript != NULL) {
124 }
125}
struct Evt * takeTurnScript
EvtScript * handleEventSource
struct Evt * handleEventScript
s32 takeTurnScriptID
s32 handleEventScriptID
@ EVT_PRIORITY_A
Definition evt.h:153
@ EVT_FLAG_RUN_IMMEDIATELY
don't wait for next update_scripts call
Definition evt.h:161
Evt * get_script_by_index(s32 index)
Evt * start_script(EvtScript *source, s32 priority, s32 initialState)
void kill_script_by_ID(s32 id)

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 127 of file 1A5830.c.

127 {
131 s32 targetPartIdx = battleStatus->curTargetPart;
132 Actor* target;
133 Actor* target2;
135 s32 actorClass;
136 s32 hitResult;
137
138 battleStatus->curTargetID2 = battleStatus->curTargetID;
139 battleStatus->curTargetPart2 = battleStatus->curTargetPart;
140
142 if (target == NULL) {
143 return HIT_RESULT_HIT;
144 }
145
148
150 switch (actorClass) {
152 target->curHP = playerData->curHP;
153 break;
155 target->curHP = 127;
156 break;
158 break;
159 }
160
161 if (battleStatus->curAttackElement & DAMAGE_TYPE_TRIGGER_LUCKY) {
163 return HIT_RESULT_HIT;
164 }
165
167 target2 = target;
168 if (targetPart->eventFlags & ACTOR_EVENT_FLAG_ILLUSORY || battleStatus->outtaSightActive || target2->transparentStatus == STATUS_KEY_TRANSPARENT) {
169 if (!(battleStatus->curAttackElement & DAMAGE_TYPE_MAGIC)) {
171 }
172 }
173
174 if (hitResult == HIT_RESULT_MISS) {
175 return HIT_RESULT_MISS;
176 }
178 switch (actorClass) {
180 if (battleStatus->cloudNineTurnsLeft) {
181 if (rand_int(100) < battleStatus->cloudNineDodgeChance) {
183 break;
184 }
185 } else {
187 if (rand_int(100) < 10) {
189 break;
190 }
191 }
193 if (rand_int(100) < 30) {
195 break;
196 }
197 }
199 if (rand_int(100) < 20) {
201 break;
202 }
203 }
204 }
205 break;
207 break;
209 break;
210 }
211
212 if (hitResult == HIT_RESULT_MISS) {
213 return HIT_RESULT_MISS;
214 }
215
217 return HIT_RESULT_LUCKY;
218 }
219
220 if (target2->stoneStatus == STATUS_KEY_STONE) {
221 return HIT_RESULT_IMMUNE;
222 }
223
224 if (target2->staticStatus == STATUS_KEY_STATIC) {
226 }
227
228 return HIT_RESULT_HIT;
229}
void dispatch_event_general(Actor *actor, s32 event)
Definition 1A5830.c:23
#define rand_int
#define ASSERT(condition)
@ ACTOR_EVENT_FLAG_ILLUSORY
Player attacks pass through and miss.
Definition enums.h:3374
@ STATUS_KEY_TRANSPARENT
Definition enums.h:2210
@ STATUS_KEY_STATIC
Definition enums.h:2207
@ STATUS_KEY_STONE
Definition enums.h:2208
@ HIT_RESULT_HIT_STATIC
Definition enums.h:1957
@ HIT_RESULT_HIT
Definition enums.h:1950
@ HIT_RESULT_LUCKY
Definition enums.h:1955
@ HIT_RESULT_IMMUNE
Definition enums.h:1958
@ HIT_RESULT_MISS
Definition enums.h:1956
@ ABILITY_CLOSE_CALL
Definition enums.h:469
@ ABILITY_LUCKY_DAY
Definition enums.h:471
@ ABILITY_PRETTY_LUCKY
Definition enums.h:444
@ EVENT_LUCKY
Definition enums.h:2172
@ DAMAGE_TYPE_MAGIC
Definition enums.h:2855
@ DAMAGE_TYPE_TRIGGER_LUCKY
Definition enums.h:2881
s32 player_team_is_ability_active(Actor *actor, s32 ability)
Definition 190B20.c:2765
ActorPart * get_actor_part(Actor *actor, s32 partID)
Definition 190B20.c:1191
Actor * get_actor(s32 actorID)
Definition actor_api.c:155
PlayerData gPlayerData
Definition 77480.c:39
BattleStatus gBattleStatus
Definition battle.cpp:13

◆ calc_enemy_damage_target()

HitResult calc_enemy_damage_target ( Actor * attacker)
Bug
? repeated paralyze and dizzy infliction

Definition at line 231 of file 1A5830.c.

231 {
233 ActorState* state = &attacker->state;
234 s32 targetID = battleStatus->curTargetID;
235 s32 targetPartIdx = battleStatus->curTargetPart;
236 s32 actorClass;
237 Actor* target;
239 s32 hitResult;
240 s32 one = TRUE;
243 s32 isFire = FALSE;
244 s32 isWater = FALSE;
245 s32 isIce = FALSE;
246 s32 isElectric = FALSE;
248 s32 isPlayer;
249 s32 defense;
250 s32 event;
251 s32 damage;
252 Evt* script;
253
254 battleStatus->wasStatusInflicted = FALSE;
255 battleStatus->lastAttackDamage = 0;
256
257 battleStatus->attackerActorID = attacker->actorID;
258 battleStatus->curTargetID2 = targetID;
259 battleStatus->curTargetPart2 = targetPartIdx;
260
262 if (target == NULL) {
263 return HIT_RESULT_HIT;
264 }
265
268
270 target->lastDamageTaken = 0;
271
272 switch (actorClass) {
274 target->curHP = gPlayerData.curHP;
275 break;
277 target->curHP = 127;
278 break;
280 break;
281 }
282
283 // handle defender status
284
285 if (targetPart->eventFlags & ACTOR_EVENT_FLAG_ILLUSORY) {
286 return HIT_RESULT_MISS;
287 }
288
289 if (target->transparentStatus == STATUS_KEY_TRANSPARENT
290 || (targetPart->eventFlags & ACTOR_EVENT_FLAG_BURIED && !(battleStatus->curAttackElement & DAMAGE_TYPE_QUAKE))
291 ) {
292 return HIT_RESULT_MISS;
293 }
294
295 if (target->stoneStatus == STATUS_KEY_STONE) {
296 show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, -1);
297 show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 0);
298 play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 0);
300 return HIT_RESULT_HIT;
301 }
302
303 // handle attack element
304
305 if (battleStatus->curAttackElement & DAMAGE_TYPE_BLAST) {
306 if (!(battleStatus->curAttackElement & DAMAGE_TYPE_NO_CONTACT)
308 ) {
309 play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 3);
311 return HIT_RESULT_BACKFIRE;
312 }
313 }
314 if ((battleStatus->curAttackElement & DAMAGE_TYPE_QUAKE) && (target->flags & ACTOR_FLAG_FLYING)) {
315 play_hit_sound(attacker, state->goalPos.x, state->goalPos.y, state->goalPos.z, 1);
317 }
318 if (battleStatus->curAttackElement & DAMAGE_TYPE_FIRE) {
319 fx_ring_blast(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f, 1.0f, 24);
320 isFire = TRUE;
321 }
322 if (battleStatus->curAttackElement & DAMAGE_TYPE_SHOCK) {
325 }
326 if (battleStatus->curAttackElement & DAMAGE_TYPE_WATER) {
327 fx_water_splash(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f, 1.0f, 24);
328 isWater = TRUE;
329 }
330 if (battleStatus->curAttackElement & DAMAGE_TYPE_ICE) {
331 fx_big_snowflakes(0, state->goalPos.x, state->goalPos.y, state->goalPos.z + 5.0f);
332 isIce = TRUE;
333 }
334
335 if (!(attacker->staticStatus == STATUS_KEY_STATIC)
336 && ((target->staticStatus == STATUS_KEY_STATIC) || (targetPart->eventFlags & ACTOR_EVENT_FLAG_ELECTRIFIED))
337 && !(battleStatus->curAttackElement & (DAMAGE_TYPE_SHOCK | DAMAGE_TYPE_NO_CONTACT))
338 && !(battleStatus->curAttackEventSuppression & SUPPRESS_EVENT_SHOCK_CONTACT)
339 && !has_enchanted_part(attacker)) // enchanted attacks ignore electrified defenders
340 {
343 }
344
345 // ------------------------------------------------------------------------
346 // damage calculation
347
349
350 // determine target defense
351
352 defense = get_defense(target, targetPart->defenseTable, battleStatus->curAttackElement);
353
354 if (!(battleStatus->curAttackElement & DAMAGE_TYPE_IGNORE_DEFENSE)) {
355 defense += target->defenseBoost;
356
358 if (battleStatus->waterBlockTurnsLeft > 0) {
359 if ((battleStatus->curAttackElement & (DAMAGE_TYPE_BLAST | DAMAGE_TYPE_FIRE))) {
360 defense += 2;
361 } else {
362 defense += 1;
363 }
364 }
365
367 defense += 1;
368 }
369 }
370 }
371
372 // apply attacker damage modifiers
373
374 damage = battleStatus->curAttackDamage;
375
376 switch (actorClass) {
378 damage -= battleStatus->merleeDefenseBoost;
379 break;
382 break;
383 }
384
385 damage += attacker->attackBoost;
386
387 if (attacker->chillOutTurns != 0) {
388 damage -= attacker->chillOutAmount;
389 }
390
391 if (attacker->debuff == STATUS_KEY_SHRINK) {
392 if (damage > 0) {
393 damage /= 2;
394 }
395 }
396
397 if (damage > 99) {
398 damage = 99;
399 }
400 if (damage < 1) {
401 defense = 0;
402 }
403
404 target->hpChangeCounter = 0;
405 damage -= defense;
406
407 // apply damage mitigation from defensive badges
408
410 if (isPlayer) {
412 if (battleStatus->curAttackElement & DAMAGE_TYPE_FIRE) {
413 damage--;
414 }
415 }
416
420
421 if (target->curHP <= 5) {
423 damage /= 2;
424 }
425 }
426 }
427
428 // apply damage mitigation from blocking
429
430 switch (actorClass) {
432 // TODO figure out how to better write target->debuff >= STATUS_KEY_POISON
433 if ((target->debuff == 0 || target->debuff >= STATUS_KEY_POISON)
434 && (target->stoneStatus == 0)
435 && !(battleStatus->curAttackElement & DAMAGE_TYPE_UNBLOCKABLE)
436 ) {
437 s32 blocked;
438
440 blocked = rand_int(1);
441 } else {
442 blocked = check_block_input(BUTTON_A);
443 }
444
445 if (blocked) {
446 damage--;
451 break;
452 }
454 }
455 break;
457 if (target->stoneStatus == 0) {
458 if (target->koStatus == 0 && !(battleStatus->curAttackElement & DAMAGE_TYPE_UNBLOCKABLE)) {
460 damage = 0;
464 break;
465 }
467 }
468 }
469 break;
470 }
471
474 }
475
476 // deal damage and determine resulting battle event
477
478 event = EVENT_HIT_COMBO;
479 if (damage < 1) {
480 target->hpChangeCounter = 0;
481 if (!(battleStatus->curAttackElement & DAMAGE_TYPE_STATUS_ALWAYS_HITS)) {
483 event = EVENT_ZERO_DAMAGE;
484 } else {
486 event = EVENT_ZERO_DAMAGE;
487 if (target->curHP < 1) {
488 event = EVENT_DEATH;
489 }
490 }
491 battleStatus->lastAttackDamage = 0;
492 } else {
493 target->damageCounter += damage;
494 target->hpChangeCounter -= damage;
495 battleStatus->lastAttackDamage = 0;
499 ) {
500 if (!(target->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
501 target->curHP -= damage;
502 }
503
504 if (target->curHP < 1) {
505 target->curHP = 0;
506 event = EVENT_DEATH;
507 }
508 }
509 battleStatus->lastAttackDamage += damage;
510 target->lastDamageTaken = battleStatus->lastAttackDamage;
511 target->hpChangeCounter = 0;
512
514 battleStatus->damageTaken += damage;
515 gPlayerData.curHP = target->curHP;
516 }
517 }
518
520 if (event == EVENT_HIT_COMBO) {
521 event = EVENT_HIT;
522 }
523 if (event == EVENT_ZERO_DAMAGE) {
524 event = EVENT_IMMUNE;
525 }
526 if (target->curHP < 1 && event == EVENT_IMMUNE) {
527 event = EVENT_DEATH;
528 }
529 } else if (event == EVENT_DEATH) {
530 event = EVENT_HIT_COMBO;
531 }
532
535 }
536
539 && (targetPart->eventFlags & ACTOR_EVENT_FLAG_FLIPABLE)
540 ) {
541 if (event == EVENT_HIT) {
542 event = EVENT_FLIP_TRIGGER;
543 }
544 if (event == EVENT_IMMUNE) {
545 event = EVENT_FLIP_TRIGGER;
546 }
547 }
548
551 && (targetPart->eventFlags & ACTOR_EVENT_FLAG_FLIPABLE)
552 ) {
553 if (event == EVENT_HIT_COMBO) {
554 event = EVENT_FLIP_TRIGGER;
555 }
556 if (event == EVENT_ZERO_DAMAGE) {
557 event = EVENT_FLIP_TRIGGER;
558 }
559 }
560
563 ) {
564 if (event == EVENT_HIT) {
565 event = EVENT_BURN_HIT;
566 }
567 if (event == EVENT_DEATH) {
568 event = EVENT_FIRE_DEATH;
569 }
570 isFire = TRUE;
571 }
572
574 if (event == EVENT_HIT_COMBO) {
575 event = EVENT_18;
576 }
577 if (event == EVENT_HIT) {
578 event = EVENT_BLOCK;
579 }
580 if (event == EVENT_ZERO_DAMAGE) {
581 event = EVENT_18;
582 }
583 if (event == EVENT_IMMUNE) {
584 event = EVENT_BLOCK;
585 }
586 if (event == EVENT_BURN_HIT) {
587 event = EVENT_BLOCK;
588 }
589 }
590
591 // try inflicting status effect
592
594 && battleStatus->lastAttackDamage >= 0
595 && event != EVENT_DEATH
601 {
605 }
609 }
613 }
617 }
621 }
625 }
629 }
633 }
637 }
638
643 }
647 }
648
652 }
653
654 if (statusInflicted) {
655 if (event == EVENT_ZERO_DAMAGE) {
656 event = EVENT_HIT_COMBO;
657 }
658 if (event == EVENT_IMMUNE) {
659 event = EVENT_HIT;
660 }
661 }
662 }
663
664 // dispatch events and play damage effects
665
666 battleStatus->wasStatusInflicted = statusInflicted;
667
668 switch (actorClass) {
671 break;
674 break;
677 break;
678 }
679
681 && battleStatus->lastAttackDamage > 0
683 && !(target->flags & ACTOR_FLAG_NO_DMG_APPLY))
684 {
686 }
687
688 if (!(target->flags & ACTOR_FLAG_NO_DMG_POPUP)) {
689 switch (actorClass) {
692 if (battleStatus->lastAttackDamage == 0) {
694 // immune star fx?
695 show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, -3);
696 }
697 } else if (battleStatus->curAttackElement & (DAMAGE_TYPE_MULTIPLE_POPUPS | DAMAGE_TYPE_SMASH)) {
698 show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 1);
699 show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
700 } else {
701 show_primary_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 1);
702 show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
703 break;
704 }
705 break;
707 if (battleStatus->lastAttackDamage == 0) {
709 show_immune_bonk(state->goalPos.x, state->goalPos.y, state->goalPos.z, 0, 1, 3);
710 }
711 } else if (battleStatus->curAttackElement & (DAMAGE_TYPE_MULTIPLE_POPUPS | DAMAGE_TYPE_SMASH)) {
712 show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
713 show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
714 } else {
715 show_primary_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
716 show_damage_fx(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
717 }
718 break;
719 }
720 }
721
722 if (battleStatus->lastAttackDamage > 0) {
724
726
727 if (attacker->actorTypeData1[5] != SOUND_NONE) {
728 sfx_play_sound_at_position(attacker->actorTypeData1[5], SOUND_SPACE_DEFAULT, state->goalPos.x, state->goalPos.y, state->goalPos.z);
729 }
730
731 if (isFire) {
733 } else if (!isElectric) {
735 } else {
737 }
738
739 play_hit_sound(target, state->goalPos.x, state->goalPos.y, state->goalPos.z, hitSound);
740 }
741
742 if ((battleStatus->lastAttackDamage < 1 && !statusInflicted2 && !madeElectricContact) || targetPart->flags & ACTOR_PART_FLAG_DAMAGE_IMMUNE) {
744 }
745
746 if ((battleStatus->curAttackStatus & STATUS_FLAG_SLEEP) && statusInflicted) {
748 script->varTable[0] = state->goalPos.x;
749 script->varTable[1] = state->goalPos.y;
750 script->varTable[2] = state->goalPos.z;
752 }
753 if ((battleStatus->curAttackStatus & STATUS_FLAG_DIZZY) && statusInflicted) {
755 script->varTable[0] = state->goalPos.x;
756 script->varTable[1] = state->goalPos.y;
757 script->varTable[2] = state->goalPos.z;
759 }
760 if ((battleStatus->curAttackStatus & STATUS_FLAG_PARALYZE) && statusInflicted) {
762 script->varTable[0] = state->goalPos.x;
763 script->varTable[1] = state->goalPos.y;
764 script->varTable[2] = state->goalPos.z;
766 }
767 if ((battleStatus->curAttackStatus & STATUS_FLAG_POISON) && statusInflicted) {
769 script->varTable[0] = state->goalPos.x;
770 script->varTable[1] = state->goalPos.y;
771 script->varTable[2] = state->goalPos.z;
773 }
774 if ((battleStatus->curAttackStatus & STATUS_FLAG_STOP) && statusInflicted) {
776 script->varTable[0] = state->goalPos.x;
777 script->varTable[1] = state->goalPos.y;
778 script->varTable[2] = state->goalPos.z;
780 }
781 if ((battleStatus->curAttackStatus & STATUS_FLAG_FROZEN) && statusInflicted) {
783 script->varTable[0] = state->goalPos.x;
784 script->varTable[1] = state->goalPos.y;
785 script->varTable[2] = state->goalPos.z;
786 script->varTablePtr[3] = target;
788 }
789 if ((battleStatus->curAttackStatus & STATUS_FLAG_SHRINK) && statusInflicted) {
791 script->varTable[0] = state->goalPos.x;
792 script->varTable[1] = state->goalPos.y;
793 script->varTable[2] = state->goalPos.z;
794 script->varTablePtr[3] = target;
796 }
797
798 if ((battleStatus->curAttackElement & DAMAGE_TYPE_SMASH) && target->actorType == ACTOR_TYPE_GOOMNUT_TREE) {
800 }
801
803
804 if (attacker->staticStatus != STATUS_KEY_STATIC
805 && (target->staticStatus == STATUS_KEY_STATIC || targetPart->eventFlags & ACTOR_EVENT_FLAG_ELECTRIFIED)
806 && !(battleStatus->curAttackElement & DAMAGE_TYPE_NO_CONTACT)
807 && !(battleStatus->curAttackEventSuppression & SUPPRESS_EVENT_SHOCK_CONTACT)
808 && (attacker->transparentStatus != STATUS_KEY_TRANSPARENT)
810 {
814 return HIT_RESULT_BACKFIRE;
815 }
816
817 return hitResult;
818}
s32 dispatch_damage_event_actor_1(Actor *actor, s32 damageAmount, s32 event)
Definition 1A5830.c:892
void play_hit_sound(Actor *actor, f32 x, f32 y, f32 z, u32 hitSound)
Definition 1A5830.c:37
s32 has_enchanted_part(Actor *actor)
Definition 1A5830.c:7
s32 check_block_input(s32 buttonMask)
Definition action_cmd.c:537
@ ACTION_RATING_NICE
sets nice hits = 1
Definition enums.h:1979
@ BUTTON_A
Definition enums.h:2790
@ BS_FLAGS1_TUTORIAL_BATTLE
Definition enums.h:3593
@ BS_FLAGS1_PLAYER_DEFENDING
Definition enums.h:3590
@ BS_FLAGS1_TRIGGER_EVENTS
Definition enums.h:3574
@ BS_FLAGS1_ATK_BLOCKED
Definition enums.h:3599
@ ACTOR_EVENT_FLAG_ELECTRIFIED
Player takes shock damage upon contact.
Definition enums.h:3375
@ ACTOR_EVENT_FLAG_BURIED
Actor can only by hit by quake-element attacks.
Definition enums.h:3379
@ ACTOR_EVENT_FLAG_FLIPABLE
Actor can be flipped; triggered by jump and quake attacks.
Definition enums.h:3380
@ ACTOR_EVENT_FLAG_EXPLODE_ON_IGNITION
Blast and fire attacks trigger an explosion.
Definition enums.h:3377
@ BS_FLAGS2_IS_FIRST_STRIKE
Definition enums.h:3617
@ STATUS_KEY_PARALYZE
Definition enums.h:2201
@ STATUS_TURN_MOD_PARALYZE
Definition enums.h:2234
@ STATUS_KEY_FROZEN
Definition enums.h:2203
@ STATUS_TURN_MOD_SLEEP
Definition enums.h:2228
@ STATUS_TURN_MOD_DIZZY
Definition enums.h:2232
@ STATUS_TURN_MOD_POISON
Definition enums.h:2233
@ STATUS_KEY_FEAR
Definition enums.h:2199
@ STATUS_TURN_MOD_STOP
Definition enums.h:2237
@ STATUS_KEY_SLEEP
Definition enums.h:2202
@ STATUS_KEY_STOP
Definition enums.h:2204
@ STATUS_TURN_MOD_STONE
Definition enums.h:2236
@ STATUS_TURN_MOD_FROZEN
Definition enums.h:2230
@ STATUS_KEY_SHRINK
Definition enums.h:2206
@ STATUS_KEY_DIZZY
Definition enums.h:2200
@ STATUS_KEY_POISON
Definition enums.h:2205
@ STATUS_TURN_MOD_STATIC
Definition enums.h:2229
@ STATUS_TURN_MOD_FEAR
Definition enums.h:2231
@ STATUS_TURN_MOD_SHRINK
Definition enums.h:2235
@ STATUS_KEY_DAZE
Definition enums.h:2209
@ HIT_RESULT_BACKFIRE
Definition enums.h:1949
@ HIT_RESULT_NO_DAMAGE
Definition enums.h:1952
@ SUPPRESS_EVENT_SHOCK_CONTACT
Definition enums.h:2903
@ STATUS_FLAG_FEAR
Definition enums.h:2815
@ STATUS_FLAG_STOP
Definition enums.h:2821
@ STATUS_FLAG_FROZEN
Definition enums.h:2814
@ STATUS_FLAG_STATIC
Definition enums.h:2813
@ STATUS_FLAG_SHRINK
Definition enums.h:2819
@ STATUS_FLAG_PARALYZE
Definition enums.h:2816
@ STATUS_FLAG_STONE
Definition enums.h:2820
@ STATUS_FLAG_DIZZY
Definition enums.h:2818
@ STATUS_FLAG_SLEEP
Definition enums.h:2812
@ STATUS_FLAG_POISON
Definition enums.h:2817
@ ABILITY_BERSERKER
Definition enums.h:457
@ ABILITY_P_DOWN_D_UP
Definition enums.h:473
@ ABILITY_HEALTHY_HEALTHY
Definition enums.h:491
@ ABILITY_DEFEND_PLUS
Definition enums.h:463
@ ABILITY_DAMAGE_DODGE
Definition enums.h:487
@ ABILITY_LAST_STAND
Definition enums.h:468
@ ABILITY_P_UP_D_DOWN
Definition enums.h:470
@ ABILITY_FIRE_SHIELD
Definition enums.h:443
@ SOUND_DAMAGE_STARS
Definition enums.h:950
@ SOUND_INFLICT_STATUS
Definition enums.h:1355
@ SOUND_NONE
Definition enums.h:547
@ SOUND_SMACK_TREE
Definition enums.h:787
@ SOUND_INFLICT_SLEEP
Definition enums.h:1354
@ ACTOR_PLAYER
Definition enums.h:2085
@ ACTOR_FLAG_FLYING
Quake Hammer can't hit.
Definition enums.h:3329
@ ACTOR_FLAG_NO_DMG_POPUP
Hide damage popup.
Definition enums.h:3341
@ ACTOR_FLAG_NO_DMG_APPLY
Damage is not applied to actor HP.
Definition enums.h:3340
@ EVENT_HIT
Definition enums.h:2132
@ EVENT_BURN_HIT
Definition enums.h:2136
@ EVENT_FIRE_DEATH
Definition enums.h:2162
@ EVENT_IMMUNE
Definition enums.h:2146
@ EVENT_ZERO_DAMAGE
Definition enums.h:2144
@ EVENT_EXPLODE_TRIGGER
Definition enums.h:2155
@ EVENT_BLOCK
Definition enums.h:2147
@ EVENT_SPIN_SMASH_DEATH
Definition enums.h:2154
@ EVENT_18
Definition enums.h:2145
@ EVENT_HIT_COMBO
Definition enums.h:2131
@ EVENT_DEATH
Definition enums.h:2153
@ EVENT_FLIP_TRIGGER
Definition enums.h:2135
@ EVENT_SHOCK_HIT
Definition enums.h:2165
@ ACTOR_PART_FLAG_DAMAGE_IMMUNE
electrified Plays extra hurt SFX?
Definition enums.h:3358
@ DAMAGE_TYPE_POW
Definition enums.h:2861
@ DAMAGE_TYPE_4000
Definition enums.h:2865
@ DAMAGE_TYPE_ICE
Definition enums.h:2854
@ DAMAGE_TYPE_STATUS_ALWAYS_HITS
Definition enums.h:2880
@ DAMAGE_TYPE_SMASH
Definition enums.h:2857
@ DAMAGE_TYPE_UNBLOCKABLE
Definition enums.h:2875
@ DAMAGE_TYPE_IGNORE_DEFENSE
Definition enums.h:2877
@ DAMAGE_TYPE_SHOCK
Definition enums.h:2856
@ DAMAGE_TYPE_BLAST
Definition enums.h:2860
@ DAMAGE_TYPE_FIRE
Definition enums.h:2852
@ DAMAGE_TYPE_QUAKE
Definition enums.h:2862
@ DAMAGE_TYPE_JUMP
Definition enums.h:2858
@ DAMAGE_TYPE_NO_CONTACT
Definition enums.h:2878
@ DAMAGE_TYPE_MULTIPLE_POPUPS
Definition enums.h:2879
@ DAMAGE_TYPE_WATER
Definition enums.h:2853
void show_primary_damage_popup(f32 x, f32 y, f32 z, s32 attack, s32 a)
Definition 190B20.c:2269
s32 is_ability_active(s32 arg0)
Definition inventory.c:1735
void show_immune_bonk(f32 x, f32 y, f32 z, s32, s32, s32)
void show_actor_health_bar(Actor *)
Definition 190B20.c:2505
void clear_part_pal_adjustment(ActorPart *)
Definition 190B20.c:2618
void set_actor_flash_mode(Actor *actor, s32 arg1)
Definition 190B20.c:2696
void show_damage_fx(Actor *actor, f32 x, f32 y, f32 z, s32 damage)
Definition 190B20.c:2334
s32 get_defense(Actor *actor, s32 *defenseTable, s32 elementFlags)
Definition 190B20.c:2219
void func_80266970(Actor *)
Definition 190B20.c:2439
void show_next_damage_popup(f32 x, f32 y, f32 z, s32 damageAmount, s32)
Definition 190B20.c:2295
void apply_shock_effect(Actor *)
void show_action_rating(s32, Actor *, f32, f32, f32)
Definition 190B20.c:2360
s32 try_inflict_status(Actor *, s32, s32)
Definition 190B20.c:2532
s32 inflict_partner_ko(Actor *target, s32 statusTypeKey, s32 duration)
Definition 190B20.c:2203
EvtScript EVS_PlayStopHitFX
Definition dmg_player.c:109
EvtScript EVS_PlayFreezeHitFX
Definition dmg_player.c:115
EvtScript EVS_PlayShrinkHitFX
Definition dmg_player.c:125
EvtScript EVS_PlayParalyzeHitFX
Definition dmg_player.c:97
EvtScript EVS_PlayPoisonHitFX
Definition dmg_player.c:103
EvtScript EVS_PlaySleepHitFX
Definition dmg_player.c:85
EvtScript EVS_PlayDizzyHitFX
Definition dmg_player.c:91

◆ dispatch_damage_event_actor()

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

Definition at line 820 of file 1A5830.c.

820 {
822 ActorState* state = &actor->state;
825 s32 hpChangeCounter;
826 s32 hpChange;
827 s32 flagCheck;
828 s32 new_var;
829
830 battleStatus->curAttackDamage = damageAmount;
832 actor->hpChangeCounter += hpChange;
833 new_var = actor->hpChangeCounter;
835 actor->damageCounter += hpChange;
836 actor->hpChangeCounter -= hpChange;
837 battleStatus->lastAttackDamage = 0;
838 actor->curHP -= hpChange;
839
840 if (actor->curHP <= 0) {
842 battleStatus->lastAttackDamage += actor->curHP;
843 actor->curHP = 0;
844 }
845
846 battleStatus->lastAttackDamage += hpChange;
847 actor->lastDamageTaken = battleStatus->lastAttackDamage;
848 battleStatus->curDamageSource = DMG_SRC_DEFAULT;
852 }
855 }
856 }
857 if (dispatchEvent == EVENT_DEATH) {
860 }
863 }
864 }
865
866 if (!stopMotion) {
868
869 if (func_80263230(actor, actor) != 0) {
870 show_next_damage_popup(actor->targetData[0].truePos.x, actor->targetData[0].truePos.y, actor->targetData[0].truePos.z, battleStatus->lastAttackDamage, 0);
871 show_damage_fx(actor, actor->targetData[0].truePos.x, actor->targetData[0].truePos.y, actor->targetData[0].truePos.z, battleStatus->lastAttackDamage);
872 }
874
875 } else {
876 show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage, 0);
877 show_damage_fx(actor, state->goalPos.x, state->goalPos.y, state->goalPos.z, battleStatus->lastAttackDamage);
878 }
879
880 if (battleStatus->lastAttackDamage > 0) {
881 set_actor_flash_mode(actor, 1);
882 }
885 return 0;
886}
s16 lastDamageTaken
ActorState state
s16 damageCounter
struct SelectableTarget targetData[24]
s16 targetActorID
s16 hpChangeCounter
@ DMG_SRC_DEFAULT
Definition enums.h:1988
@ ACTOR_FLAG_HEALTH_BAR_HIDDEN
Definition enums.h:3338
@ EVENT_SPIN_SMASH_LAUNCH_HIT
Definition enums.h:2138
@ EVENT_SHOCK_DEATH
Definition enums.h:2159
@ EVENT_SPIN_SMASH_LAUNCH_DEATH
Definition enums.h:2158
s32 func_80263230(Actor *, Actor *)
Definition 190B20.c:558

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 888 of file 1A5830.c.

888 {
890}
s32 dispatch_damage_event_actor(Actor *actor, s32 damageAmount, s32 originalEvent, s32 stopMotion)
Definition 1A5830.c:820

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 892 of file 1A5830.c.

892 {
894}

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 2092 of file 1A5830.c.

2092 {
2093 s32 timeLeft;
2094 f32 absMag;
2095 f64 start1;
2096 f64 start2;
2097 f32 len1;
2098 f32 len2;
2099 f32 len3;
2100 f32 len4;
2101 f64 len5;
2102 f32 len6;
2103 f64 len7;
2104
2105 switch (easing) {
2106 case EASING_LINEAR:
2107 return start + (end - start) * elapsed / duration;
2109 return start + SQ(elapsed) * (end - start) / SQ(duration);
2110 case EASING_CUBIC_IN:
2111 return start + CUBE(elapsed) * (end - start) / CUBE(duration);
2112 case EASING_QUARTIC_IN:
2113 return start + QUART(elapsed) * (end - start) / QUART(duration);
2115 len1 = end - start;
2116 return end - (len1 * cos_rad(((f32)elapsed / duration) * PI_D * 4.0) * (duration - elapsed) *
2117 (duration - elapsed)) / SQ((f32)duration);
2119 len2 = end - start;
2120 return end - (len2 * cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 15.0) * (duration - elapsed) *
2121 (duration - elapsed)) / SQ((f32)duration);
2123 timeLeft = duration - elapsed;
2124 return start + (end - start) - ((SQ(timeLeft) * (end - start))) / SQ(duration);
2125 case EASING_CUBIC_OUT:
2126 len3 = end - start;
2127 timeLeft = duration - elapsed;
2128 return start + len3 - ((CUBE(timeLeft) * len3)) / CUBE(duration);
2129 case EASING_QUARTIC_OUT:
2130 len4 = end - start;
2131 timeLeft = duration - elapsed;
2132 return start + len4 - ((QUART(timeLeft) * len4)) / QUART(duration);
2133 case EASING_COS_BOUNCE:
2134 absMag = cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 40.0) * (duration - elapsed) *
2135 (duration - elapsed) / SQ((f32)duration);
2136 if (absMag < 0.0f) {
2137 absMag = -absMag;
2138 }
2139 return end - (end - start) * absMag;
2140 case EASING_COS_IN_OUT:
2141 len5 = end - start;
2142 start1 = start;
2143 return start1 + (len5 * (1.0 - cos_rad(((f32)elapsed * PI_D) / (f32)duration)) / 2);
2144 case EASING_SIN_OUT:
2145 len6 = end - start;
2146 return start + (len6 * sin_rad((((f32) elapsed) * (PI_D / 2)) / ((f32) duration)));
2147 case EASING_COS_IN:
2148 len7 = end - start;
2149 start2 = start;
2150 return start2 + (len7 * (1.0 - cos_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration)));
2151 }
2152
2153 return 0.0f;
2154}
@ EASING_SIN_OUT
Definition enums.h:521
@ EASING_COS_IN
Definition enums.h:522
@ EASING_CUBIC_IN
Definition enums.h:512
@ EASING_CUBIC_OUT
Definition enums.h:515
@ EASING_QUARTIC_IN
Definition enums.h:513
@ EASING_COS_BOUNCE
Definition enums.h:519
@ EASING_COS_SLOW_OVERSHOOT
Definition enums.h:517
@ EASING_QUADRATIC_IN
Definition enums.h:511
@ EASING_COS_IN_OUT
Definition enums.h:520
@ EASING_QUARTIC_OUT
Definition enums.h:516
@ EASING_QUADRATIC_OUT
Definition enums.h:514
@ EASING_LINEAR
Definition enums.h:510
@ EASING_COS_FAST_OVERSHOOT
Definition enums.h:518
f32 cos_rad(f32 x)
Definition 43F0.c:715
f32 sin_rad(f32 x)
Definition 43F0.c:711
#define PI_D
Definition macros.h:131
#define QUART(x)
Definition macros.h:172
#define CUBE(x)
Definition macros.h:171
#define SQ(x)
Definition macros.h:170

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 2703 of file 1A5830.c.

2703 {
2704 100, 100, 100,
2705 110,
2706 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
2707};