public void SetOverworldSpell(TargetingMenu menu, Canvas canvas, StatsBase caster)
{
targetingMenu = menu;
targetingCanvas = canvas;
overworldSpell = true;
spellCaster = caster;
}
public override void GetCommand()
{
base.GetCommand();
target = CombatManager.instance.playerTeam[Random.Range(0, CombatManager.instance.playerTeam.Count)];
if (spellList.Count > 0 && Random.Range(0f, 1f) <= chanceToUseSpell)
{
Spell spellToCast = spellList[Random.Range(0, spellList.Count)];
if (spellToCast.spellType == SpellType.Heal)
{
target = CombatManager.instance.enemyTeam[Random.Range(0, CombatManager.instance.enemyTeam.Count)];
}
CastSpell(target, spellToCast);
}
else if (Random.Range(0f, 1f) <= blockChance)
{
Defend();
}
else
{
Attack(target);
}
}
/// <summary>
/// XD
/// </summary>
/// <param name="dataList"></param>
/// <returns></returns>
private LJVStatsDatum StatsDatumFromFullLJVList(List <FullLJVDatum> dataList)
{
LJVStatsDatum statsDatum = new LJVStatsDatum();
List <double> currentDensities = new List <double>();
List <double> resistances = new List <double>();
List <double> photoCurrents = new List <double>();
List <double> luminances = new List <double>();
List <double> currentEffs = new List <double>();
List <double> powerEffs = new List <double>();
List <double> EQEs = new List <double>();
List <double> CIExs = new List <double>();
List <double> CIEys = new List <double>();
foreach (FullLJVDatum fd in dataList)
{
currentDensities.Add(Convert.ToDouble(fd.CurrentDensity));
//Debug.WriteLine("currentDensity = " + fd.CurrentDensity);
resistances.Add(Convert.ToDouble(fd.Resistance));
photoCurrents.Add(Convert.ToDouble((fd.PhotoCurrentA + fd.PhotoCurrentB) / 2.0m));
luminances.Add(Convert.ToDouble(fd.Luminance));
currentEffs.Add(Convert.ToDouble(fd.CurrentEff));
powerEffs.Add(Convert.ToDouble(fd.PowerEff));
EQEs.Add(Convert.ToDouble(fd.EQE));
CIExs.Add(Convert.ToDouble(fd.CameraCIEx));
CIEys.Add(Convert.ToDouble(fd.CameraCIEy));
}
statsDatum.Voltage = dataList.First().Voltage;
StatsBase calculator = new StatsBase();
calculator.PopulateStatsFromArrayAndRound(currentDensities.ToArray(), 13);
statsDatum.MeanCurrentDensity = Convert.ToDecimal(calculator.Mean);
statsDatum.CurrentDensityStdDev = Convert.ToDecimal(calculator.StdDev);
//Debug.WriteLine("statsDatum.MeanCurrentDensity = " + statsDatum.MeanCurrentDensity);
//Debug.WriteLine("statsDatum.CurrentDensityStdDev = " + statsDatum.CurrentDensityStdDev);
calculator.PopulateStatsFromArrayAndRound(resistances.ToArray(), 13);
statsDatum.MeanResistance = Convert.ToDecimal(calculator.Mean);
statsDatum.ResistanceStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(photoCurrents.ToArray(), 13);
statsDatum.MeanPhotoCurrent = Convert.ToDecimal(calculator.Mean);
statsDatum.PhotoCurrentStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(luminances.ToArray(), 13);
statsDatum.MeanLuminance = Convert.ToDecimal(calculator.Mean);
statsDatum.LuminanceStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(currentEffs.ToArray(), 13);
statsDatum.MeanCurrentEff = Convert.ToDecimal(calculator.Mean);
statsDatum.CurrentEffStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(powerEffs.ToArray(), 13);
statsDatum.MeanPowerEff = Convert.ToDecimal(calculator.Mean);
statsDatum.PowerEffStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(EQEs.ToArray(), 13);
statsDatum.MeanEQE = Convert.ToDecimal(calculator.Mean);
statsDatum.EQEStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(CIExs.ToArray(), 13);
statsDatum.MeanCameraCIEx = Convert.ToDecimal(calculator.Mean);
statsDatum.CameraCIExStdDev = Convert.ToDecimal(calculator.StdDev);
calculator.PopulateStatsFromArrayAndRound(CIEys.ToArray(), 13);
statsDatum.MeanCameraCIEy = Convert.ToDecimal(calculator.Mean);
statsDatum.CameraCIEyStdDev = Convert.ToDecimal(calculator.StdDev);
return(statsDatum);
}
/// <summary>
/// Ensures index exist for the collection that keeps the data for an object
/// </summary>
/// <param name="col"></param>
private void EnsureIndex(StatsBase s)
{
//get collection
var col = this.mongocollections[s.GetCollectionName()];
col.CreateIndex(s.GetIndexedKeys(), MongoDB.Driver.Builders.IndexOptions.SetUnique(true).SetDropDups(true).SetBackground(true));
}
public override void Attack(StatsBase target, int damage)
{
base.Attack(target, damage);
if (weapon.id != 0 && !weapon.appraised)
{
InventoryManager.Instance.AppraiseItem(weapon.id);
}
}
IEnumerator AttackDelay(StatsBase attacker, StatsBase target, int damage, bool ignoreDefence)
{
messageText.text += string.Format("{0} attacks!\n", attacker.characterName);
AudioPlayer.Instance.Attack();
yield return(new WaitForSeconds(timeToWait));
Attack(attacker, target, damage, ignoreDefence, false, true);
}
public void CastSpell(StatsBase target, Spell spell)
{
if (!spell.attackAll)
{
CombatManager.instance.SpellAttack(this, target, spell);
}
else
{
CombatManager.instance.SpellAttackAll(this, spell);
}
}
public virtual void Attack(StatsBase target, int damage)
{
bool isCrit = false;
if (Random.Range(0f, 1f) <= critChance)
{
isCrit = true;
}
CombatManager.instance.StartAttack(this, target, damage, isCrit);
}
public void Heal(StatsBase healer, StatsBase target, int amount, bool dontContinueAfterAttack)
{
target.Heal(amount);
messageText.text += string.Format("{0} heals {1} health.", target.characterName, amount);
AudioPlayer.Instance.HealSpell();
if (!dontContinueAfterAttack)
{
StartCoroutine(NextTurnWait());
}
}
// Update is called once per frame
public void UpdateStats(StatsBase _stats)
{
if (isPlayer)
{
if (_stats.EXP >= _stats.MaxEXP)
{
_stats.EXP -= _stats.MaxEXP;
++_stats.Level;
CalculateStats(_stats);
}
}
}
public void RefreshData() //刷新装备数据
{
TotalEquips = new StatsBase();
foreach (Equip equip in onwear)
{
if (equip != null)
{
TotalEquips.Add(equip.MFProperties);
TotalEquips.Add(equip.PProperties);
}
}
}
public void SetTarget(int index, bool targetAllies)
{
if (!targetAllies)
{
target = CombatManager.instance.enemyTeam[index];
}
else
{
target = CombatManager.instance.allAllies[index];
}
ExecuteCommand();
}
public Equipment()
{
TotalEquips = new StatsBase();
onwear = new Equip[6];
// ReSharper disable once NotAccessedVariable
/*for (int i = 0; i < 6; i++)
* {
* onwear[i] = new Equip();
* }*/
CenterControl.Centerctrl.RegisterData(this);
}
void DamagePlayer(StatsBase target)
{
if (target == null)
{
Debug.Log("UHHH TARGET HAS NO STATS!");
}
else
{
Vector2 LaunchDirection = GlobalVar.KnockbackForce * KnockbackMod * Mathf.Sign(transform.position.x - target.transform.position.x);
target.GetHit(DamageAmount, Launch, LaunchDirection);
Debug.Log("HONKADOOK CHECK THIS BOOT");
}
}
public void NextTurn()
{
DisableCommandCanvas();
if (!battleEnded)
{
messageText.text = "";
if (enemyTeam.Count > 0 && playerTeam.Count > 0)
{
turnIndex = (turnIndex + 1) % (allAllies.Count + allEnemies.Count);
if (turnIndex < turnOrder.Count && !turnOrder[turnIndex].isDead)
{
currentActor = turnOrder[turnIndex];
if (statsPanels.Keys.Contains <StatsBase>(currentActor))
{
statsPanels[currentActor].ToggleIndicator();
}
currentActor.GetCommand();
}
else
{
NextTurn();
}
}
else if (enemyTeam.Count <= 0)
{
messageText.text += ("Victory!\n");
AudioManager.Instance.SilenceAllBGM();
AudioPlayer.Instance.VictoryFanfare();
battleEnded = true;
StartCoroutine(NextTurnWait());
}
else if (playerTeam.Count <= 0)
{
messageText.text += ("The party are wiped out!\n");
AudioManager.Instance.SilenceAllBGM();
AudioPlayer.Instance.GameOver();
battleEnded = true;
gameOver = true;
StartCoroutine(NextTurnWait());
}
}
else
{
StartCoroutine(EndBattle(true));
}
}
public void Attack(StatsBase attacker, StatsBase target, int damage, bool ignoreDefence, bool lifesteal, bool showAnimation, bool dontAdvanceAfterAttack)
{
int damageTaken = target.TakeDamage(damage, ignoreDefence);
if (damageTaken > 0)
{
if (ignoreDefence)
{
messageText.text += "Critical hit!\n";
}
if (!lifesteal)
{
messageText.text += string.Format("{0} takes {1} damage.", target.characterName, damageTaken);
if (showAnimation)
{
AudioPlayer.Instance.TakeDamage();
}
}
else
{
attacker.Heal(damageTaken);
messageText.text += string.Format("Absorbs {0} HP from {1}!", damageTaken, target.characterName);
AudioPlayer.Instance.HealSpell();
}
if (target.isEnemy && showAnimation)
{
spriteManager.PlayMeleeEffect(allEnemies.IndexOf((EnemyStats)target));
if (target.currentHP > 0)
{
spriteManager.FlickerSprite(allEnemies.IndexOf((EnemyStats)target));
}
}
}
else
{
messageText.text += string.Format("{0} blocks the attack.", target.characterName);
AudioPlayer.Instance.Block();
}
if (target.isDead)
{
messageText.text += string.Format("\n{0} dies!", target.characterName);
}
if (!dontAdvanceAfterAttack)
{
StartCoroutine(NextTurnWait());
}
}
// Use this for initialization
public void Init(StatsBase _stats, bool _isPlayer = false)
{
isPlayer = _isPlayer;
if (_isPlayer)
{
if (!LoadStats()) // Check Loadable stats
{
CalculateStats(_stats);
}
}
else
{
CalculateStats(_stats);
}
}
private void SwitchToTargeting(bool targetAllies)
{
if (commandType == CommandType.Spell && currentSpell.attackAll)
{
target = CombatManager.instance.enemyTeam[0];
ExecuteCommand();
}
else
{
commandCanvas.enabled = false;
targetingCanvas.enabled = true;
spellCanvas.enabled = false;
itemCanvas.enabled = false;
targetingMenu.InitialiseTargetList(targetAllies);
}
}
public void SearchJsonStrong_themObjectCastSuccess()
{
//arrange
IFacadeJsonUtility jsonUtility = new FacadeJsonUtility();
StatsBaseJson statBase = new StatsBaseJson();
statBase.Name = "nombre";
statBase.Life = 20;
string jsonString = jsonUtility.ToJson(statBase);
//Act
StatsBase result = new StatsBase(jsonUtility.FromJson <StatsBaseJson>(jsonString));
//assert
Assert.AreEqual(statBase.Name, result.Name, "The conversion is not work");
Assert.AreEqual(statBase.Life, result.Life, "The conversion is not work");
}
IEnumerator SpellDelay(StatsBase attacker, StatsBase target, Spell spell)
{
messageText.text += string.Format("{0} casts {1}!\n", attacker.characterName, spell.name);
AudioPlayer.Instance.CastSpell();
yield return(new WaitForSeconds(timeToWait));
if (attacker.currentMP >= spell.manaCost)
{
attacker.currentMP -= spell.manaCost;
UseSpell(attacker, target, spell, false);
}
else
{
messageText.text += "Not enough MP!";
StartCoroutine(NextTurnWait());
}
}
private void UseSpell(StatsBase attacker, StatsBase target, Spell spell, bool dontContinueAfterAttack)
{
switch (spell.spellType)
{
case SpellType.None:
messageText.text += "Nothing happens!";
StartCoroutine(NextTurnWait());
break;
case SpellType.Damage:
Attack(attacker, target, spell.primaryStatValue + attacker.currentINT, false, spell.lifesteal, false, dontContinueAfterAttack);
AudioPlayer.Instance.DamageSpell();
if (target.isEnemy)
{
spriteManager.PlayMagicEffect(allEnemies.IndexOf((EnemyStats)target));
if (target.currentHP > 0)
{
spriteManager.FlickerSprite(allEnemies.IndexOf((EnemyStats)target));
}
}
break;
case SpellType.Physical:
Attack(attacker, target, spell.primaryStatValue + attacker.currentATK, false, spell.lifesteal, true, dontContinueAfterAttack);
break;
case SpellType.Heal:
if (!target.isDead)
{
Heal(attacker, target, spell.primaryStatValue + attacker.currentINT, dontContinueAfterAttack);
}
else
{
messageText.text += string.Format("But {0} is dead!", target.characterName);
}
break;
}
if (spell.id != 0 && !spell.appraised)
{
SpellInventory.Instance.AppraiseSpell(spell.id);
}
}
IEnumerator SpellDelayAll(StatsBase attacker, Spell spell)
{
messageText.text += string.Format("{0} casts {1}!\n", attacker.characterName, spell.name);
AudioPlayer.Instance.CastSpell();
if (attacker.currentMP >= spell.manaCost)
{
List <StatsBase> targets = new List <StatsBase>();
if ((!attacker.isEnemy && spell.spellType != SpellType.Heal) || (attacker.isEnemy && spell.spellType == SpellType.Heal))
{
foreach (StatsBase stats in enemyTeam)
{
targets.Add(stats);
}
}
else
{
foreach (StatsBase stats in playerTeam)
{
targets.Add(stats);
}
}
foreach (StatsBase target in targets)
{
yield return(new WaitForSeconds(timeToWait));
messageText.text = "";
attacker.currentMP -= spell.manaCost;
UseSpell(attacker, target, spell, true);
spriteManager.UpdateSprites(allEnemies);
UpdateAllStats();
}
StartCoroutine(NextTurnWait());
}
else
{
yield return(new WaitForSeconds(timeToWait));
messageText.text += "Not enough MP!";
StartCoroutine(NextTurnWait());
}
}
IEnumerator BuffRefresh()
{
while (true)
{
TotalBuff = new StatsBase();
foreach (Buff buff in Bufflist)
{
TotalBuff.Add(buff.EffectStats);
buff.EffectTime--;
if (buff.EffectTime <= 0)
{
Bufflist.Remove(buff);
}
}
yield return(new WaitForSeconds(1f));
}
}
private void CalculateStats(StatsBase _stats)
{
_stats.MaxEXP = _stats.Level * MaxEXPScaling;
_stats.MaxHealth = _stats.Level * HealthScaling;
_stats.MaxStamina = _stats.Level * StaminaScaling;
_stats.Attack = _stats.Level * AttackScaling;
_stats.Defense = _stats.Level * DefenseScaling;
_stats.Health = _stats.MaxHealth;
_stats.Stamina = _stats.MaxStamina;
//Debug.Log("Name : " + m_Stats.Name);
//Debug.Log("Level : " + _stats.Level);
//Debug.Log("EXP : " + _stats.EXP);
//Debug.Log("Max EXP : " + _stats.MaxEXP);
//Debug.Log("HP : " + m_Stats.Health);
//Debug.Log("Max HP : " + _stats.MaxHealth);
//Debug.Log("Stamina : " + m_Stats.Stamina);
//Debug.Log("Max Stamina : " + m_Stats.MaxStamina);
//Debug.Log("Attack : " + m_Stats.Attack);
//Debug.Log("Defense : " + m_Stats.Defense);
}
IEnumerator ItemDelay(StatsBase attacker, StatsBase target, Item item)
{
messageText.text += string.Format("{0} uses {1}!\n", attacker.characterName, item.name);
yield return(new WaitForSeconds(timeToWait));
switch (item.spellType)
{
case SpellType.None:
messageText.text += "You can't use this!";
StartCoroutine(NextTurnWait());
break;
case SpellType.Damage:
Attack(attacker, target, item.primaryStatValue, true, false, false);
if (target.isEnemy)
{
spriteManager.PlayMagicEffect(allEnemies.IndexOf((EnemyStats)target));
if (target.currentHP > 0)
{
spriteManager.FlickerSprite(allEnemies.IndexOf((EnemyStats)target));
}
}
break;
case SpellType.Physical:
Attack(attacker, target, item.primaryStatValue, true, false, false);
break;
case SpellType.Heal:
Heal(attacker, target, item.primaryStatValue);
break;
}
if (item.type == ItemType.Consumable)
{
// Decrease quantity
InventoryManager.Instance.RemoveItem(item.id);
}
}
protected PartBase(PartRecord partRecord, Unit owner)
{
// For null weapon
if (partRecord == null)
{
return;
}
// Load stats for part
Stats = PooReader.GetStatsByTemplateId(partRecord.TemplateId);
// Set color
Color = partRecord.Color;
// Set owner
Owner = owner;
// Set the Id
Id = partRecord.Id;
// TODO: Any other info we need
}
private void Start()
{
PlayerStats = new StatsBase();
PlayerLevel = new LevelData();
ItemEnternalStats = new List <StatsBase>();
BaseStats = new StatsBase();
PlayerEquipment = new Equipment();
Bufflist = new List <Buff>();
TotalStats = new StatsBase();
TotalIntime = new StatsIntime();
TotalItemStats = new StatsBase();
TotalIntime.HpI = 50;
PlayerStats.HpM = 100;
StartCoroutine(BuffRefresh());
StartCoroutine(AutoRecover());
CenterControl.Centerctrl.RegisterData(this);
}
public override void UseItem()
{
MFProperties = StatsBase.Multi(PlayerData.Player.PlayerStats, MProperties);
//Addbuff
}
public override void CreacionDePersonaje(StatsBase statsBase)
{
CharacterBase = new ZpoppetCharacter(statsBase);
}
public CharacterTest(StatsBase baseStat) : base(baseStat)
{
}
