void PrepareDamageData()
{
activeData.pokemonLevel = source.pokemonData.level;
activeData.pokemonBoosts = source.pokemonData.boosts.ShallowCopy();
activeData.pokemonStats = source.pokemonData.stats.ShallowCopy();
activeData.pokemonWasInWonderRoom = source.pokemonData.inWonderRoom;
Battle.RelayVar relayVar;
//Weather modifier
relayVar = new Battle.RelayVar(integerValue: 100);
relayVar = battle.RunEvent("WeatherModifyDamage", source.targetScript, null, activeData.moveData, relayVar);
activeData.weatherModifier = relayVar.integerValue / 100f;
//Not a modifier
activeData.randomModifier = RandomScript.Randomizer(100) / 100f;
//STAB
if (source.pokemonData.HasType(activeData.moveType))
{
activeData.stabModifier = ((activeData.stab != -1) ? activeData.stab : 1.5f);
}
else
{
activeData.stabModifier = 1;
}
bool hitResult = !battle.SingleEvent("PrepareHit", activeData.moveData, null, null, source, activeData.moveData).getEndEvent();
//if (!hitResult) return false;
battle.RunEvent("PrepareHit", source.targetScript, null, activeData.moveData);
}
public static Battle.RelayVar PsnOnResidual(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
Pokemon pokemon = ((PokemonCharacter)target.sourceElement).pokemonData;
battle.Damage(pokemon.maxhp / 8);
return(relayVar);
}
//OnBeforeMove
public static Battle.RelayVar ParOnBeforeMove(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
if (RandomScript.RandomChance(1, 4))
{
relayVar.EndEventHere();
}
return(relayVar);
}
public static Battle.RelayVar FlinchOnBeforeMove(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
Debug.Log("You are not sup-POSED to be hia?");
if (battle.RunEvent("Flinch", target).getEndEvent())
{
return(relayVar);
}
relayVar.EndEventHere();
return(relayVar);
}
//onBasePower
public static Battle.RelayVar TechnicianOnBasePower(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
int basePower = relayVar.integerValue;
if (basePower <= 60)
{
relayVar.integerValue = Mathf.FloorToInt(basePower * 1.5f);
}
return(relayVar);
}
//OnModifySpa
public static Battle.RelayVar OvergrowOnModifySpA(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
MoveData move = (MoveData)effect;
Pokemon attacker = ((PokemonCharacter)target.sourceElement).pokemonData;
if (move.type == Globals.Type.Grass && attacker.hp <= attacker.maxhp / 3)
{
Debug.Log("Overgrow boost Spa");
// this.chainModify(1.5); //TODO
}
return(relayVar);
}
//OnModifySpe
public static Battle.RelayVar ParOnModifySpe(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
if (!(target.sourceElement is PokemonCharacter))
{
return(relayVar);
}
Pokemon pokemon = ((PokemonCharacter)target.sourceElement).pokemonData;
if (pokemon.HasAbilityActive(new string[] { "quickfeet" }))
{
relayVar.integerValue = Mathf.FloorToInt(relayVar.integerValue * .5f);
}
return(relayVar);
}
//OnTakeItem
public static Battle.RelayVar MegaStoneOnTakeItem(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
ItemData item = (ItemData)relayVar.effectValue;
Pokemon pSource = ((PokemonCharacter)source).pokemonData;
if (item.megaEvolves == pSource.baseTemplate.baseSpecies)
{
relayVar.EndEventHere();
}
else
{
relayVar.booleanValue = true;
}
return(relayVar);
}
int CalculateMoveStat(string statName, int boost = 0, int modifier = 1)
{
statName = Globals.getId(statName);
if (statName == "hp")
{
return(source.pokemonData.maxhp);
}
//Should be baseStat???
int stat = activeData.pokemonStats.GetStatValue(statName);
if (activeData.pokemonWasInWonderRoom)
{
if (statName == "def")
{
stat = activeData.pokemonStats.GetStatValue("spd");
}
else if (statName == "spd")
{
stat = activeData.pokemonStats.GetStatValue("def");
}
}
//BOOST
Globals.BoostsTable boosts = new Globals.BoostsTable();
boosts.SetBoostValue(statName, boost);
Battle.RelayVar relayVar = new Battle.RelayVar(boosts: boosts);
relayVar = battle.RunEvent("ModifyBoost", source.targetScript, null, null, relayVar);
boost = relayVar.boosts.GetBoostValue(statName);
boost = Mathf.Clamp(boost, -6, 6);
if (boost >= 0)
{
stat = Mathf.FloorToInt(stat * boosts.boostTable[boost]);
}
else
{
stat = Mathf.FloorToInt(stat / boosts.boostTable[-boost]);
}
//END BOOST
//stat modifier
stat = stat * modifier; //if float problems check showdown github
return(stat);
}
public static Battle.RelayVar ConfusionOnBeforeMove(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
Pokemon poke = ((PokemonCharacter)target.sourceElement).pokemonData;
//Discount time not here anymore
if (!RandomScript.RandomChance(1, 3))
{
return(relayVar);
}
battle.Damage(battle.GetDamage(poke, poke, null, 40), poke.targetData, poke.myPokemon,
new MoveData(id: "confused",
effectType: Globals.EffectTypes.Move,
type: Globals.Type.Unknown));
relayVar.EndEventHere();
return(relayVar);
}
int ModifyDamage(int baseDamage, Pokemon target)
{
Globals.Type type = activeData.moveType;
baseDamage += 2;
Battle.RelayVar relayVar;
//Weather modifier calculated on the beginning
baseDamage = Mathf.FloorToInt(baseDamage * activeData.weatherModifier);
//crit
if (activeData.crit)
{
baseDamage = Mathf.FloorToInt(baseDamage * 1.5f);
}
//Not a modifier calculated on the beginning
baseDamage = Mathf.FloorToInt(baseDamage * activeData.randomModifier);
//STAB calculated on the beginning
baseDamage = Mathf.FloorToInt(baseDamage * activeData.stabModifier);
//Types
activeData.typeMod = Mathf.Clamp(target.RunEffectiveness(this), -6, 6);
if (activeData.typeMod > 0)
{
for (int i = 0; i < activeData.typeMod; i++)
{
baseDamage *= 2;
}
}
if (activeData.typeMod < 0)
{
for (int i = 0; i > activeData.typeMod; i--)
{
baseDamage = Mathf.FloorToInt(baseDamage / 2f);
}
}
//Burn Status
if (source.pokemonData.statusId == "brn" && activeData.moveData.category == Globals.MoveCategory.Physical && !source.pokemonData.HasAbilityActive(new string[] { "guts" }))
{
if (activeData.moveId != "facade")
{
baseDamage = Mathf.FloorToInt(baseDamage * 0.5f);
}
}
// Final modifier. Modifiers that modify damage after min damage check, such as Life Orb.
relayVar = new Battle.RelayVar(integerValue: baseDamage);
relayVar = battle.RunEvent("ModifyDamage", source.targetScript, target.myPokemon, activeData.moveData, relayVar);
baseDamage = relayVar.integerValue;
//Z breaking protect
if (activeData.zPowered && activeData.zBrokeProtect)
{
baseDamage = Mathf.FloorToInt(baseDamage * 0.25f);
}
if (baseDamage < 1)
{
baseDamage = 1;
}
return(Mathf.FloorToInt(baseDamage));
}
//OnStart
public static Battle.RelayVar ConfusionOnStart(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
battle.effectDataInEvent.time = RandomScript.RandomBetween(2, 6);
return(relayVar);
}
//This has to be called after immunities, setting zbroke protect and all of the tryhit and movehit things
int GetDamage(Pokemon target)
{
MoveData moveData = activeData.moveData;
Battle.RelayVar relayVar;
/*RETURN DIRECT DAMAGE*/
if (moveData.ohko != Globals.OHKO.Null)
{
return(target.maxhp); //Fissure, Sheer cold
}
if (moveData.eventMethods.damageCallback != null) //mirro coat, naturesmaddnes, hyper fang...
{
relayVar = new Battle.RelayVar();
moveData.eventMethods.StartCallback("damageCallback", battle, relayVar, target.targetData, source, null);
return(relayVar.integerValue);
}
if (moveData.damageByLevel)
{
return(activeData.pokemonLevel); //nightshade, seismic toss
}
if (moveData.damage != -1)
{
return(moveData.damage); //Dragon rage, sonic boom
}
/*USING BASE POWER*/
//Category
Globals.MoveCategory category = (moveData.category == Globals.MoveCategory.Null) ? Globals.MoveCategory.Physical : moveData.category;
if (moveData.defensiveCategory == Globals.MoveCategory.Null)
{
category = moveData.defensiveCategory;
}
//BasePower
int basePower = activeData.basePower;
if (moveData.eventMethods.basePowerCallback != null)
{
relayVar = new Battle.RelayVar();
moveData.eventMethods.StartCallback("basePowerCallback", battle, relayVar, target.targetData, source, moveData);
basePower = relayVar.integerValue;
}
if (basePower < 0)
{
return(-1); //Return -1 means no dealing damage
}
basePower = Mathf.Max(1, basePower); //Min value will be 1
//CritRatio
int[] critMultiplier = { 0, 24, 8, 2, 1 };
relayVar = new Battle.RelayVar(integerValue: moveData.critRatio);
relayVar = battle.RunEvent("ModifyCritRatio", source.targetScript, target.myPokemon, moveData, relayVar);
int critRatio = Mathf.Clamp(relayVar.integerValue, 0, 4);
//Set crit
activeData.crit = moveData.willCrit;
if (!activeData.crit)
{
activeData.crit = RandomScript.RandomChance(1, critMultiplier[critRatio]);
}
if (activeData.crit)
{
relayVar = new Battle.RelayVar(booleanValue: activeData.crit);
relayVar = battle.RunEvent("CriticalHit", target.targetData, null, moveData);
activeData.crit = relayVar.booleanValue;
}
//Happens after crit calculation
relayVar = new Battle.RelayVar(integerValue: basePower);
relayVar = battle.RunEvent("BasePower", source.targetScript, target.myPokemon, moveData, relayVar, true);
if (relayVar.getEndEvent() && relayVar.integerValue != -1)
{
return(0);
}
basePower = Mathf.Max(1, relayVar.integerValue);
//Starting?
int level = activeData.pokemonLevel;
Pokemon defender = target;
string attackStat = (category == Globals.MoveCategory.Physical) ? "Atk" : "SpA";
string defenseStat = (category == Globals.MoveCategory.Physical) ? "Def" : "SpD";
//statTable
int attack;
int defense;
int atkBoosts = (moveData.useTargetOffensive) ? defender.boosts.GetBoostValue(attackStat) : activeData.pokemonBoosts.GetBoostValue(attackStat);
int defBoosts = (moveData.useSourceDefensive) ? activeData.pokemonBoosts.GetBoostValue(defenseStat) : defender.boosts.GetBoostValue(defenseStat);
bool ignoreNegativeOffensive = moveData.ignoreNegativeOffensive;
bool ignorePositiveDefensive = moveData.ignorePositiveDefensive;
if (activeData.crit)
{
ignoreNegativeOffensive = true;
ignorePositiveDefensive = true;
}
bool ignoreOffensive = moveData.ignoreOffensive || (ignoreNegativeOffensive && atkBoosts < 0);
bool ignoreDefensive = moveData.ignoreDefensive || (ignorePositiveDefensive && defBoosts > 0);
if (ignoreOffensive)
{
//this.debug('Negating (sp)atk boost/penalty.');
atkBoosts = 0;
}
if (ignoreDefensive)
{
//this.debug('Negating (sp)def boost/penalty.');
defBoosts = 0;
}
if (moveData.useTargetOffensive)
{
attack = defender.CalculateStat(attackStat, atkBoosts);
}
else
{
attack = CalculateMoveStat(attackStat, atkBoosts);
}
if (moveData.useSourceDefensive)
{
defense = CalculateMoveStat(defenseStat, defBoosts);
}
else
{
defense = defender.CalculateStat(defenseStat, defBoosts);
}
//Apply stat modifiers
relayVar = new Battle.RelayVar(integerValue: attack);
relayVar = battle.RunEvent("Modify" + attackStat, source.targetScript, defender.myPokemon, moveData, relayVar);
attack = relayVar.integerValue;
relayVar = new Battle.RelayVar(integerValue: defense);
relayVar = battle.RunEvent("Modify" + defenseStat, defender.targetData, source, moveData, relayVar);
defense = relayVar.integerValue;
//int(int(int(2 * L / 5 + 2) * A * P / D) / 50);
int baseDamage = Mathf.FloorToInt(Mathf.FloorToInt(Mathf.FloorToInt(2f * level / 5f + 2f) * basePower * attack / defense) / 50f);
return(ModifyDamage(baseDamage, target));
}
public static Battle.RelayVar EndEventOnTakeItem(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
relayVar.EndEventHere();
return(relayVar);
}
public static Battle.RelayVar TestOnModifyAtk(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
relayVar.integerValue = 10;
return(relayVar);
}
public static Battle.RelayVar TestingStuff(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
relayVar.integerValue++;
return(relayVar);
}
protected int MoveHit(TargetableElement target, EffectData moveData = null, bool isSecondary = false, bool isSelf = false)
{
int damage = -1;
if (moveData == null)
{
moveData = activeData.moveData;
}
/*
* TryHitField (singleevent)
* TryHitSide (singleevent)
* TryHit (singleevent)
* TryPrimaryHit (runevent)
*/
if (target.sourceElement is PokemonCharacter)
{
int didSomething = -1;
Pokemon pokeTarget = ((PokemonCharacter)target.sourceElement).pokemonData;
damage = GetDamage(pokeTarget);
/*
* selfdestruct stuff
*/
if (damage >= 0 && !pokeTarget.fainted)
{
if (activeData.moveData.noFaint && damage >= pokeTarget.hp)
{
damage = pokeTarget.hp - 1;
}
damage = battle.Damage(damage, target, source, activeData.moveData);
//Damage interrumped
if (damage <= 0)
{
return(-1);
}
didSomething = 1;
}
/*
* boosts stuff
* heal stuff
* status stuff
* forceStatus stuff
* volatileStatus stuff
* sideCondition stuff
* weather stuff
* terrain stuff
* pseudoWeather stuff
* forceSwitch stuff
* selfSwitch stuff
*
* //HIT EVENTS
* HitField (singleevent)
* HitSide (singleevent)
* Hit (singleevent)
* Hit (runevent)
* AfterHit (singleevent)
*/
//if the move didnt do someting return false
if (didSomething < 0)
{
didSomething = 1;
}
if (didSomething == 0 && moveData.self == null &&
(moveData is MoveData) && ((MoveData)moveData).selfdestruct == "")
{
return(-1);
}
}
//Move has self && !selfdropped
//move has secondaries
if (moveData.secondaries != null)
{
Globals.SecondaryEffect[] secondaries = new Globals.SecondaryEffect[moveData.secondaries.Length];
for (int i = 0; i < secondaries.Length; ++i)
{
secondaries[i] = moveData.secondaries[i].DeepCopy();
}
Battle.RelayVar relayVar = new Battle.RelayVar(secondaries: secondaries);
secondaries = battle.RunEvent("ModifySecondaries", target, source, activeData.moveData, relayVar).secondaries;
foreach (Globals.SecondaryEffect secondary in secondaries)
{
int secondaryRoll = RandomScript.RandomBetween(0, 100);
if (secondary.chance < 0 || secondaryRoll < secondary.chance)
{
TreatSecondaries(target, secondary, isSelf);
}
}
}
//Dragout
//SelfSwitch
return(damage);
}
void OnCreatedMove()
{
//if (sourceEffect) move.sourceEffect = sourceEffect.id;
Battle.RelayVar relayVar = new Battle.RelayVar(effectValue: activeData.moveData);
battle.SingleEvent("ModifyMove", activeData.moveData, null, source.targetScript, null, activeData.moveData, relayVar);
activeData.moveData = (MoveData)battle.RunEvent("ModifyMove", source.targetScript, null, activeData.moveData, relayVar).effectValue;
/*ZMOVE SET STUFF*/
if (activeData.zPowered)
{
if (activeData.moveData.zMoveBoost != null)
{
battle.Boost(activeData.moveData.zMoveBoost, source.targetScript, source, new EffectData(id: "zpower"));
}
else if (activeData.moveData.zMoveEffect == "heal")
{
battle.Heal(source.pokemonData.maxhp, source.targetScript, source, new EffectData(id: "zpower"));
}
else if (activeData.moveData.zMoveEffect == "healreplacement")
{
activeData.moveData.self = new Globals.SelfEffect(sideConditionId: "healreplacement");
}
else if (activeData.moveData.zMoveEffect == "clearnegativeboost")
{
source.pokemonData.boosts.ClearNegatives();
}
else if (activeData.moveData.zMoveEffect == "redirect")
{
source.pokemonData.AddVolatile("followme", source, new EffectData(id: "zpower"));
}
else if (activeData.moveData.zMoveEffect == "crit2")
{
source.pokemonData.AddVolatile("focusenergy", source, new EffectData(id: "zpower"));
}
else if (activeData.moveData.zMoveEffect == "curse")
{
if (source.pokemonData.HasType(Globals.Type.Ghost))
{
battle.Heal(source.pokemonData.maxhp, source.targetScript, source, new EffectData(id: "zpower"));
}
else
{
battle.Boost(new Globals.BoostsTable(atk: 1), source.targetScript, source, new EffectData(id: "zpower"));
}
}
}
/*END ZMOVE STUFF*/
if (battle.SingleEvent("TryMove", activeData.moveData, null, source.targetScript, null, activeData.moveData).getEndEvent() ||
battle.RunEvent("TryMove", source.targetScript, null, activeData.moveData).getEndEvent())
{
activeData.moveData.mindBlownRecoil = false;
MakeMoveFail();
}
//Singleevent UseMoveMessage (just for magnitude number display)
if (activeData.moveData.ignoreImmunity == "")
{
activeData.moveData.ignoreImmunity = (activeData.moveData.category == Globals.MoveCategory.Status) ? "All" : "";
}
if (activeData.moveData.selfdestruct == "always")
{
source.pokemonData.Faint(source, activeData.moveData);
}
//ACCURACY
GetAccuracy();
}
int GetAccuracy()
{
//boosts table
int accuracy = activeData.moveData.accuracy;
//boosts, boost
/*HAS ACCURACY*/
if (accuracy >= 0)
{
if (!activeData.moveData.ignoreAccuracy)
{
float[] boostTable = { 1f, 4f / 3f, 5f / 3f, 2f, 7f / 3f, 8f / 3f, 3f };
Battle.RelayVar relayVar = new Battle.RelayVar(boosts: source.pokemonData.boosts.ShallowCopy());
relayVar = battle.RunEvent("ModifyBoost", source.targetScript, null, null, relayVar);
int boost = Mathf.Clamp(relayVar.boosts.GetBoostValue("accuracy"), -6, 6);
if (boost > 0)
{
accuracy = Mathf.FloorToInt(accuracy * boostTable[boost]);
}
else
{
accuracy = Mathf.FloorToInt(accuracy / boostTable[-boost]);
}
}
//ignoreEvasion here (not needed)
}
/*IS OHKO*/
if (activeData.moveData.ohko != Globals.OHKO.Null)
{
accuracy = 30;
if (activeData.moveData.ohko != Globals.OHKO.Ice && source.pokemonData.HasType(Globals.Type.Ice))
{
accuracy = 20;
}
//accuracy by level here (not used)
}
else
{
Battle.RelayVar relayVar = new Battle.RelayVar(integerValue: accuracy);
accuracy = battle.RunEvent("ModifyAccuracy", source.targetScript, null, activeData.moveData, relayVar).integerValue;
}
/*ALWAYSHITS*/
if (activeData.moveData.id == "toxic" && source.pokemonData.HasType(Globals.Type.Poison))
{
accuracy = -1;
}
else
{
Battle.RelayVar relayVar = new Battle.RelayVar(integerValue: accuracy);
accuracy = battle.RunEvent("Accuracy", source.targetScript, null, activeData.moveData, relayVar).integerValue;
}
accuracy = Mathf.Max(accuracy, 1);
activeData.accuracy = accuracy;
return(accuracy);
}
//OnModifyAtk
public static Battle.RelayVar HustleOnModifyAtk(Battle battle, Battle.RelayVar relayVar, TargetableElement target = null, BattleElement source = null, EffectData effect = null)
{
//battle.modify(relayVar.integerValue, 1.5);
return(relayVar);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Z))
{
//TYPECHART
int value = TypeChart.BattleTypeChart["" + typeDefense].damageTaken["" + typeAttack];
string result = (value == 0) ? " is ok against " : (value == 1) ? " is super effective against " : (value == 2) ? "is not very effective against " : (value == 3) ? " does not affect " : "wat";
Debug.Log(typeAttack + result + typeDefense);
}
if (Input.GetKeyDown(KeyCode.X))
{
//LOG TEMPLATEDATA
LogPokemon();
}
if (Input.GetKeyDown(KeyCode.C))
{
//BOOSTMODIFIERS STUFF
int previousMod = 6144;
int nextMod = 5325;
int nextValue = (previousMod * nextMod + 2048);
int test = nextValue >> 12;
float end = (float)test / 4096f;
float wat = (6144f / 4096f) * (5325f / 4096f);
Debug.Log("((previousMod * nextMod + 2048) >> 12) / 4096 \n" +
"((" + previousMod + "*" + nextMod + "+ 2048) >> 12) / 4096 \n" +
"((" + previousMod + " * " + nextMod + " + 2048) = " + nextValue + "\n" +
nextValue + " >> 12 = " + test + "\n" +
test + " / 4096 = " + end
);
Debug.Log("" + 6144f / 4096f + " * " + 5325f / 4096f + " = " + wat);
}
if (Input.GetKeyDown(KeyCode.V))
{
//LOG BATTLE STATS
Globals.StatsTable baseStats = new Globals.StatsTable(hp: 45, atk: 49, def: 49, spa: 65, spd: 65, spe: 45);
Globals.StatsTable stats = baseStats.ShallowCopy();// new Globals.StatsTable(hp: 45, atk: 49, def: 49, spa: 65, spd: 65, spe: 45);
PokemonSet set = new PokemonSet();
set.ivs = new Globals.StatsTable();
set.evs = new Globals.StatsTable();
set.level = 50;
set.nature = new Globals.Nature("Testing");//, plus: "hp", minus: "spe");
stats.SetBattleStats(set);
Debug.Log("Testing Stats: hp: " + stats.hp + ", atk:" + stats.atk + ", def:" + stats.def + ", spa:" + stats.spa + ", spd:" + stats.spd + ", spe:" + stats.spe);
Debug.Log("Base stats used: hp: " + baseStats.hp + ", atk:" + baseStats.atk + ", def:" + baseStats.def + ", spa:" + baseStats.spa + ", spd:" + baseStats.spd + ", spe:" + baseStats.spe);
}
if (Input.GetKeyDown(KeyCode.B))
{
//LOG HIDDEN POWER
Globals.HiddenPower hp = new Globals.HiddenPower(hpIvs);
Debug.Log("Hidden Power: " + hp.hpType + " " + hp.hpPower);
}
if (Input.GetKeyDown(KeyCode.N))
{
//LOG CAN MEGA EVOLVE
TemplateData templateData = Pokedex.BattlePokedex["rayquaza"];
PokemonSet set = new PokemonSet();
set.itemId = "abomasite";
set.movesId = new string[] { "tackle" };
Debug.Log("Can mega evolve " + CanMegaEvolve(templateData, set));
}
if (Input.GetKeyDown(KeyCode.M))
{
//LOG CAN ULTRA BURST
TemplateData templateData = Pokedex.BattlePokedex["necrozmadawnwings"];
PokemonSet set = new PokemonSet();
set.itemId = "ultranecroziumz";
set.movesId = new string[] { "tackle" };
Debug.Log("Can ultra burst " + CanUltraBurst(templateData, set));
}
if (Input.GetKeyDown(KeyCode.A))
{
//LOG POKEMON DATA
Battle battle = new Battle();
PokemonSet set = new PokemonSet(
speciesId: "bulbasaur",
name: "Flamenco",
level: 50,
gender: Globals.GenderName.M,
happiness: 100,
pokeball: "MajoBall",
shiny: false,
abilityId: "overgrow",
itemId: "normaliumz",
movesId: new string[] { "tackle", "absorb", "caca", "10000000voltthunderbolt" },
evs: new Globals.StatsTable(spd: 252, def: 252, spe: 6),
ivs: BestHiddenPowers.HiddenPowers["Ice"],
nature: Natures.BattleNatures["adamant"],
ppBoosts: new int[] { 3, 1, 0, 2 }
);
Pokemon testPoke = new Pokemon(battle, set, new Battle.Team(new PokemonSet[] { set }), null);
testPoke.LogPokemon();
}
if (Input.GetKeyDown(KeyCode.S))
{
//TESTING CALLBACK GETTERS AND CALLERS
MoveData move = Moves.BattleMovedex["test"];
Debug.Log(move.id);
Debug.Log(move.eventMethods.HasCallback("onModifyAtk"));
Debug.Log(move.eventMethods.HasCallback("onTakeItem"));
Debug.Log(move.eventMethods.HasCallback("caca"));
Debug.Log(move.eventMethods.HasCallback("id"));
Battle.RelayVar relayVar = new Battle.RelayVar();
Debug.Log("I was a " + relayVar.integerValue + " before");
move.eventMethods.StartCallback("onModifyAtk", null, relayVar, null, null, null);
Debug.Log("But now, thanks to the StartCallback method, I am a " + relayVar.integerValue);
}
if (Input.GetKeyDown(KeyCode.D))
{
//Single event test
Battle b = new Battle();
MoveData move = Moves.BattleMovedex["test"];
Battle.RelayVar tororo = b.SingleEvent("ModifyAtk", move);
Debug.Log(tororo.integerValue);
}
if (Input.GetKeyDown(KeyCode.F))
{
}
if (Input.GetKeyDown(KeyCode.Q))
{
Battle b = new Battle();
PokemonSet set1 = new PokemonSet(speciesId: "bulbasaur", name: "Tentomon", level: 50, gender: Globals.GenderName.F, abilityId: "testingrunevent", itemId: "testingrunevent", movesId: new string[] { "testingrunevent" });
Battle.Team t1 = new Battle.Team(new PokemonSet[] { set1 });
GameObject go1 = new GameObject();
PokemonCharacter pc1 = go1.AddComponent <PokemonCharacter>();
pc1.Init(b, set1, t1);
pc1.pokemonData.isActive = true;
t1.pokemons = new PokemonCharacter[] { pc1 };
t1.teamMoves = new List <ActiveMove>();
PokemonSet set2 = new PokemonSet(speciesId: "bulbasaur", name: "Tentomon", level: 50, gender: Globals.GenderName.F, abilityId: "testingrunevent", itemId: "testingrunevent", movesId: new string[] { "testingrunevent" });
Battle.Team t2 = new Battle.Team(new PokemonSet[] { set2 });
GameObject go2 = new GameObject();
PokemonCharacter pc2 = go2.AddComponent <PokemonCharacter>();
pc2.Init(b, set2, t2);
pc2.pokemonData.isActive = true;
t2.pokemons = new PokemonCharacter[] { pc2 };
t2.teamMoves = new List <ActiveMove>();
b.teams = new Battle.Team[] { t1, t2 };
MoveData move = Moves.BattleMovedex["testingrunevent"];
Battle.RelayVar relayVar = new Battle.RelayVar(integerValue: move.basePower);
relayVar = b.RunEvent("BasePower", pc1.targetScript, pc2, move, relayVar, true);
Debug.Log(relayVar.integerValue);
//public int GetDamage(Pokemon pokemon, Pokemon target, ActiveMove activeMove, int directDamage = -1)//movedata comes from active move?? //DirectDamage for confusion and stuff
GameObject go3 = new GameObject();
ActiveMove am = go3.AddComponent <ActiveMove>();
am.activeData = new ActiveMove.ActiveMoveData(move.id);
int damage = b.GetDamage(pc1.pokemonData, pc2.pokemonData, am);
Debug.Log("Damage " + damage);
}
}
public Battle.RelayVar StartCallback(string callbackName, Battle battle, Battle.RelayVar relayVar, TargetableElement target, BattleElement source, EffectData effect)
{
return(((Callbacks.EventCallback) this.GetType().GetField(callbackName).GetValue(this))(battle, relayVar, target, source, effect));
}
