ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2025-01-10 05:35:05 +01:00
Code Issues Packages Projects Releases Wiki Activity
7dc52f6a5e
pokeemerald/src/battle_tv.c

1247 lines
47 KiB
C
Raw Normal View History

decompile and document battle tv
2018-02-27 20:40:09 +01:00
#include "global.h"
#include "pokemon.h"
#include "battle.h"
Give battle_anim files appropriate names
2019-03-31 19:15:39 +02:00
#include "battle_anim.h"
decompile and document battle tv
2018-02-27 20:40:09 +01:00
#include "battle_tv.h"
#include "constants/battle_string_ids.h"
#include "constants/battle_anim.h"
#include "constants/moves.h"
#include "battle_message.h"
#include "tv.h"
// this file's functions
static bool8 sub_817E0B8(u16 stringId);
static void AddMovePoints(u8 caseId, u16 arg1, u8 arg2, u8 arg3);
static void TrySetBattleSeminarShow(void);
static void AddPointsOnFainting(bool8 targetFainted);
static void AddPointsBasedOnWeather(u16 weatherFlags, u16 moveId, u8 moveSlot);
static bool8 ShouldCalculateDamage(u16 moveId, s32 *dmg, u16 *powerOverride);
// const rom data
static const u16 sVariableDmgMoves[] =
{
MOVE_COUNTER, MOVE_FISSURE, MOVE_BIDE, MOVE_MIRROR_COAT,
MOVE_HORN_DRILL, MOVE_FLAIL, MOVE_REVERSAL, MOVE_HIDDEN_POWER,
MOVE_SHEER_COLD, MOVE_FOCUS_PUNCH, MOVE_ERUPTION,
MOVE_WATER_SPOUT, MOVE_DREAM_EATER, MOVE_WEATHER_BALL,
MOVE_SNORE, MOVE_PAIN_SPLIT, MOVE_GUILLOTINE,
MOVE_FRUSTRATION, MOVE_RETURN, MOVE_ENDEAVOR,
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
MOVE_PRESENT, MOVE_REVENGE, 0xFFFF,
decompile and document battle tv
2018-02-27 20:40:09 +01:00
// those are handled by the function itself
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
MOVE_MAGNITUDE, MOVE_PSYWAVE, 0xFFFF
decompile and document battle tv
2018-02-27 20:40:09 +01:00
};
static const u16 sUnknown_0860A4E0[] =
{
0x0001, 0x0001, 0x0001, 0x0004, 0x0001, 0x0001, 0x0001, 0x0000, 0x0005, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
0x0001, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0005, 0x0005, 0x0004, 0x0005, 0x0001, 0x0003, 0x0001,
0x0003, 0x0005, 0x0001, 0x0007, 0x0001, 0x0007, 0x0007, 0x0001, 0x0005, 0x0002, 0x0004, 0x0001, 0x0001, 0x0001, 0x0005, 0x0001,
0x0002, 0x0004, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
0x0001, 0x0007, 0x0004, 0x0004, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0004, 0x0001, 0x0001, 0x0001, 0x0004,
0x0005, 0x0002, 0x0004, 0x0001, 0x0004, 0x0001, 0x0007, 0x0002, 0x0001, 0x0005, 0x0007, 0x0003, 0x0003, 0x0004, 0x0003, 0x0003,
0x0003, 0x0003, 0x0003, 0x0002, 0x0004, 0x0001, 0x0005, 0x0001, 0x0001, 0x0004, 0x0005, 0x0003, 0x0001, 0x0002, 0x0001, 0x0005,
0x0004, 0x0003, 0x0006, 0x0004, 0x0003, 0x0003, 0x0003, 0x0002, 0x0004, 0x0001, 0x0001, 0x0001, 0x0005, 0x0001, 0x0001, 0x0007,
0x0002, 0x0002, 0x0001, 0x0001, 0x0004, 0x0004, 0x0004, 0x0001, 0x0004, 0x0004, 0x0001, 0x0001, 0x0001, 0x0001, 0x0007, 0x0007,
0x0006, 0x0003, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0002, 0x0003, 0x0001, 0x0001, 0x0004, 0x0004,
0x0003, 0x0003, 0x0003, 0x0001, 0x0004, 0x0007, 0x0007, 0x0005, 0x0007, 0x0001, 0x0007, 0x0001, 0x0005, 0x0000, 0x0004, 0x0004,
0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0006, 0x0003, 0x0006, 0x0004, 0x0004, 0x0002, 0x0005, 0x0002, 0x0001, 0x0001, 0x0006,
0x0006, 0x0006, 0x0001, 0x0001, 0x0001, 0x0001, 0x0002, 0x0006, 0x0001, 0x0004, 0x0001, 0x0001, 0x0003, 0x0001, 0x0001, 0x0001,
0x0001, 0x0001, 0x0004, 0x0001, 0x0001, 0x0003
};
static const u16 sUnknown_0860A68C[] =
{
0x0004, 0xfffd, 0xfffa
};
static const u16 sUnknown_0860A692[] =
{
0x0004, 0x0004, 0x0006, 0x0006, 0x0007, 0x0006, 0x0002
};
static const u16 sUnknown_0860A6A0[] =
{
0x0091, 0x0003, 0x00fa, 0x0003, 0x00be, 0x0003, 0x0080, 0x0003, 0x006e, 0x0003, 0x0098, 0x0003, 0x0143, 0x0003, 0x0123, 0x0003,
0x007f, 0x0003, 0x014a, 0x0003, 0x0039, 0x0003, 0x0134, 0x0003, 0x0038, 0x0003, 0x003d, 0x0003, 0x015a, 0x0000, 0x0037, 0x0003,
0x0160, 0x0003, 0x0137, 0x0003, 0x0057, 0x0003, 0x004c, 0xfffc, 0x013b, 0xfffc, 0x00ac, 0xfffc, 0x0035, 0xfffc, 0x00dd, 0xfffc,
0x007e, 0xfffc, 0x0101, 0xfffc, 0x0034, 0xfffc, 0x0133, 0xfffc, 0x012b, 0xfffc, 0x011c, 0xfffc, 0x0053, 0xfffc, 0x0007, 0xfffc,
0x004c, 0xfffc, 0xffff, 0x0000
};
static const u16 sUnknown_0860A728[] =
{
0x013b, 0x0003, 0x00ac, 0x0003, 0x0035, 0x0003, 0x00dd, 0x0003, 0x007e, 0x0003, 0x0101, 0x0003, 0x0034, 0x0003, 0x0133, 0x0003,
0x012b, 0x0003, 0x011c, 0x0003, 0x0053, 0x0003, 0x0007, 0x0003, 0x004c, 0x0005, 0x00eb, 0x0003, 0x00ea, 0x0003, 0x00ec, 0x0003,
0x0137, 0x0003, 0xffff, 0x0000
};
static const u16 sUnknown_0860A770[] =
{
0x0137, 0x0003, 0x004c, 0xfffd, 0xffff, 0x0000
};
static const u16 sUnknown_0860A77C[] =
{
0x0137, 0x0003, 0x004c, 0xfffd, 0xffff, 0x0000
};
static const u16 sUnknown_0860A788[] =
{
0x0055, 0x0003, 0x0009, 0x0003, 0x00d1, 0x0003, 0x0054, 0x0003, 0x00c0, 0x0003, 0x015f, 0x0003, 0x0056, 0x0000, 0x0057, 0x0003,
0x0158, 0x0003, 0xffff, 0x0000
};
static const u16 sUnknown_0860A7B0[] =
{
0x0005, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003
};
static const u16 sUnknown_0860A7BE[] =
{
0x0005, 0x0005, 0x0005, 0x0005, 0x0005
};
static const u16 sUnknown_0860A7C8[] =
{
0x0004
};
static const u16 sUnknown_0860A7CA[] =
{
0x0005
};
static const u16 sUnknown_0860A7CC[] =
{
0x0005
};
static const u16 sUnknown_0860A7CE[] =
{
0x0003
};
static const u16 sUnknown_0860A7D0[] =
{
0x0003
};
static const u16 sUnknown_0860A7D2[] =
{
0x0004
};
static const u16 sUnknown_0860A7D4[] =
{
0x0003
};
static const u16 sUnknown_0860A7D6[] =
{
0x0006
};
static const u16 sUnknown_0860A7D8[] =
{
0x0006
};
static const u16 sUnknown_0860A7DA[] =
{
0x0006
};
static const u16 sUnknown_0860A7DC[] =
{
0x0004
};
static const u16 sUnknown_0860A7DE[] =
{
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002
};
static const u16 sUnknown_0860A7EC[] =
{
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004
};
static const u16 sUnknown_0860A7FA[] =
{
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
};
static const u16 sUnknown_0860A808[] =
{
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002
};
static const u16 sUnknown_0860A816[] =
{
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004
};
static const u16 sUnknown_0860A824[] =
{
0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe
};
static const u16 *const sPointsArray[] =
{
sUnknown_0860A4E0,
sUnknown_0860A68C,
sUnknown_0860A692,
sUnknown_0860A6A0,
sUnknown_0860A728,
sUnknown_0860A770,
sUnknown_0860A77C,
sUnknown_0860A788,
sUnknown_0860A7B0,
sUnknown_0860A7BE,
sUnknown_0860A7C8,
sUnknown_0860A7CA,
sUnknown_0860A7CC,
sUnknown_0860A7CE,
sUnknown_0860A7D0,
sUnknown_0860A7D2,
sUnknown_0860A7D4,
sUnknown_0860A7D6,
sUnknown_0860A7D8,
sUnknown_0860A7DA,
sUnknown_0860A7DA,
sUnknown_0860A7DC,
sUnknown_0860A7DE,
sUnknown_0860A7EC,
sUnknown_0860A7FA,
sUnknown_0860A808,
sUnknown_0860A816,
sUnknown_0860A824
};
static const u16 sUnknown_0860A8A4[] =
{
STRINGID_PKMNPERISHCOUNTFELL, STRINGID_PKMNWISHCAMETRUE, STRINGID_PKMNLOSTPPGRUDGE,
STRINGID_PKMNTOOKFOE, STRINGID_PKMNABSORBEDNUTRIENTS, STRINGID_PKMNANCHOREDITSELF,
STRINGID_PKMNAFFLICTEDBYCURSE, STRINGID_PKMNSAPPEDBYLEECHSEED, STRINGID_PKMNLOCKEDINNIGHTMARE,
STRINGID_PKMNHURTBY, STRINGID_PKMNHURTBYBURN, STRINGID_PKMNHURTBYPOISON,
STRINGID_PKMNHURTBYSPIKES, STRINGID_ATTACKERFAINTED, STRINGID_TARGETFAINTED,
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
STRINGID_PKMNHITWITHRECOIL, STRINGID_PKMNCRASHED, 0xFFFF
decompile and document battle tv
2018-02-27 20:40:09 +01:00
};
// code
void BattleTv_SetDataBasedOnString(u16 stringId)
{
struct BattleTv *tvPtr;
u32 atkSide, defSide, effSide, scriptingSide;
struct Pokemon *atkMon, *defMon;
u8 moveSlot;
u32 atkFlank, defFlank, effFlank;
u8 *perishCount;
u16 *statStringId, *finishedMoveId;
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK) && stringId != STRINGID_ITDOESNTAFFECT && stringId != STRINGID_NOTVERYEFFECTIVE)
return;
tvPtr = &gBattleStruct->tv;
atkSide = GetBattlerSide(gBattlerAttacker);
defSide = GetBattlerSide(gBattlerTarget);
effSide = GetBattlerSide(gEffectBattler);
C vars sym ewram
2018-06-30 15:35:54 +02:00
scriptingSide = GetBattlerSide(gBattleMsgDataPtr->scrActive);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
if (atkSide == B_SIDE_PLAYER)
atkMon = &gPlayerParty[gBattlerPartyIndexes[gBattlerAttacker]];
else
atkMon = &gEnemyParty[gBattlerPartyIndexes[gBattlerAttacker]];
if (defSide == B_SIDE_PLAYER)
defMon = &gPlayerParty[gBattlerPartyIndexes[gBattlerTarget]];
else
defMon = &gEnemyParty[gBattlerPartyIndexes[gBattlerTarget]];
C vars sym ewram
2018-06-30 15:35:54 +02:00
moveSlot = GetBattlerMoveSlotId(gBattlerAttacker, gBattleMsgDataPtr->currentMove);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
if (moveSlot >= 4 && sub_817E0B8(stringId) && stringId > BATTLESTRINGS_ID_ADDER)
{
tvPtr->side[atkSide].faintCause = 15;
return;
}
perishCount = (u8 *)(gBattleTextBuff1 + 4);
statStringId = (u16 *)(gBattleTextBuff2 + 2);
finishedMoveId = (u16 *)(gBattleTextBuff1 + 2);
atkFlank = GetBattlerPosition(gBattlerAttacker) / 2;
defFlank = GetBattlerPosition(gBattlerTarget) / 2;
effFlank = GetBattlerPosition(gEffectBattler) / 2;
switch (stringId)
{
case STRINGID_ITDOESNTAFFECT:
AddMovePoints(1, moveSlot, 2, 0);
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
TrySetBattleSeminarShow();
break;
case STRINGID_NOTVERYEFFECTIVE:
AddMovePoints(1, moveSlot, 1, 0);
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK) && GetMonData(defMon, MON_DATA_HP, NULL) != 0)
TrySetBattleSeminarShow();
break;
case STRINGID_SUPEREFFECTIVE:
AddMovePoints(1, moveSlot, 0, 0);
break;
case STRINGID_PKMNFORESAWATTACK:
tvPtr->side[atkSide].futureSightMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].futureSightMoveSlot = moveSlot;
break;
case STRINGID_PKMNCHOSEXASDESTINY:
tvPtr->side[atkSide].doomDesireMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].doomDesireMoveSlot = moveSlot;
break;
case STRINGID_FAINTINTHREE:
tvPtr->side[atkSide].perishSongMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].perishSongMoveSlot = moveSlot;
tvPtr->side[atkSide].perishSong = 1;
break;
case STRINGID_PKMNPERISHCOUNTFELL:
if (*perishCount == 0)
tvPtr->side[atkSide].faintCause = 10;
break;
case STRINGID_PKMNWISHCAMETRUE:
if (tvPtr->side[defSide].wishMonId != 0)
{
AddMovePoints(2, 3, defSide,
(tvPtr->side[defSide].wishMonId - 1) * 4 + tvPtr->side[defSide].wishMoveSlot);
}
break;
case STRINGID_PKMNWANTSGRUDGE:
tvPtr->side[atkSide].grudgeMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].grudgeMoveSlot = moveSlot;
break;
case STRINGID_PKMNLOSTPPGRUDGE:
if (tvPtr->side[defSide].grudgeMonId != 0)
{
AddMovePoints(2, 4, defSide,
(tvPtr->side[defSide].grudgeMonId - 1) * 4 + tvPtr->side[defSide].grudgeMoveSlot);
}
break;
case STRINGID_PKMNTRYINGTOTAKEFOE:
tvPtr->side[atkSide].destinyBondMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].destinyBondMoveSlot = moveSlot;
break;
case STRINGID_PKMNTOOKFOE:
if (tvPtr->side[defSide].destinyBondMonId != 0)
tvPtr->side[atkSide].faintCause = 11;
break;
case STRINGID_PKMNPLANTEDROOTS:
tvPtr->pos[atkSide][atkFlank].ingrainMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[atkSide][atkFlank].ingrainMoveSlot = moveSlot;
break;
case STRINGID_PKMNABSORBEDNUTRIENTS:
if (tvPtr->pos[atkSide][atkFlank].ingrainMonId != 0)
{
AddMovePoints(2, 6, atkSide,
(tvPtr->pos[atkSide][atkFlank].ingrainMonId - 1) * 4 + tvPtr->pos[atkSide][atkFlank].ingrainMoveSlot);
}
break;
case STRINGID_PKMNANCHOREDITSELF:
if (tvPtr->pos[defSide][defFlank].ingrainMonId != 0)
{
AddMovePoints(2, 6, defSide,
(tvPtr->pos[defSide][defFlank].ingrainMonId - 1) * 4 + tvPtr->pos[defSide][defFlank].ingrainMoveSlot);
}
break;
case STRINGID_PKMNTRANSFORMEDINTO:
gBattleStruct->anyMonHasTransformed = TRUE;
break;
case STRINGID_CRITICALHIT:
AddMovePoints(0x12, moveSlot, 0, 0);
break;
case STRINGID_PKMNSSTATCHANGED:
if (gBattleTextBuff1[2] != 0)
{
if (*statStringId == STRINGID_STATSHARPLY)
AddMovePoints(0x17, moveSlot, gBattleTextBuff1[2] - 1, 0);
else
AddMovePoints(0x16, moveSlot, gBattleTextBuff1[2] - 1, 0);
}
break;
case STRINGID_PKMNSSTATCHANGED2:
if (gBattleTextBuff1[2] != 0)
{
if (gBattlerAttacker == gBattlerTarget)
{
if (*statStringId == STRINGID_STATSHARPLY)
AddMovePoints(0x17, moveSlot, gBattleTextBuff1[2] - 1, 0);
else
AddMovePoints(0x16, moveSlot, gBattleTextBuff1[2] - 1, 0);
}
else
{
AddMovePoints(0x1B, moveSlot, gBattleTextBuff1[2] - 1, 0);
}
}
break;
case STRINGID_PKMNSSTATCHANGED3:
if (gBattleTextBuff1[2] != 0)
AddMovePoints(0x18, moveSlot, gBattleTextBuff1[2] - 1, 0);
break;
case STRINGID_PKMNSSTATCHANGED4:
if (gBattleTextBuff1[2] != 0)
{
if (*statStringId == STRINGID_STATHARSHLY)
AddMovePoints(0x1A, moveSlot, gBattleTextBuff1[2] - 1, 0);
else
AddMovePoints(0x19, moveSlot, gBattleTextBuff1[2] - 1, 0);
}
break;
case STRINGID_PKMNLAIDCURSE:
tvPtr->pos[defSide][defFlank].curseMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][defFlank].curseMoveSlot = moveSlot;
break;
case STRINGID_PKMNAFFLICTEDBYCURSE:
if (GetMonData(atkMon, MON_DATA_HP, NULL)
&& tvPtr->pos[atkSide][atkFlank].curseMonId != 0)
{
AddMovePoints(8, 0, tvPtr->pos[atkSide][atkFlank].curseMonId - 1, tvPtr->pos[atkSide][atkFlank].curseMoveSlot);
tvPtr->side[atkSide].faintCause = 1;
tvPtr->side[atkSide].faintCauseMonId = atkFlank;
}
break;
case STRINGID_PKMNSEEDED:
tvPtr->pos[defSide][defFlank].leechSeedMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][defFlank].leechSeedMoveSlot = moveSlot;
break;
case STRINGID_PKMNSAPPEDBYLEECHSEED:
if (tvPtr->pos[atkSide][atkFlank].leechSeedMonId != 0)
{
AddMovePoints(8, 1, tvPtr->pos[atkSide][atkFlank].leechSeedMonId - 1, tvPtr->pos[atkSide][atkFlank].leechSeedMoveSlot);
tvPtr->side[atkSide].faintCause = 2;
tvPtr->side[atkSide].faintCauseMonId = atkFlank;
}
break;
case STRINGID_PKMNFELLINTONIGHTMARE:
tvPtr->pos[defSide][defFlank].nightmareMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][defFlank].nightmareMoveSlot = moveSlot;
break;
case STRINGID_PKMNLOCKEDINNIGHTMARE:
if (GetMonData(atkMon, MON_DATA_HP, NULL) != 0
&& tvPtr->pos[atkSide][atkFlank].nightmareMonId != 0)
{
AddMovePoints(8, 5, tvPtr->pos[atkSide][atkFlank].nightmareMonId - 1, tvPtr->pos[atkSide][atkFlank].nightmareMoveSlot);
tvPtr->side[atkSide].faintCause = 5;
tvPtr->side[atkSide].faintCauseMonId = atkFlank;
}
break;
case STRINGID_PKMNSQUEEZEDBYBIND:
case STRINGID_PKMNTRAPPEDINVORTEX:
case STRINGID_PKMNWRAPPEDBY:
case STRINGID_PKMNCLAMPED:
case STRINGID_PKMNTRAPPEDBYSANDTOMB:
tvPtr->pos[defSide][defFlank].wrapMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][defFlank].wrapMoveSlot = moveSlot;
break;
case STRINGID_PKMNHURTBY:
if (GetMonData(atkMon, MON_DATA_HP, NULL) != 0
&& tvPtr->pos[atkSide][atkFlank].wrapMonId != 0)
{
AddMovePoints(8, 6, tvPtr->pos[atkSide][atkFlank].wrapMonId - 1, tvPtr->pos[atkSide][atkFlank].wrapMoveSlot);
tvPtr->side[atkSide].faintCause = 6;
tvPtr->side[atkSide].faintCauseMonId = atkFlank;
}
break;
case STRINGID_PKMNWASBURNED:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].brnMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].brnMoveSlot = moveSlot;
break;
case STRINGID_PKMNHURTBYBURN:
if (GetMonData(atkMon, MON_DATA_HP, NULL) != 0)
{
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].brnMonId != 0)
AddMovePoints(8, 4, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].brnMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].brnMoveSlot);
tvPtr->side[atkSide].faintCause = 4;
tvPtr->side[atkSide].faintCauseMonId = gBattlerPartyIndexes[gBattlerAttacker];
}
break;
case STRINGID_PKMNWASPOISONED:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].psnMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].psnMoveSlot = moveSlot;
break;
case STRINGID_PKMNBADLYPOISONED:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].badPsnMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].badPsnMoveSlot = moveSlot;
break;
case STRINGID_PKMNHURTBYPOISON:
if (GetMonData(atkMon, MON_DATA_HP, NULL) != 0)
{
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].psnMonId != 0)
AddMovePoints(8, 2, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].psnMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].psnMoveSlot);
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].badPsnMonId != 0)
AddMovePoints(8, 3, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].badPsnMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].badPsnMoveSlot);
tvPtr->side[atkSide].faintCause = 3;
tvPtr->side[atkSide].faintCauseMonId = gBattlerPartyIndexes[gBattlerAttacker];
}
break;
case STRINGID_PKMNFELLINLOVE:
tvPtr->pos[defSide][defFlank].attractMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][defFlank].attractMoveSlot = moveSlot;
break;
case STRINGID_PKMNIMMOBILIZEDBYLOVE:
if (tvPtr->pos[atkSide][atkFlank].attractMonId != 0)
AddMovePoints(9, 0, tvPtr->pos[atkSide][atkFlank].attractMonId - 1, tvPtr->pos[atkSide][atkFlank].attractMoveSlot);
break;
case STRINGID_PKMNWASPARALYZED:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].prlzMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].prlzMoveSlot = moveSlot;
break;
case STRINGID_PKMNISPARALYZED:
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].prlzMonId != 0)
AddMovePoints(9, 2, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].prlzMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].prlzMoveSlot);
break;
case STRINGID_PKMNFELLASLEEP:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].slpMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].slpMoveSlot = moveSlot;
break;
case STRINGID_PKMNFASTASLEEP:
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].slpMonId != 0
C vars sym ewram
2018-06-30 15:35:54 +02:00
&& gBattleMsgDataPtr->currentMove != MOVE_SNORE
&& gBattleMsgDataPtr->currentMove != MOVE_SLEEP_TALK)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
AddMovePoints(9, 3, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].slpMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].slpMoveSlot);
break;
case STRINGID_PKMNWASFROZEN:
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].frzMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->mon[effSide][gBattlerPartyIndexes[gEffectBattler]].frzMoveSlot = moveSlot;
break;
case STRINGID_PKMNISFROZEN:
if (tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].frzMonId != 0)
AddMovePoints(9, 4, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].frzMonId - 1, tvPtr->mon[atkSide][gBattlerPartyIndexes[gBattlerAttacker]].frzMoveSlot);
break;
case STRINGID_PKMNWASCONFUSED:
tvPtr->pos[effSide][effFlank].confusionMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[effSide][effFlank].confusionMoveSlot = moveSlot;
break;
case STRINGID_ITHURTCONFUSION:
if (tvPtr->pos[atkSide][atkFlank].confusionMonId != 0)
AddMovePoints(9, 1, tvPtr->pos[atkSide][atkFlank].confusionMonId - 1, tvPtr->pos[atkSide][atkFlank].confusionMoveSlot);
tvPtr->side[atkSide].faintCause = 12;
break;
case STRINGID_SPIKESSCATTERED:
tvPtr->side[defSide].spikesMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[defSide].spikesMoveSlot = moveSlot;
break;
case STRINGID_PKMNHURTBYSPIKES:
if (tvPtr->side[scriptingSide].spikesMonId != 0)
{
AddMovePoints(10, scriptingSide ^ BIT_SIDE, tvPtr->side[scriptingSide].spikesMonId - 1, tvPtr->side[scriptingSide].spikesMoveSlot);
tvPtr->side[scriptingSide].faintCause = 7;
}
break;
case STRINGID_PKMNBLEWAWAYSPIKES:
tvPtr->side[atkSide].spikesMonId = 0;
tvPtr->side[atkSide].spikesMoveSlot = 0;
break;
case STRINGID_FIREWEAKENED:
tvPtr->pos[atkSide][atkFlank].waterSportMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[atkSide][atkFlank].waterSportMoveSlot = moveSlot;
break;
case STRINGID_ELECTRICITYWEAKENED:
tvPtr->pos[atkSide][atkFlank].mudSportMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[atkSide][atkFlank].mudSportMoveSlot = moveSlot;
break;
case STRINGID_ATTACKERFAINTED:
AddPointsOnFainting(FALSE);
case STRINGID_RETURNMON:
if (tvPtr->pos[atkSide][atkFlank].waterSportMonId != 0)
{
tvPtr->pos[atkSide][atkFlank].waterSportMonId = 0;
tvPtr->pos[atkSide][atkFlank].waterSportMoveSlot = 0;
}
if (tvPtr->pos[atkSide][atkFlank].mudSportMonId != 0)
{
tvPtr->pos[atkSide][atkFlank].mudSportMonId = 0;
tvPtr->pos[atkSide][atkFlank].mudSportMoveSlot = 0;
}
break;
case STRINGID_TARGETFAINTED:
AddPointsOnFainting(TRUE);
if (tvPtr->pos[atkSide][defFlank].waterSportMonId != 0)
{
tvPtr->pos[atkSide][defFlank].waterSportMonId = 0;
tvPtr->pos[atkSide][defFlank].waterSportMoveSlot = 0;
}
if (tvPtr->pos[atkSide][defFlank].mudSportMonId != 0)
{
tvPtr->pos[atkSide][defFlank].mudSportMonId = 0;
tvPtr->pos[atkSide][defFlank].mudSportMoveSlot = 0;
}
break;
case STRINGID_PKMNRAISEDDEF:
case STRINGID_PKMNRAISEDDEFALITTLE:
tvPtr->side[atkSide].reflectMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].reflectMoveSlot = moveSlot;
break;
case STRINGID_PKMNRAISEDSPDEF:
case STRINGID_PKMNRAISEDSPDEFALITTLE:
tvPtr->side[atkSide].lightScreenMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].lightScreenMoveSlot = moveSlot;
break;
case STRINGID_PKMNSXWOREOFF:
if (*finishedMoveId == MOVE_REFLECT)
{
tvPtr->side[atkSide].reflectMonId = 0;
tvPtr->side[atkSide].reflectMoveSlot = 0;
}
if (*finishedMoveId == MOVE_LIGHT_SCREEN)
{
tvPtr->side[atkSide].lightScreenMonId = 0;
tvPtr->side[atkSide].lightScreenMoveSlot = 0;
}
if (*finishedMoveId == MOVE_MIST)
{
tvPtr->side[atkSide].mistMonId = 0;
tvPtr->side[atkSide].mistMoveSlot = 0;
}
break;
case STRINGID_PKMNCOVEREDBYVEIL:
tvPtr->side[atkSide].safeguardMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].safeguardMoveSlot = moveSlot;
break;
case STRINGID_PKMNUSEDSAFEGUARD:
if (tvPtr->side[defSide].safeguardMonId != 0)
AddMovePoints(15, 0, tvPtr->side[defSide].safeguardMonId - 1, tvPtr->side[defSide].safeguardMoveSlot);
break;
case STRINGID_PKMNSAFEGUARDEXPIRED:
tvPtr->side[atkSide].safeguardMonId = 0;
tvPtr->side[atkSide].safeguardMoveSlot = 0;
break;
case STRINGID_PKMNSHROUDEDINMIST:
tvPtr->side[atkSide].mistMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].mistMoveSlot = moveSlot;
break;
case STRINGID_PKMNPROTECTEDBYMIST:
if (tvPtr->side[defSide].mistMonId != 0)
AddMovePoints(16, 0, tvPtr->side[defSide].mistMonId - 1, tvPtr->side[defSide].mistMoveSlot);
break;
case STRINGID_THEWALLSHATTERED:
tvPtr->side[defSide].reflectMonId = 0;
tvPtr->side[defSide].reflectMoveSlot = 0;
tvPtr->side[defSide].lightScreenMonId = 0;
tvPtr->side[defSide].lightScreenMoveSlot = 0;
AddMovePoints(17, 0, gBattlerPartyIndexes[gBattlerAttacker], moveSlot);
break;
case STRINGID_PKMNFLINCHED:
if (tvPtr->pos[atkSide][0].attackedByMonId != 0)
AddMovePoints(21, 0, tvPtr->pos[atkSide][0].attackedByMonId - 1, tvPtr->pos[atkSide][0].attackedByMoveSlot);
if (tvPtr->pos[atkSide][1].attackedByMonId != 0)
AddMovePoints(21, 0, tvPtr->pos[atkSide][1].attackedByMonId - 1, tvPtr->pos[atkSide][1].attackedByMoveSlot);
break;
case STRINGID_PKMNCRASHED:
case STRINGID_PKMNHITWITHRECOIL:
tvPtr->side[atkSide].faintCause = 14;
break;
}
}
static bool8 sub_817E0B8(u16 stringId)
{
s32 i = 0;
battle tv review changes
2018-03-01 01:05:34 +01:00
do
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
if (sUnknown_0860A8A4[i] == stringId)
break;
i++;
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
} while (sUnknown_0860A8A4[i] != 0xFFFF);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
if (sUnknown_0860A8A4[i] == 0xFFFF)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return TRUE;
else
return FALSE;
}
void BattleTv_SetDataBasedOnMove(u16 move, u16 weatherFlags, struct DisableStruct *disableStructPtr)
{
struct BattleTv *tvPtr;
u32 atkSide, defSide;
u8 moveSlot;
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
return;
tvPtr = &gBattleStruct->tv;
atkSide = GetBattlerSide(gBattlerAttacker);
defSide = GetBattlerSide(gBattlerTarget);
moveSlot = GetBattlerMoveSlotId(gBattlerAttacker, move);
if (moveSlot >= 4)
{
tvPtr->side[atkSide].faintCause = 15;
return;
}
tvPtr->pos[defSide][GetBattlerPosition(gBattlerAttacker) / 2].attackedByMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->pos[defSide][GetBattlerPosition(gBattlerAttacker) / 2].attackedByMoveSlot = moveSlot;
tvPtr->side[atkSide].usedMoveSlot = moveSlot;
AddMovePoints(0, moveSlot, gBattleMoves[move].effect, 0);
AddPointsBasedOnWeather(weatherFlags, move, moveSlot);
Clean battle structs
2018-10-14 18:37:52 +02:00
if (disableStructPtr->chargeTimer != 0)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
AddMovePoints(7, move, moveSlot, 0);
if (move == MOVE_WISH)
{
tvPtr->side[atkSide].wishMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide].wishMoveSlot = moveSlot;
}
if (move == MOVE_SELF_DESTRUCT || move == MOVE_EXPLOSION)
{
tvPtr->side[atkSide ^ BIT_SIDE].explosionMonId = gBattlerPartyIndexes[gBattlerAttacker] + 1;
tvPtr->side[atkSide ^ BIT_SIDE].explosionMoveSlot = moveSlot;
tvPtr->side[atkSide ^ BIT_SIDE].faintCause = 13;
tvPtr->side[atkSide ^ BIT_SIDE].explosion = 1;
}
AddMovePoints(13, gBattleMoves[move].type, gBattleMoves[move].power, 0);
AddMovePoints(14, gBattleMoves[move].type, gBattleMoves[move].power, 0);
AddMovePoints(11, gBattleMoves[move].type, 0, 0);
AddMovePoints(12, gBattleMoves[move].type, 0, 0);
}
void BattleTv_SetDataBasedOnAnimation(u8 animationId)
{
struct BattleTv *tvPtr;
u32 atkSide;
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK))
return;
tvPtr = &gBattleStruct->tv;
atkSide = GetBattlerSide(gBattlerAttacker);
switch (animationId)
{
case B_ANIM_FUTURE_SIGHT_HIT:
if (tvPtr->side[atkSide].futureSightMonId != 0)
{
AddMovePoints(2, 0, atkSide,
(tvPtr->side[atkSide].futureSightMonId - 1) * 4 + tvPtr->side[atkSide].futureSightMoveSlot);
tvPtr->side[atkSide].faintCause = 8;
}
break;
case B_ANIM_DOOM_DESIRE_HIT:
if (tvPtr->side[atkSide].doomDesireMonId != 0)
{
AddMovePoints(2, 1, atkSide,
(tvPtr->side[atkSide].doomDesireMonId - 1) * 4 + tvPtr->side[atkSide].doomDesireMoveSlot);
tvPtr->side[atkSide].faintCause = 9;
}
break;
}
}
void TryPutLinkBattleTvShowOnAir(void)
{
Undo PokeCodec's PRs This commit undoes most of PokeCodec's PRs after the debate in chat. Some harmless or completely superseded PRs have been left alone, as there is not much benefit in attempting to undo them. Reverts #1104, #1108, #1115, #1118, #1119, #1124, #1126, #1127, #1132, #1136, #1137, #1139, #1140, #1144, #1148, #1149, #1150, #1153, #1155, #1177, #1179, #1180, #1181, #1182 and #1183.
2020-09-13 09:22:50 +02:00
u16 playerBestSpecies = 0, opponentBestSpecies = 0;
s16 playerBestSum = 0, opponentBestSum = SHRT_MAX;
decompile and document battle tv
2018-02-27 20:40:09 +01:00
u8 playerBestMonId = 0, opponentBestMonId = 0;
struct BattleTvMovePoints *movePoints = NULL;
u8 countPlayer = 0, countOpponent = 0;
Undo PokeCodec's PRs This commit undoes most of PokeCodec's PRs after the debate in chat. Some harmless or completely superseded PRs have been left alone, as there is not much benefit in attempting to undo them. Reverts #1104, #1108, #1115, #1118, #1119, #1124, #1126, #1127, #1132, #1136, #1137, #1139, #1140, #1144, #1148, #1149, #1150, #1153, #1155, #1177, #1179, #1180, #1181, #1182 and #1183.
2020-09-13 09:22:50 +02:00
s16 sum = 0;
u16 species = 0;
u16 moveId = 0;
decompile and document battle tv
2018-02-27 20:40:09 +01:00
s32 i, j;
re-match TryPutLinkBattleTvShowOnAir (from #1177)
2020-10-24 03:04:28 +02:00
int zero = 0, one = 1; //needed for matching
decompile and document battle tv
2018-02-27 20:40:09 +01:00
if (gBattleStruct->anyMonHasTransformed)
return;
movePoints = &gBattleStruct->tvMovePoints;
for (i = 0; i < PARTY_SIZE; i++)
{
if (GetMonData(&gPlayerParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE)
countPlayer++;
if (GetMonData(&gEnemyParty[i], MON_DATA_SPECIES, NULL) != SPECIES_NONE)
countOpponent++;
}
if (!(gBattleTypeFlags & BATTLE_TYPE_LINK) || countPlayer != countOpponent)
return;
for (i = 0; i < PARTY_SIZE; i++)
{
species = GetMonData(&gPlayerParty[i], MON_DATA_SPECIES, NULL);
if (species != SPECIES_NONE && !GetMonData(&gPlayerParty[i], MON_DATA_IS_EGG, NULL))
{
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (sum = 0, j = 0; j < MAX_MON_MOVES; j++)
re-match TryPutLinkBattleTvShowOnAir (from #1177)
2020-10-24 03:04:28 +02:00
sum += movePoints->points[zero][i * 4 + j];
decompile and document battle tv
2018-02-27 20:40:09 +01:00
if (playerBestSum < sum)
{
playerBestMonId = i;
playerBestSum = sum;
playerBestSpecies = species;
}
}
species = GetMonData(&gEnemyParty[i], MON_DATA_SPECIES, NULL);
if (species != SPECIES_NONE && !GetMonData(&gEnemyParty[i], MON_DATA_IS_EGG, NULL))
{
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (sum = 0, j = 0; j < MAX_MON_MOVES; j++)
re-match TryPutLinkBattleTvShowOnAir (from #1177)
2020-10-24 03:04:28 +02:00
sum += movePoints->points[one][i * 4 + j];
decompile and document battle tv
2018-02-27 20:40:09 +01:00
if (opponentBestSum == sum)
{
if (GetMonData(&gEnemyParty[i], MON_DATA_EXP, NULL) > GetMonData(&gEnemyParty[opponentBestMonId], MON_DATA_EXP, NULL))
{
opponentBestMonId = i;
opponentBestSum = sum;
opponentBestSpecies = species;
}
}
else if (opponentBestSum > sum)
{
opponentBestMonId = i;
opponentBestSum = sum;
opponentBestSpecies = species;
}
}
}
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (sum = 0, i = 0, j = 0; j < MAX_MON_MOVES; j++)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
re-match TryPutLinkBattleTvShowOnAir (from #1177)
2020-10-24 03:04:28 +02:00
if (sum < movePoints->points[zero][playerBestMonId * 4 + j])
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
re-match TryPutLinkBattleTvShowOnAir (from #1177)
2020-10-24 03:04:28 +02:00
sum = movePoints->points[zero][playerBestMonId * 4 + j];
decompile and document battle tv
2018-02-27 20:40:09 +01:00
i = j;
}
}
moveId = GetMonData(&gPlayerParty[playerBestMonId], MON_DATA_MOVE1 + i, NULL);
if (playerBestSum == 0 || moveId == 0)
return;
if (gBattleTypeFlags & BATTLE_TYPE_MULTI)
{
document frontier related
2018-07-01 11:15:42 +02:00
if ((playerBestMonId < 3 && !GetLinkTrainerFlankId(gBattleScripting.multiplayerId))
|| (playerBestMonId >= 3 && GetLinkTrainerFlankId(gBattleScripting.multiplayerId)))
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
j = (opponentBestMonId < 3) ? 0 : 1;
PutBattleUpdateOnTheAir(sub_806EF84(j, gBattleScripting.multiplayerId), moveId, playerBestSpecies, opponentBestSpecies);
}
}
else
{
PutBattleUpdateOnTheAir(gBattleScripting.multiplayerId ^ 1, moveId, playerBestSpecies, opponentBestSpecies);
}
}
static void AddMovePoints(u8 caseId, u16 arg1, u8 arg2, u8 arg3)
{
struct BattleTvMovePoints *movePoints = &gBattleStruct->tvMovePoints;
struct BattleTv *tvPtr = &gBattleStruct->tv;
u32 atkSide = GetBattlerSide(gBattlerAttacker);
u32 defSide = GetBattlerSide(gBattlerTarget);
const u16 *ptr;
s32 i;
switch (caseId)
{
case 0:
case 1:
case 18:
case 22 ... 27:
movePoints->points[atkSide][gBattlerPartyIndexes[gBattlerAttacker] * 4 + arg1] += sPointsArray[caseId][arg2];
break;
case 3 ... 7:
i = 0;
ptr = sPointsArray[caseId];
do
{
if (arg1 == ptr[i])
{
movePoints->points[atkSide][gBattlerPartyIndexes[gBattlerAttacker] * 4 + arg2] += ptr[i+1];
break;
}
i += 2;
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
} while (ptr[i] != 0xFFFF);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
break;
case 19:
tvPtr->side[arg2 ^ 1].faintCause = 0;
movePoints->points[arg2][0 * 4 + arg3] += sPointsArray[caseId][arg1];
break;
case 20:
tvPtr->side[arg2].faintCause = 0;
case 2:
movePoints->points[arg2][0 * 4 + arg3] += sPointsArray[caseId][arg1];
break;
case 17:
movePoints->points[atkSide][arg2 * 4 + arg3] += sPointsArray[caseId][arg1];
break;
case 8:
case 9:
case 15:
case 16:
case 21:
movePoints->points[atkSide ^ BIT_SIDE][arg2 * 4 + arg3] += sPointsArray[caseId][arg1];
break;
case 10:
movePoints->points[arg1][arg2 * 4 + arg3] += sPointsArray[caseId][0];
break;
case 11:
if (tvPtr->pos[defSide][0].waterSportMonId != -(tvPtr->pos[defSide][1].waterSportMonId) && arg1 == 10)
{
if (tvPtr->pos[defSide][0].waterSportMonId != 0)
{
u32 id = (tvPtr->pos[defSide][0].waterSportMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->pos[defSide][0].waterSportMoveSlot] += sPointsArray[caseId][0];
}
if (tvPtr->pos[defSide][1].waterSportMonId != 0)
{
u32 id = (tvPtr->pos[defSide][1].waterSportMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->pos[defSide][1].waterSportMoveSlot] += sPointsArray[caseId][0];
}
}
break;
case 12:
if (tvPtr->pos[defSide][0].mudSportMonId != -(tvPtr->pos[defSide][1].mudSportMonId) && arg1 == 13)
{
if (tvPtr->pos[defSide][0].mudSportMonId != 0)
{
u32 id = (tvPtr->pos[defSide][0].mudSportMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->pos[defSide][0].mudSportMoveSlot] += sPointsArray[caseId][0];
}
if (tvPtr->pos[defSide][1].mudSportMonId != 0)
{
u32 id = (tvPtr->pos[defSide][1].mudSportMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->pos[defSide][1].mudSportMoveSlot] += sPointsArray[caseId][0];
}
}
break;
case 13:
if (arg1 <= 8 && arg2 != 0 && tvPtr->side[defSide].reflectMonId != 0)
{
u32 id = (tvPtr->side[defSide].reflectMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->side[defSide].reflectMoveSlot] += sPointsArray[caseId][0];
}
break;
case 14:
if (arg1 > 8 && arg2 != 0 && tvPtr->side[defSide].lightScreenMonId != 0)
{
u32 id = (tvPtr->side[defSide].lightScreenMonId - 1) * 4;
movePoints->points[defSide][id + tvPtr->side[defSide].lightScreenMoveSlot] += sPointsArray[caseId][0];
}
break;
}
}
static void AddPointsOnFainting(bool8 targetFainted)
{
struct BattleTv *tvPtr = &gBattleStruct->tv;
u32 atkSide = GetBattlerSide(gBattlerAttacker);
u32 defSide = GetBattlerSide(gBattlerTarget);
u32 atkArrId = tvPtr->side[atkSide].faintCauseMonId;
s32 i;
if (tvPtr->side[atkSide].faintCause != 0)
{
switch (tvPtr->side[atkSide].faintCause)
{
case 1:
if (tvPtr->pos[atkSide][atkArrId].curseMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->pos[atkSide][atkArrId].curseMonId - 1) * 4 + tvPtr->pos[atkSide][atkArrId].curseMoveSlot);
}
break;
case 2:
if (tvPtr->pos[atkSide][atkArrId].leechSeedMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->pos[atkSide][atkArrId].leechSeedMonId - 1) * 4 + tvPtr->pos[atkSide][atkArrId].leechSeedMoveSlot);
}
break;
case 3:
if (tvPtr->mon[atkSide][atkArrId].psnMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->mon[atkSide][atkArrId].psnMonId - 1) * 4 + tvPtr->mon[atkSide][atkArrId].psnMoveSlot);
}
if (tvPtr->mon[atkSide][atkArrId].badPsnMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->mon[atkSide][atkArrId].badPsnMonId - 1) * 4 + tvPtr->mon[atkSide][atkArrId].badPsnMoveSlot);
}
break;
case 4:
if (tvPtr->mon[atkSide][atkArrId].brnMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->mon[atkSide][atkArrId].brnMonId - 1) * 4 + tvPtr->mon[atkSide][atkArrId].brnMoveSlot);
}
break;
case 5:
if (tvPtr->pos[atkSide][atkArrId].nightmareMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->pos[atkSide][atkArrId].nightmareMonId - 1) * 4 + tvPtr->pos[atkSide][atkArrId].nightmareMoveSlot);
}
break;
case 6:
if (tvPtr->pos[atkSide][atkArrId].wrapMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->pos[atkSide][atkArrId].wrapMonId - 1) * 4 + tvPtr->pos[atkSide][atkArrId].wrapMoveSlot);
}
break;
case 7:
if (tvPtr->side[atkSide].spikesMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->side[atkSide].spikesMonId - 1) * 4 + tvPtr->side[atkSide].spikesMoveSlot);
}
break;
case 8:
if (tvPtr->side[atkSide].futureSightMonId != 0)
{
AddMovePoints(20, 0, atkSide,
(tvPtr->side[atkSide].futureSightMonId - 1) * 4 + tvPtr->side[atkSide].futureSightMoveSlot);
}
break;
case 9:
if (tvPtr->side[atkSide].doomDesireMonId != 0)
{
AddMovePoints(20, 0, atkSide,
(tvPtr->side[atkSide].doomDesireMonId - 1) * 4 + tvPtr->side[atkSide].doomDesireMoveSlot);
}
break;
case 10:
if (tvPtr->side[atkSide].perishSong
&& tvPtr->side[atkSide].perishSongMonId - 1 != gBattlerPartyIndexes[gBattlerAttacker])
{
AddMovePoints(19, 0, atkSide,
(tvPtr->side[atkSide].perishSongMonId - 1) * 4 + tvPtr->side[atkSide].perishSongMoveSlot);
}
if (tvPtr->side[atkSide ^ BIT_SIDE].perishSong)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->side[atkSide ^ BIT_SIDE].perishSongMonId - 1) * 4 + tvPtr->side[atkSide ^ BIT_SIDE].perishSongMoveSlot);
}
break;
case 11:
if (tvPtr->side[atkSide ^ BIT_SIDE].destinyBondMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->side[atkSide ^ BIT_SIDE].destinyBondMonId - 1) * 4 + tvPtr->side[atkSide ^ BIT_SIDE].destinyBondMoveSlot);
}
break;
case 12:
for (i = 0; i < 2; i++)
{
if (tvPtr->pos[atkSide][i].confusionMonId != 0)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->pos[atkSide][i].confusionMonId - 1) * 4 + tvPtr->pos[atkSide][i].confusionMoveSlot);
}
}
break;
case 13:
if (tvPtr->side[atkSide].explosion)
{
AddMovePoints(19, 0, atkSide,
(tvPtr->side[atkSide].explosionMonId - 1) * 4 + tvPtr->side[atkSide].explosionMoveSlot);
}
if (tvPtr->side[atkSide ^ BIT_SIDE].explosion)
{
AddMovePoints(19, 0, atkSide ^ BIT_SIDE,
(tvPtr->side[atkSide ^ BIT_SIDE].explosionMonId - 1) * 4 + tvPtr->side[atkSide ^ BIT_SIDE].explosionMoveSlot);
}
break;
case 14:
if (targetFainted == TRUE)
{
AddMovePoints(20, 0, atkSide,
(gBattlerPartyIndexes[gBattlerAttacker]) * 4 + tvPtr->side[atkSide].usedMoveSlot);
}
break;
case 15:
break;
}
}
else
{
if (tvPtr->side[defSide].faintCause == 7)
{
if (tvPtr->side[defSide].spikesMonId != 0)
{
AddMovePoints(19, 0, defSide ^ BIT_SIDE,
(tvPtr->side[defSide].spikesMonId - 1) * 4 + tvPtr->side[defSide].spikesMoveSlot);
}
}
else
{
AddMovePoints(20, 0, atkSide,
(gBattlerPartyIndexes[gBattlerAttacker]) * 4 + tvPtr->side[atkSide].usedMoveSlot);
}
}
}
static void TrySetBattleSeminarShow(void)
{
s32 i;
s32 dmgByMove[4];
u16 powerOverride;
u16 currMoveSaved;
Label remaining battle types
2021-01-13 21:17:32 +01:00
if (gBattleTypeFlags & (BATTLE_TYPE_DOUBLE | BATTLE_TYPE_LINK | BATTLE_TYPE_RECORDED_LINK))
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
battle tv review changes
2018-03-01 01:05:34 +01:00
else if (GetBattlerSide(gBattlerAttacker) == B_SIDE_OPPONENT)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
Add stat stage constants
2020-08-05 02:33:05 +02:00
else if (gBattleMons[gBattlerAttacker].statStages[STAT_ACC] < DEFAULT_STAT_STAGE)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
Add stat stage constants
2020-08-05 02:33:05 +02:00
else if (gBattleMons[gBattlerTarget].statStages[STAT_EVASION] > DEFAULT_STAT_STAGE)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
battle tv review changes
2018-03-01 01:05:34 +01:00
else if (gCurrentMove == MOVE_HIDDEN_POWER || gCurrentMove == MOVE_WEATHER_BALL)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
battle tv review changes
2018-03-01 01:05:34 +01:00
else if (gBattleTypeFlags & (BATTLE_TYPE_PALACE | BATTLE_TYPE_PIKE | BATTLE_TYPE_PYRAMID))
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
battle tv review changes
2018-03-01 01:05:34 +01:00
else if (gBattleMoves[gBattleMons[gBattlerAttacker].moves[gMoveSelectionCursor[gBattlerAttacker]]].power == 0)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
i = 0;
currMoveSaved = gBattleMons[gBattlerAttacker].moves[gMoveSelectionCursor[gBattlerAttacker]];
battle tv review changes
2018-03-01 01:05:34 +01:00
do
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
if (currMoveSaved == sVariableDmgMoves[i])
break;
i++;
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
} while (sVariableDmgMoves[i] != 0xFFFF);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
if (sVariableDmgMoves[i] != 0xFFFF)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
return;
dmgByMove[gMoveSelectionCursor[gBattlerAttacker]] = gBattleMoveDamage;
currMoveSaved = gCurrentMove;
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (i = 0; i < MAX_MON_MOVES; i++)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
gCurrentMove = gBattleMons[gBattlerAttacker].moves[i];
powerOverride = 0;
if (ShouldCalculateDamage(gCurrentMove, &dmgByMove[i], &powerOverride))
{
u8 moveResultFlags;
u16 sideStatus = gSideStatuses[GET_BATTLER_SIDE(gBattlerTarget)];
gBattleMoveDamage = CalculateBaseDamage(&gBattleMons[gBattlerAttacker], &gBattleMons[gBattlerTarget], gCurrentMove,
sideStatus, powerOverride,
0, gBattlerAttacker, gBattlerTarget);
if (gStatuses3[gBattlerAttacker] & STATUS3_CHARGED_UP && gBattleMoves[gCurrentMove].type == TYPE_ELECTRIC)
gBattleMoveDamage *= 2;
if (gProtectStructs[gBattlerAttacker].helpingHand)
gBattleMoveDamage = gBattleMoveDamage * 15 / 10;
moveResultFlags = TypeCalc(gCurrentMove, gBattlerAttacker, gBattlerTarget);
dmgByMove[i] = gBattleMoveDamage;
if (dmgByMove[i] == 0 && !(moveResultFlags & MOVE_RESULT_NO_EFFECT))
dmgByMove[i] = 1;
}
}
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (i = 0; i < MAX_MON_MOVES; i++)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
if (i != gMoveSelectionCursor[gBattlerAttacker] && dmgByMove[i] > dmgByMove[gMoveSelectionCursor[gBattlerAttacker]])
{
u16 opponentSpecies, playerSpecies;
s32 bestMoveId;
if (gMoveSelectionCursor[gBattlerAttacker] != 0)
bestMoveId = 0;
else
bestMoveId = 1;
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
for (i = 0; i < MAX_MON_MOVES; i++)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
if (i != gMoveSelectionCursor[gBattlerAttacker] && dmgByMove[i] > dmgByMove[bestMoveId])
bestMoveId = i;
}
opponentSpecies = GetMonData(&gEnemyParty [gBattlerPartyIndexes[gBattlerTarget]], MON_DATA_SPECIES, NULL);
playerSpecies = GetMonData(&gPlayerParty[gBattlerPartyIndexes[gBattlerAttacker]], MON_DATA_SPECIES, NULL);
sub_80EE35C(opponentSpecies, playerSpecies, gMoveSelectionCursor[gBattlerAttacker], gBattleMons[gBattlerAttacker].moves, gBattleMons[gBattlerAttacker].moves[bestMoveId]);
break;
}
}
gBattleMoveDamage = dmgByMove[gMoveSelectionCursor[gBattlerAttacker]];
gCurrentMove = currMoveSaved;
}
static bool8 ShouldCalculateDamage(u16 moveId, s32 *dmg, u16 *powerOverride)
{
if (gBattleMoves[moveId].power == 0)
{
*dmg = 0;
return FALSE;
}
else
{
s32 i = 0;
battle tv review changes
2018-03-01 01:05:34 +01:00
do
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
if (moveId == sVariableDmgMoves[i])
break;
i++;
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
} while (sVariableDmgMoves[i] != 0xFFFF);
decompile and document battle tv
2018-02-27 20:40:09 +01:00
Remove uses of INVALID_ defines, clean up some arrays with constants, and spaces -> tabs
2018-12-05 15:31:01 +01:00
if (sVariableDmgMoves[i] != 0xFFFF)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
{
*dmg = 0;
return FALSE;
}
else if (moveId == MOVE_PSYWAVE)
{
*dmg = gBattleMons[gBattlerAttacker].level;
*dmg /= 2;
return FALSE;
}
else if (moveId == MOVE_MAGNITUDE)
{
*powerOverride = 10;
return TRUE;
}
else
{
return TRUE;
}
}
}
void BattleTv_ClearExplosionFaintCause(void)
{
if (gBattleTypeFlags & BATTLE_TYPE_LINK)
{
struct BattleTv *tvPtr = &gBattleStruct->tv;
tvPtr->side[B_SIDE_PLAYER].faintCause = 0;
tvPtr->side[B_SIDE_OPPONENT].faintCause = 0;
tvPtr->side[B_SIDE_PLAYER].faintCauseMonId = 0;
tvPtr->side[B_SIDE_OPPONENT].faintCauseMonId = 0;
tvPtr->side[B_SIDE_PLAYER].explosionMonId = 0;
tvPtr->side[B_SIDE_OPPONENT].explosionMonId = 0;
tvPtr->side[B_SIDE_PLAYER].explosionMoveSlot = 0;
tvPtr->side[B_SIDE_OPPONENT].explosionMoveSlot = 0;
tvPtr->side[B_SIDE_PLAYER].explosion = 0;
tvPtr->side[B_SIDE_OPPONENT].explosion = 0;
}
}
u8 GetBattlerMoveSlotId(u8 battlerId, u16 moveId)
{
s32 i;
struct Pokemon *party;
if (GetBattlerSide(battlerId) == B_SIDE_PLAYER)
party = gPlayerParty;
else
party = gEnemyParty;
i = 0;
while (1)
{
use max mon moves constant where able (#480) * use max mon moves constant where able * fix errors in script commands file * fix more errors
2018-12-25 18:50:15 +01:00
if (i >= MAX_MON_MOVES)
decompile and document battle tv
2018-02-27 20:40:09 +01:00
break;
if (GetMonData(&party[gBattlerPartyIndexes[battlerId]], MON_DATA_MOVE1 + i, NULL) == moveId)
break;
i++;
}
return i;
}
static void AddPointsBasedOnWeather(u16 weatherFlags, u16 moveId, u8 moveSlot)
{
if (weatherFlags & WEATHER_RAIN_ANY)
AddMovePoints(3, moveId, moveSlot, 0);
else if (weatherFlags & WEATHER_SUN_ANY)
AddMovePoints(4, moveId, moveSlot, 0);
else if (weatherFlags & WEATHER_SANDSTORM_ANY)
AddMovePoints(5, moveId, moveSlot, 0);
else if (weatherFlags & WEATHER_HAIL_ANY)
AddMovePoints(6, moveId, moveSlot, 0);
}
Copy Permalink