//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 int ComparePokeSpeed(PokemonCharacter a, PokemonCharacter b)
{
if (a.pokemonData.speed != b.pokemonData.speed)
{
return(b.pokemonData.speed - a.pokemonData.speed);
}
return(Mathf.FloorToInt(RandomScript.GetRandomValue() - .5f));
}
public override void OnInspectorGUI()
{
DrawDefaultInspector(); // for other non-HideInInspector fields
RandomScript script = (RandomScript)target;
script.boolValue = EditorGUILayout.ObjectField("Bool Value", script.boolValue, typeof(BoolValue), false) as BoolValue;
if (script.boolValue != null)
{
// draw checkbox for the bool
script.boolValue.initialValue = EditorGUILayout.Toggle("Bool Value Initial Value", script.boolValue.initialValue);
if (script.boolValue.initialValue) // if bool is true, show other fields
{
script.iField = EditorGUILayout.ObjectField("I Field", script.iField, typeof(InputField), true) as InputField;
script.Template = EditorGUILayout.ObjectField("Template", script.Template, typeof(GameObject), true) as GameObject;
}
}
}
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);
}
public int ComparePriority(EventStatus a, EventStatus b)
{
if (a.order != b.order)
{
return(-(b.order - a.order));
}
if (a.priority != b.priority)
{
return(b.priority - a.priority);
}
if (a.speed != b.speed)
{
return(b.speed - a.speed);
}
if (a.suborder != b.suborder)
{
return(-(b.suborder - a.suborder));
}
return(Mathf.FloorToInt(RandomScript.GetRandomValue() - .5f));
}
void Start()
{
BUTTON1.enabled = false;
BUTTON2.enabled = false;
BUTTON3.enabled = false;
BUTTON4.enabled = false;
BUTTON5.enabled = false;
BUTTON6.enabled = false;
index = Random.Range(0, 3);
grow = false;
start = true;
wait = 0.5f;
count = 0f;
sound = GetComponent <AudioSource>();
image = GetComponent <Image>();
AS = GameObject.Find("Info").GetComponent <AddScript>();
RS = GameObject.Find("Buttons").GetComponent <RandomScript>();
BG1 = GameObject.Find("BG1").GetComponent <BackgroundScript>();
BG2 = GameObject.Find("BG2").GetComponent <BackgroundScript>();
BG3 = GameObject.Find("BG3").GetComponent <BackgroundScript>();
BG4 = GameObject.Find("BG4").GetComponent <BackgroundScript>();
image1 = GameObject.Find("Button1").GetComponent <Image>();
image2 = GameObject.Find("Button2").GetComponent <Image>();
image3 = GameObject.Find("Button3").GetComponent <Image>();
image4 = GameObject.Find("Button4").GetComponent <Image>();
image5 = GameObject.Find("Button5").GetComponent <Image>();
image6 = GameObject.Find("Button6").GetComponent <Image>();
image7 = GameObject.Find("Button7").GetComponent <Image>();
monster = GameObject.Find("MonsterHB").GetComponent <MonsterScript>();
HS = GameObject.Find("Score").GetComponent <HighscoreScript>();
playerMoveRend = GameObject.Find("Player").GetComponent <SpriteRenderer>();
playerMoveAnim = GameObject.Find("Player").GetComponent <Animator>();
playerFallRend = GameObject.Find("player").GetComponent <SpriteRenderer>();
PlayerFallAnim = GameObject.Find("player").GetComponent <Animator>();
}
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);
}
//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));
}
//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);
}
public int ModifyDamage(int baseDamage, Pokemon pokemon, Pokemon target, ActiveMove activeMove)
{
Globals.Type type = activeMove.activeData.moveData.type;
baseDamage += 2;
RelayVar relayVar;
//MultiTarget should go here but not needed
//Weather modifier
relayVar = new RelayVar(integerValue: baseDamage);
relayVar = RunEvent("WeatherModifyDamage", pokemon.targetData, target.myPokemon, activeMove.activeData.moveData, relayVar);
baseDamage = relayVar.integerValue;
Debug.Log("Weather modifier: " + baseDamage);
//crit
if (activeMove.activeData.crit)
{
baseDamage = Mathf.FloorToInt(baseDamage * 1.5f);
}
Debug.Log("Crit modifier: " + baseDamage);
//Not a modifier
baseDamage = RandomScript.Randomizer(baseDamage);
Debug.Log("Random modifier: " + baseDamage);
//STAB
if (pokemon.HasType(type))
{
baseDamage = Mathf.FloorToInt(baseDamage * ((activeMove.activeData.stab != -1) ? activeMove.activeData.stab : 1.5f));
}
Debug.Log("STAB modifier: " + baseDamage);
//Types
activeMove.activeData.typeMod = Mathf.Clamp(target.RunEffectiveness(activeMove), -6, 6);
if (activeMove.activeData.typeMod > 0)
{
for (int i = 0; i < activeMove.activeData.typeMod; i++)
{
baseDamage *= 2;
}
}
if (activeMove.activeData.typeMod < 0)
{
for (int i = 0; i > activeMove.activeData.typeMod; i--)
{
baseDamage = Mathf.FloorToInt(baseDamage / 2f);
}
}
Debug.Log("Types modifier: " + baseDamage);
//Burn Status
if (pokemon.statusId == "brn" && activeMove.activeData.moveData.category == Globals.MoveCategory.Physical && !pokemon.HasAbilityActive(new string[] { "guts" }))
{
if (activeMove.id != "facade")
{
baseDamage = Mathf.FloorToInt(baseDamage * 0.5f);
}
}
Debug.Log("Burn modifier: " + baseDamage);
// Final modifier. Modifiers that modify damage after min damage check, such as Life Orb.
relayVar = new RelayVar(integerValue: baseDamage);
relayVar = RunEvent("ModifyDamage", pokemon.targetData, target.myPokemon, activeMove.activeData.moveData, relayVar);
baseDamage = relayVar.integerValue;
Debug.Log("other modifier: " + baseDamage);
//Z breaking protect
if (activeMove.activeData.zPowered && activeMove.activeData.zBrokeProtect)
{
baseDamage = Mathf.FloorToInt(baseDamage * 0.25f);
}
Debug.Log("z break protect modifier: " + baseDamage);
if (baseDamage < 1)
{
baseDamage = 1;
}
return(Mathf.FloorToInt(baseDamage));
}
//I think it will be used for direct damages
public int GetDamage(Pokemon pokemon, Pokemon target, ActiveMove activeMove, int directDamage = -1)//movedata comes from active move?? //DirectDamage for confusion and stuff
{
MoveData moveData = activeMove.activeData.moveData;
RelayVar relayVar;
if (moveData == null && directDamage == -1)
{
return(-1); //No moveData and no directDamage
}
if (directDamage != -1)
{
moveData = new MoveData(basePower: directDamage,
type: Globals.Type.Unknown,
category: Globals.MoveCategory.Physical,
willCrit: false);
}
//if not ignoreImmunity return false (do it before?
/*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 RelayVar();
moveData.eventMethods.StartCallback("damageCallback", this, relayVar, target.targetData, pokemon.myPokemon, null);
return(relayVar.integerValue);
}
if (moveData.damageByLevel)
{
return(pokemon.level); //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 = moveData.basePower;
if (moveData.eventMethods.basePowerCallback != null)
{
relayVar = new RelayVar();
moveData.eventMethods.StartCallback("basePowerCallback", this, relayVar, target.targetData, pokemon.myPokemon, 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
Debug.Log("Power after basePowerCallback: " + basePower);
//CritRatio
int[] critMultiplier = { 0, 24, 8, 2, 1 };
relayVar = new RelayVar(integerValue: moveData.critRatio);
relayVar = RunEvent("ModifyCritRatio", pokemon.targetData, target.myPokemon, moveData, relayVar);
int critRatio = Mathf.Clamp(relayVar.integerValue, 0, 4);
//Set crit
activeMove.activeData.crit = moveData.willCrit;
if (!activeMove.activeData.crit)
{
activeMove.activeData.crit = RandomScript.RandomChance(1, critMultiplier[critRatio]);
}
if (activeMove.activeData.crit)
{
relayVar = new RelayVar(booleanValue: activeMove.activeData.crit);
relayVar = RunEvent("CriticalHit", target.targetData, null, moveData);
activeMove.activeData.crit = relayVar.booleanValue;
}
//Happens after crit calculation
relayVar = new RelayVar(integerValue: basePower);
relayVar = RunEvent("BasePower", pokemon.targetData, target.myPokemon, moveData, relayVar, true);
if (relayVar.getEndEvent() && relayVar.integerValue != -1)
{
return(-1);
}
basePower = Mathf.Max(1, relayVar.integerValue);
Debug.Log("Power after basepower: " + basePower);
//Starting?
int level = pokemon.level;
Pokemon attacker = pokemon;
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) : attacker.boosts.GetBoostValue(attackStat);
int defBoosts = (moveData.useSourceDefensive) ? attacker.boosts.GetBoostValue(defenseStat) : defender.boosts.GetBoostValue(defenseStat);
bool ignoreNegativeOffensive = moveData.ignoreNegativeOffensive;
bool ignorePositiveDefensive = moveData.ignorePositiveDefensive;
if (activeMove.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 = attacker.CalculateStat(attackStat, atkBoosts);
}
if (moveData.useSourceDefensive)
{
defense = attacker.CalculateStat(defenseStat, defBoosts);
}
else
{
defense = defender.CalculateStat(defenseStat, defBoosts);
}
Debug.Log("attack: " + attack + " defense: " + defense);
//Apply stat modifiers
relayVar = new RelayVar(integerValue: attack);
relayVar = RunEvent("Modify" + attackStat, attacker.targetData, defender.myPokemon, moveData, relayVar);
attack = relayVar.integerValue;
relayVar = new RelayVar(integerValue: defense);
relayVar = RunEvent("Modify" + defenseStat, defender.targetData, attacker.myPokemon, moveData, relayVar);
defense = relayVar.integerValue;
Debug.Log("After modifiers attack: " + attack + " defense: " + defense);
//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);
Debug.Log("baseDamage: " + baseDamage);
// Calculate damage modifiers separately (order differs between generations)
return(ModifyDamage(baseDamage, pokemon, target, activeMove));
}
