private void OnGUI()
{
minSize = new Vector2(300, 300);
maxSize = new Vector2(300, 300);
EditorGUILayout.LabelField("Creation area", CustomStyles.subtitles);
GUILayout.Space(10);
if (GUILayout.Button("Create Melee Attack"))
{
MeleeAttackWindow.OpenWindow();
Close();
}
GUILayout.Space(10);
if (GUILayout.Button("Create Magic Attack"))
{
MagicAttackWindow.OpenWindow();
Close();
}
GUILayout.Space(10);
if (GUILayout.Button("Create Combination Attack"))
{
CombinationAttackWindow.OpenWindow();
Close();
}
GUILayout.Space(22);
EditorGUI.DrawRect(GUILayoutUtility.GetRect(100, 2), Color.black);
GUILayout.Space(20);
EditorGUILayout.LabelField("Edition area", CustomStyles.subtitles);
GUILayout.Space(10);
attack = (BaseAttack)EditorGUILayout.ObjectField("Attack", attack, typeof(BaseAttack), false);
if (attack != null)
{
if (attack.isCombination)
{
if (GUILayout.Button("Edit Combination Attack"))
{
LoadCombinationAttack.OpenWindow((CombinationAttack)attack);
Close();
}
}
else
{
if (attack.isMeleeAttack)
{
if (GUILayout.Button("Edit Melee Attack"))
{
LoadMeleeWindow.OpenWindow(attack);
Close();
}
}
else
{
if (GUILayout.Button("Edit Magic Attack"))
{
LoadMagicWindow.OpenWindow(attack);
Close();
}
}
}
}
}
public void PickUp(BaseAttack NewSpell, GameObject Origin)
{
bool foundItem = false;
int freeSpot = 0;
for (int i = 0; i < myAttacks.Length; i++)
{
if (myAttacks[i] == null)
{
freeSpot = i;
foundItem = true;
break;
}
}
if (foundItem)
{
myAttacks[freeSpot] = NewSpell;
Destroy(Origin);
}
else
{
Origin.GetComponent <PlayerPickUpTheThing>().myAttack = myAttacks[myCurrentObject];
Origin.GetComponent <SpriteRenderer>().sprite = myAttacks[myCurrentObject].UIElement;
myAttacks[myCurrentObject] = NewSpell;
}
SetFrames();
}
/*[Task]
* public void DoIMove2()
* {
* float distanceToTarget = Vector3.Distance(target.position, transform.position);
* movementToDo = actionManager.CalculateMove(myStats, targetStats, distanceToTarget);
* if (movementToDo != null)
* switch (movementToDo.movementType)
* {
* case BaseMovement.MovementType.goToTarget:
* goToTarget = true;
* runAway = false;
* standStill = false;
* break;
* case BaseMovement.MovementType.runAway:
* goToTarget = false;
* runAway = true;
* standStill = false;
* break;
* case BaseMovement.MovementType.standStill:
* goToTarget = false;
* runAway = false;
* standStill = true;
* break;
* }
* }*/
public void DoIAttack(BaseAttack attackGiven)
{
attackToDo = attackGiven;
float distanceToTarget = Vector3.Distance(target.position, transform.position);
if (attackToDo != null)
{
switch (attackToDo.attackType)
{
case BaseAttack.AttackType.dud:
doDudAttack = true;
break;
case BaseAttack.AttackType.melee:
lastTime = Time.time + 1f;
goToTarget = false;
runAway = false;
doMeleeAttack = true;
distance = distanceToTarget;
break;
case BaseAttack.AttackType.range:
lastTime = Time.time + 1f;
goToTarget = false;
runAway = false;
doRangeAttack = true;
distance = distanceToTarget;
break;
}
}
}
public bool CompareTo(BaseAttack atk)
{
bool same = false;
if(this.availableTime == atk.availableTime &&
this.absorb == atk.absorb &&
this.absorbValue == atk.absorbValue &&
this.hitChance == atk.hitChance &&
this.hitFormula == atk.hitFormula &&
this.hitFormula == atk.hitFormula &&
this.useRange.CompareTo(atk.useRange) &&
this.hasCritical == atk.hasCritical &&
this.overrideAnimation == atk.overrideAnimation &&
this.animationID == atk.animationID &&
this.audioName == atk.audioName &&
this.criticalAudioName == atk.criticalAudioName)
{
same = true;
for(int i=0; i<this.consume.Length; i++)
{
if(!this.consume[i].CompareTo(atk.consume[i]))
{
return false;
}
}
for(int i=0; i<this.criticalConsume.Length; i++)
{
if(!this.criticalConsume[i].CompareTo(atk.criticalConsume[i]))
{
return false;
}
}
}
return same;
}
public static void OpenWindow(BaseAttack attack)
{
var myWindow = GetWindow <LoadMeleeWindow>();
myWindow.wantsMouseMove = true;
myWindow.title = "Edit Melee Attack";
myWindow.baseAttack = attack;
for (int i = 0; i < attack.listOfColors.Count; i++)
{
myWindow.colorIndex.Add(i);
}
for (int i = 0; i < attack.listOfTags.Count; i++)
{
myWindow.tagIndex.Add(i);
}
if (myWindow.baseAttack.attackQty < 2)
{
myWindow.isMultiple = false;
}
else
{
myWindow.isMultiple = true;
}
myWindow.Show();
}
public static void TestAttack(GameObject performer, BaseAttack attackToTest)
{
if (!Application.isEditor)
{
return;
}
startPosition = performer.transform.position;
GameObject battlegroundCenter = GameObject.Find("Center Of The Battleground");
GameObject [] enemies = GameObject.FindGameObjectsWithTag("Enemy");
GameObject enemyToAttack = enemies[Random.Range(0, enemies.Length)];
GameObject [] heroes = GameObject.FindGameObjectsWithTag("Hero");
GameObject heroToAttack = heroes[Random.Range(0, heroes.Length)];
isAreaAttack = attackToTest.isAreaAttack;
centerPosition = new Vector3(battlegroundCenter.transform.position.x, startPosition.y, battlegroundCenter.transform.position.z);
attacker = performer;
if (attacker.tag == "Enemy")
{
targetPosition = new Vector3(heroToAttack.transform.position.x, startPosition.y, heroToAttack.transform.position.z);
}
else if (attacker.tag == "Hero")
{
targetPosition = new Vector3(enemyToAttack.transform.position.x, startPosition.y, enemyToAttack.transform.position.z);
}
testingAction = true;
}
/// <summary>
/// Attackオブジェクトと接触した時の処理
/// </summary>
/// <param name="enemy"></param>
virtual protected void ColliedAttack(BaseAttack enemy)
{
if (!attackParameter.attackLevel.CheckLevel(enemy.attackParameter.attackLevel))
{
SelfDestroy();
}
}
public override void OnEpisodeBegin()
{
target.GetComponent <PlayerAgent>().EndEpisode();
myStats.currentHealth = myStats.maxHealth;
myStats.health.value = myStats.maxHealth;
second = 0;
timer = 0;
timeForNextAttack = 0;
timeOnAttackSelected = -1;
attackSelected = null;
vulnerabilityTime = 0;
distance = Vector3.Distance(target.transform.localPosition, transform.localPosition);
lightAttackDone = 0;
heavyAttackDoneMiss = 0;
heavyAttackDoneHit = 0;
poisonAttackDone = 0;
stunAttackDoneMiss = 0;
stunAttackDoneHit = 0;
gustAttackDone = 0;
actionManager.ResetAttack();
/*if (counter < 4)
* behaviorParameters.BehaviorType = BehaviorType.Default;
* else if (counter < 6)
* behaviorParameters.BehaviorType = BehaviorType.HeuristicOnly;
* else
* counter = 0;*/
}
public void Start()
{
type = GetComponent <Slot>().slotItem.itemType;
playerObject = GameObject.FindGameObjectWithTag("Player");
player = playerObject.GetComponent <Player>();
playerAttack = playerObject.GetComponent <BaseAttack>();
}
/// <summary>
/// Attack�I�u�W�F�N�g�ƐڐG�������̏���
/// </summary>
/// <param name="enemy"></param>
protected virtual void ColliedAttack(BaseAttack enemy)
{
if (!attackParameter.attackLevel.CheckLevel(enemy.attackParameter.attackLevel))
{
SelfDestroy();
}
}
void Awake()
{
gameManager = GetComponentInParent <GameManager>();
myStats = GetComponent <CharacterStats>();
baseAttacks = new Dictionary <int, BaseAttack>();
target = gameManager.player;
targetStats = target.GetComponent <CharacterStats>();
actionManager = gameManager.bossActionManager;
PopulateAttackDictionary(actionManager.availableAttacks);
arenaName = transform.parent.name.Replace(" ", "");
timeOnAttackSelected = -1;
attackSelected = null;
timeForNextAttack = 0;
vulnerabilityTime = 0;
distance = Vector3.Distance(target.transform.localPosition, transform.localPosition);
lightAttackDone = 0;
heavyAttackDoneMiss = 0;
heavyAttackDoneHit = 0;
poisonAttackDone = 0;
stunAttackDoneMiss = 0;
stunAttackDoneHit = 0;
gustAttackDone = 0;
behaviorParameters = GetComponent <BehaviorParameters>();
counter = 1;
}
//creo una funzione void che chiamo Input4 Che richiederà un BaseAttack
public void Input4(BaseAttack choosenMagic)//magic attack
{
//assegno a HeroChoice.Attacker il nome dell'eroe
HeroChoice.Attacker = HeroToManage[0].name;
//assegno a HeroChoice.AttacksGameObject il game Object dell'eroe
HeroChoice.AttacksGameObject = HeroToManage[0];
//cambio il tipo di heroChoice a Player
HeroChoice.Type = "Player";
//controllo se l'attackCost è minore dell'Mp corrente dell'Eroe selezionato
if (choosenMagic.attackCost <= HeroToManage[0].GetComponent <HeroStateM>().hero.currMP)
{
//diminuisco l'MP dell'giocatore in base al costo della spell
HeroToManage[0].GetComponent <HeroStateM>().hero.currMP -= choosenMagic.attackCost;
//assengo al chosenAttack la magia scelta da player
HeroChoice.chosenAttack = choosenMagic;
//disattivo MagicsPanel
MagicsPanel.SetActive(false);
//attivo l'enemySelectPanel
EnemySelectPanel.SetActive(true);
//chiamo la funzione UpdateHeroPanel per cambiare il numero di mp
HeroToManage[0].GetComponent <HeroStateM>().UpdateHeroPanel();
}
else
{
//disattivo MagicsPanel
MagicsPanel.SetActive(false);
//attivo AttackPanel
AttackPanel.SetActive(true);
//attivo testo
testo.SetActive(true);
//imposto in active a true
isactive = true;
}
}
public override int GetHashCode()
{
int hash = 1;
if (BaseStamina != 0)
{
hash ^= BaseStamina.GetHashCode();
}
if (BaseAttack != 0)
{
hash ^= BaseAttack.GetHashCode();
}
if (BaseDefense != 0)
{
hash ^= BaseDefense.GetHashCode();
}
if (DodgeEnergyDelta != 0)
{
hash ^= DodgeEnergyDelta.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
private IEnumerator WaitAfterInput()
{
yield return(new WaitForSeconds(1));
selectEnemy = true;
selectedAttack = actionButtons[buttonNumber].GetComponent <ActionButton>().attackToPerform;
Debug.Log(selectedAttack.name);
}
void DealDamage(BaseAttack doAttack)
{
if (distance < doAttack.attackRange)
{
targetStats.currentHealth = targetStats.currentHealth - (targetStats.maxHealth * doAttack.attackDamage / 100);
targetStats.health.value = targetStats.health.value - (targetStats.maxHealth * doAttack.attackDamage / 100);
}
}
public HomingState(BaseAttack parent, Transform _target, Options option)
: base(parent)
{
target = _target;
framecount = new FrameCounter(option.time);
homingLevel = option.level;
interval = option.interval;
}
public HomingState(BaseAttack parent, Transform _target, Options option)
: base(parent)
{
target = _target;
framecount = new FrameCounter(option.time);
homingLevel = option.level;
interval = option.interval;
}
private void BuildWeapons()
{
bool weapon1NotAssigned = (m_weaponType1 == eWeaponType.NONE);
bool weapon2NotAssigned = (m_weaponType2 == eWeaponType.NONE);
do
{
if (weapon1NotAssigned)
{
m_weaponType1 = (eWeaponType)Random.Range(0, 3);
}
if (weapon2NotAssigned)
{
m_weaponType2 = (eWeaponType)Random.Range(0, 3);
}
} while (m_weaponType1 == m_weaponType2);
if (m_weaponType1 == eWeaponType.BUSTER)
{
m_attack1 = GetComponent <BusterAttack>();
}
else if (m_weaponType1 == eWeaponType.SABER)
{
m_attack1 = GetComponent <SaberAttack>();
}
else if (m_weaponType1 == eWeaponType.SHIELD)
{
m_attack1 = GetComponent <ShieldAttack>();
}
else if (m_weaponType1 == eWeaponType.TONFA)
{
m_attack1 = GetComponent <TonfaAttack>();
}
if (m_weaponType2 == eWeaponType.BUSTER)
{
m_attack2 = GetComponent <BusterAttack>();
}
else if (m_weaponType2 == eWeaponType.SABER)
{
m_attack2 = GetComponent <SaberAttack>();
}
else if (m_weaponType2 == eWeaponType.SHIELD)
{
m_attack2 = GetComponent <ShieldAttack>();
}
else if (m_weaponType2 == eWeaponType.TONFA)
{
m_attack2 = GetComponent <TonfaAttack>();
}
}
public void MagicSelection(BaseAttack Spell)
{
Spell.TurnInfo = playerChoise;
playerChoise.SetChosenAttack(Spell);
//check team and target
if (BSM.CharactersToManage[0].tag == "BlueTeam")
{
if (playerChoise.IsAoE)
{
if (playerChoise.AoeTargetSkill == BSM.BlueTeamInBattle)
{
BlueTeamAoETargetsMenu.gameObject.SetActive(true);
BlueTeamAoETargetsMenu.GetChild(0).GetComponent <Button>().interactable = true;
BlueTeamAoETargetsMenu.GetChild(1).GetComponent <Button>().interactable = false;
}
else if (playerChoise.AoeTargetSkill == BSM.RedTeamInBattle)
{
BlueTeamAoETargetsMenu.gameObject.SetActive(true);
BlueTeamAoETargetsMenu.GetChild(0).GetComponent <Button>().interactable = false;
BlueTeamAoETargetsMenu.GetChild(1).GetComponent <Button>().interactable = true;
}
}
else if (playerChoise.TargetAlly)
{
BlueTeamAllyTargetsMenu.gameObject.SetActive(true);
}
else
{
BlueTeamEnemyTargetsMenu.gameObject.SetActive(true);
}
}
else if (BSM.CharactersToManage[0].tag == "RedTeam")
{
if (playerChoise.IsAoE)
{
if (playerChoise.AoeTargetSkill == BSM.BlueTeamInBattle)
{
RedTeamAoETargetsMenu.gameObject.SetActive(true);
RedTeamAoETargetsMenu.GetChild(0).GetComponent <Button>().interactable = true;
RedTeamAoETargetsMenu.GetChild(1).GetComponent <Button>().interactable = false;
}
else if (playerChoise.AoeTargetSkill == BSM.RedTeamInBattle)
{
RedTeamAoETargetsMenu.gameObject.SetActive(true);
RedTeamAoETargetsMenu.GetChild(0).GetComponent <Button>().interactable = false;
RedTeamAoETargetsMenu.GetChild(1).GetComponent <Button>().interactable = true;
}
}
if (playerChoise.TargetAlly)
{
RedTeamAllyTargetsMenu.gameObject.SetActive(true);
}
else
{
RedTeamEnemyTargetsMenu.gameObject.SetActive(true);
}
}
}
public void Test_GetBaseAttack_ByID_GoodResult()
{
int intBaseAttackID = 1;
BaseAttack objBaseAttack = new BaseAttack();
objBaseAttack.GetBaseAttack(intBaseAttackID);
Assert.AreEqual(intBaseAttackID, objBaseAttack.BaseAttackID);
}
public void SetAttack(BaseAttack attack)
{
if (currentAttack)
{
Destroy(currentAttack);
}
currentAttack = Instantiate(attack, transform.position, Quaternion.identity);
currentAttack.transform.parent = transform;
}
private void GetReferences()
{
field = FindObjectOfType <Field>();
stepHandler = FindObjectOfType <StepHandler>();
attack = GetComponent <BaseAttack>();
move = GetComponent <Move>();
health = GetComponent <Health>();
attack.SetSquadType(squadType);
}
protected override void ColliedAttack(BaseAttack enemy)
{
level++;
sprite.spriteName = "ikaring" + level;
if (level >= MAX)
{
SelfDestroy();
}
}
void SpawnItems()
{
for (int i = 0; i < itemsSpawnSpots.Length; i++)
{
BaseAttack myItem = possibleItems[Random.Range(0, possibleItems.Length)];
itemsSpawnSpots[i].sprite = myItem.UIElement;
itemsSpawnSpots[i].gameObject.GetComponent <PlayerPickUpTheThing>().myAttack = myItem;
}
}
public void Test_GetFeatPrequisiteBaseAttackBonus_ByFeatID_GoodResult()
{
int intFeatID = 1177;
BaseAttack objBaseAttack = new BaseAttack();
objBaseAttack.GetFeatPrequisiteBaseAttackBonus(intFeatID);
Assert.AreEqual(11, objBaseAttack.BaseAttackNumber);
}
public void Defend(BaseAttack attack)
{
if (HP.Value == 0)
{
HP.Value = HP.Max;
}
HP.ChangeValue(-1 * attack.Damage);
}
public void Test_GetTalentPrequisiteBaseAttackBonus_ByTalentID_GoodResult()
{
int intTalentID = 113;
BaseAttack objBaseAttack = new BaseAttack();
objBaseAttack.GetTalentPrequisiteBaseAttackBonus(intTalentID);
Assert.AreEqual(5, objBaseAttack.BaseAttackNumber);
}
public void Test_GetTalentPrequisiteBaseAttackBonus_ByTalentID_BadResult()
{
int intTalentID = 0;
BaseAttack objBaseAttack = new BaseAttack();
objBaseAttack.GetTalentPrequisiteBaseAttackBonus(intTalentID);
Assert.IsTrue(objBaseAttack.BaseAttackNumber == 0 && objBaseAttack.BaseAttackID == 0);
}
protected override void ColliedAttack(BaseAttack enemy)
{
level++;
sprite.spriteName = "ikaring" + level;
if (level >= MAX)
{
SelfDestroy();
}
}
public void Test_GetBaseAttack_ByID_BadResult()
{
int intBaseAttackID = 0;
BaseAttack objBaseAttack = new BaseAttack();
objBaseAttack.GetBaseAttack(intBaseAttackID);
Assert.IsTrue(objBaseAttack.BaseAttackNumber == 0 && objBaseAttack.BaseAttackID == 0);
}
public void TargetMagicAttack(BaseAttack targetMagic)
{
heroChoise.attacker = heroesToManage[0].name; //storing the name of attacker
heroChoise.attacksGameObject = heroesToManage[0]; //storing attacker game object
heroChoise.type = "Hero"; //set the type to hero
heroChoise.choosenAttack = targetMagic;
magicPanel.SetActive(false);
enemySelectPanel.SetActive(true);
}
public void SaveInfo(CharacterStats bossStats, CharacterStats playerStats, BaseAttack attackChosen,float distance)
{
//Content of the file
// BOSS HEALT , ATTACK ID (DONE) , ATTACK DAMAGE , DISTANCE TO TARGET , PLAYER HEALTH
string content = bossStats.currentHealth.ToString() + ";" + attackChosen.attackID.ToString() + ";" + attackChosen.attackDamage.ToString() + ";" + distance.ToString() + ";" + playerStats.currentHealth.ToString() + "\n";
fightNumber = PlayerPrefs.GetInt("FightNumberTABOAv2", 0);
path = "D:/Documentos/Unity/Fight Logs TABOA v2/FighInfo" + fightNumber.ToString() + ".txt";
// if (!File.Exists(path))
File.AppendAllText(path, content);
}
public void Input3(BaseAttack chosenSpell)//chosen magic attack
{
heroChoice.attacker = heroesToManage[0].name;
heroChoice.attackerGameObject = heroesToManage[0];
heroChoice.type = "Hero";
heroChoice.chosenAttack = chosenSpell;
magicPanel.SetActive(false);
enemySelectPanel.SetActive(true);
}
public void Input4(BaseAttack choosenMagic)//chosen magic attack
{
HeroChoice.Attacker = HerosToManage[0].name;
HeroChoice.AttackersGameObject = HerosToManage[0];
HeroChoice.Type = "Hero";
HeroChoice.choosenAttack = choosenMagic;
MagicPanel.SetActive(false);
EnemySelectPanel.SetActive(true);
}
public int GetIDForAttack(BaseAttack atk)
{
int id = -1;
for(int i=0; i<this.baseAttack.Length; i++)
{
if(this.baseAttack[i].CompareTo(atk))
{
id = i;
break;
}
}
return id;
}
public int[] ImportOldAttack(BaseAttack[] atk, string title)
{
int[] ids = new int[atk.Length];
for(int i=0; i<atk.Length; i++)
{
ids[i] = this.GetIDForAttack(atk[i]);
// add attack if no match found
if(ids[i] == -1)
{
this.AddAttack(title+" Attack");
ids[i] = this.baseAttack.Length-1;
this.baseAttack[ids[i]].SetData(atk[i].GetData(new Hashtable()));
}
}
return ids;
}
public void LoadData()
{
ArrayList data = XMLHandler.LoadXML(dir+filename);
if(data.Count > 0)
{
foreach(Hashtable entry in data)
{
if(entry[XMLHandler.NODE_NAME] as string == CharacterData.CHARACTERS)
{
if(entry.ContainsKey(XMLHandler.NODES))
{
ArrayList subs = entry[XMLHandler.NODES] as ArrayList;
icon = new string[subs.Count];
character = new Character[subs.Count];
int count = DataHolder.StatusValueCount;
foreach(Hashtable val in subs)
{
if(val[XMLHandler.NODE_NAME] as string == CharacterData.CHARACTER)
{
// old attack conversion
BaseAttack[] tmpAtk = new BaseAttack[0];
int i = int.Parse((string)val["id"]);
icon[i] = "";
character[i] = new Character();
character[i].currentClass = int.Parse((string)val["class"]);
if(val.ContainsKey("startlevel"))
{
character[i].development.startLevel = int.Parse((string)val["startlevel"]);
}
if(val.ContainsKey("maxlevel"))
{
character[i].development.maxLevel = int.Parse((string)val["maxlevel"]);
character[i].development.Init(count);
}
character[i].baseCounter = int.Parse((string)val["basecounter"]);
if(val.ContainsKey("basecritical"))
{
character[i].baseCritical = int.Parse((string)val["basecritical"]);
}
if(val.ContainsKey("baseblock"))
{
character[i].baseBlock = int.Parse((string)val["baseblock"]);
}
if(val.ContainsKey("raceid"))
{
character[i].raceID = int.Parse((string)val["raceid"]);
}
if(val.ContainsKey("sizeid"))
{
character[i].sizeID = int.Parse((string)val["sizeid"]);
}
character[i].baseElement = int.Parse((string)val["baseelement"]);
if(val.ContainsKey("attacks"))
{
character[i].baseAttack = new int[int.Parse((string)val["attacks"])];
}
else
{
// old attack conversion
if(val.ContainsKey("baseattacks"))
{
character[i].baseAttack = new int[int.Parse((string)val["baseattacks"])];
tmpAtk = new BaseAttack[character[i].baseAttack.Length];
for(int j=0; j<tmpAtk.Length; j++)
{
tmpAtk[j] = new BaseAttack(count);
}
}
else
{
tmpAtk = new BaseAttack[1];
tmpAtk[0] = new BaseAttack(count);
tmpAtk[0].SetData(val);
}
}
if(val.ContainsKey("skills"))
{
character[i].development.skill = new SkillLearn[int.Parse((string)val["skills"])];
for(int j=0; j<character[i].development.skill.Length; j++)
{
character[i].development.skill[j] = new SkillLearn();
}
}
if(val.ContainsKey("norevive")) character[i].noRevive = true;
if(val.ContainsKey("leaveondeath")) character[i].leaveOnDeath = true;
if(val.ContainsKey("movespeed"))
{
character[i].moveSpeed = float.Parse((string)val["movespeed"]);
}
if(val.ContainsKey("movespeedformula"))
{
character[i].useMoveSpeedFormula = true;
character[i].moveSpeedFormula = int.Parse((string)val["movespeedformula"]);
}
if(val.ContainsKey("minmovespeed"))
{
character[i].minMoveSpeed = float.Parse((string)val["minmovespeed"]);
}
if(val.ContainsKey("aicontrolled"))
{
character[i].aiControlled = bool.Parse((string)val["aicontrolled"]);
if(val.ContainsKey("attackpartytarget")) character[i].attackPartyTarget = true;
if(val.ContainsKey("attacklasttarget")) character[i].attackLastTarget = true;
if(val.ContainsKey("ainearesttarget")) character[i].aiNearestTarget = true;
if(val.ContainsKey("aitimeout")) character[i].aiTimeout = float.Parse((string)val["aitimeout"]);
}
if(val.ContainsKey("ais"))
{
character[i].aiBehaviour = new AIBehaviour[int.Parse((string)val["ais"])];
for(int j=0; j<character[i].aiBehaviour.Length; j++)
{
character[i].aiBehaviour[j] = new AIBehaviour();
}
}
if(val.ContainsKey("fieldstatuschanges"))
{
character[i].fieldStatusChange = new StatusTimeChange[int.Parse((string)val["fieldstatuschanges"])];
for(int j=0; j<character[i].fieldStatusChange.Length; j++)
{
character[i].fieldStatusChange[j] = new StatusTimeChange();
}
}
if(val.ContainsKey("battlestatuschanges"))
{
character[i].battleStatusChange = new StatusTimeChange[int.Parse((string)val["battlestatuschanges"])];
for(int j=0; j<character[i].battleStatusChange.Length; j++)
{
character[i].battleStatusChange[j] = new StatusTimeChange();
}
}
ArrayList s = val[XMLHandler.NODES] as ArrayList;
foreach(Hashtable ht in s)
{
this.LoadLanguages(ht, i, subs.Count);
if(ht[XMLHandler.NODE_NAME] as string == CharacterData.PREFAB)
{
character[i].prefabName = ht[XMLHandler.CONTENT] as string;
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.PREFABROOT)
{
character[i].prefabRoot = ht[XMLHandler.CONTENT] as string;
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.STATUSVALUE)
{
int id = int.Parse((string)ht["id"]);
if(id < character[i].development.statusValue.Length)
{
for(int j=0; j<character[i].development.maxLevel; j++)
{
character[i].development.statusValue[id].levelValue[j] = int.Parse((string)ht[j.ToString()]);
}
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.SKILL)
{
int id = int.Parse((string)ht["id"]);
if(id < character[i].development.skill.Length)
{
character[i].development.skill[id].SetData(ht, false);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.ANIMATIONS)
{
character[i].battleAnimations = new BattleAnimationSettings(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.AUDIOCLIP)
{
character[i].audioClipName[int.Parse((string)ht["id"])] = ht[XMLHandler.CONTENT] as string;
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.AUTOATTACK)
{
character[i].autoAttack.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.AIMOVER)
{
character[i].aiMoverSettings.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.AIBEHAVIOUR)
{
int j = int.Parse((string)ht["id"]);
if(j < character[i].aiBehaviour.Length)
{
character[i].aiBehaviour[j].SetData(ht);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.BASEATTACK)
{
int j = int.Parse((string)ht["id"]);
if(j < tmpAtk.Length)
{
tmpAtk[j].SetData(ht);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.CONTROLMAP)
{
character[i].controlMap.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.FIELDANIMATIONS)
{
character[i].fieldAnimations.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.BONUSSETTINGS)
{
character[i].bonus.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.ATTACK)
{
int j = int.Parse((string)ht["id"]);
if(j < character[i].baseAttack.Length)
{
character[i].baseAttack[j] = int.Parse((string)ht["id2"]);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.DEVELOPMENT)
{
character[i].development.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.CUSTOMANIMATIONS)
{
character[i].customAnimations.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.FIELDSTATUSCHANGE)
{
int id = int.Parse((string)ht["id"]);
if(id < character[i].fieldStatusChange.Length)
{
character[i].fieldStatusChange[id].SetData(ht);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == CharacterData.BATTLESTATUSCHANGE)
{
int id = int.Parse((string)ht["id"]);
if(id < character[i].battleStatusChange.Length)
{
character[i].battleStatusChange[id].SetData(ht);
}
}
}
// old attack import
if(tmpAtk.Length > 0)
{
character[i].baseAttack = DataHolder.BaseAttacks().ImportOldAttack(tmpAtk, "Character");
}
}
}
}
}
}
}
}
public BaseAttack GetCopy()
{
BaseAttack ba = new BaseAttack(this.consume.Length);
ba.SetData(this.GetData(new Hashtable()));
return ba;
}
public static BaseAttack[] Remove(int index, BaseAttack[] list)
{
ArrayList tmp = new ArrayList();
foreach(BaseAttack str in list) tmp.Add(str);
tmp.RemoveAt(index);
return tmp.ToArray(typeof(BaseAttack)) as BaseAttack[];
}
public Combat()
{
ArmorClass = new ArmorClass();
SavingThrows = new SavingThrows();
BaseAttack = new BaseAttack();
}
public static BaseAttack[] Add(BaseAttack n, BaseAttack[] list)
{
ArrayList tmp = new ArrayList();
foreach(BaseAttack str in list) tmp.Add(str);
tmp.Add(n);
return tmp.ToArray(typeof(BaseAttack)) as BaseAttack[];
}
public void LoadData()
{
ArrayList data = XMLHandler.LoadXML(dir+filename);
if(data.Count > 0)
{
foreach(Hashtable entry in data)
{
if(entry[XMLHandler.NODE_NAME] as string == WeaponData.WEAPONS)
{
if(entry.ContainsKey(XMLHandler.NODES))
{
ArrayList subs = entry[XMLHandler.NODES] as ArrayList;
icon = new string[subs.Count];
weapon = new Weapon[subs.Count];
foreach(Hashtable val in subs)
{
if(val[XMLHandler.NODE_NAME] as string == WeaponData.WEAPON)
{
// old attack conversion
BaseAttack[] tmpAtk = new BaseAttack[0];
int i = int.Parse((string)val["id"]);
icon[i] = "";
weapon[i] = new Weapon();
if(val.ContainsKey("minimumlevel"))
{
weapon[i].minimumLevel = int.Parse((string)val["minimumlevel"]);
}
if(val.ContainsKey("minimumclasslevel"))
{
weapon[i].minimumClassLevel = int.Parse((string)val["minimumclasslevel"]);
}
weapon[i].equipPart = new bool[int.Parse((string)val["equipparts"])];
weapon[i].blockPart = new bool[int.Parse((string)val["equipparts"])];
if(val.ContainsKey("dropable")) weapon[i].dropable = true;
weapon[i].equipType = (EquipType)System.Enum.Parse(typeof(EquipType), (string)val["equiptype"]);
weapon[i].skillEffect = new SkillEffect[int.Parse((string)val["effects"])];
if(val.ContainsKey("element"))
{
weapon[i].ownAttack = true;
weapon[i].element = int.Parse((string)val["element"]);
}
int count;
if(val.ContainsKey("races"))
{
count = int.Parse((string)val["races"]);
}
else count = DataHolder.Races().GetDataCount();
weapon[i].raceValue = new int[count];
if(val.ContainsKey("sizes"))
{
count = int.Parse((string)val["sizes"]);
}
else count = DataHolder.Sizes().GetDataCount();
weapon[i].sizeValue = new int[count];
if(val.ContainsKey("elements"))
{
count = int.Parse((string)val["elements"]);
}
else count = DataHolder.Elements().GetDataCount();
weapon[i].elementValue = new int[count];
weapon[i].elementOperator = new SimpleOperator[count];
if(val.ContainsKey("attacks"))
{
weapon[i].baseAttack = new int[int.Parse((string)val["attacks"])];
}
else
{
// old attack conversion
if(val.ContainsKey("baseattacks"))
{
weapon[i].baseAttack = new int[int.Parse((string)val["baseattacks"])];
tmpAtk = new BaseAttack[weapon[i].baseAttack.Length];
for(int j=0; j<tmpAtk.Length; j++)
{
tmpAtk[j] = new BaseAttack(DataHolder.StatusValueCount);
}
}
else
{
tmpAtk = new BaseAttack[1];
tmpAtk[0] = new BaseAttack(DataHolder.StatusValueCount);
tmpAtk[0].SetData(val);
}
}
if(val.ContainsKey("skills"))
{
weapon[i].equipmentSkill = new EquipmentSkill[int.Parse((string)val["skills"])];
}
weapon[i].buyPrice = int.Parse((string)val["buyprice"]);
if(val.ContainsKey("sellprice"))
{
weapon[i].sellable = true;
weapon[i].sellPrice = int.Parse((string)val["sellprice"]);
weapon[i].sellSetter = (ValueSetter)System.Enum.Parse(typeof(ValueSetter), (string)val["sellsetter"]);
}
if(val.ContainsKey("counter"))
{
weapon[i].bonus.counterBonus = int.Parse((string)val["counter"]);
}
if(val.ContainsKey("escape"))
{
weapon[i].bonus.escapeBonus = int.Parse((string)val["escape"]);
}
if(val.ContainsKey("hitbonus"))
{
weapon[i].bonus.hitBonus = int.Parse((string)val["hitbonus"]);
}
if(val.ContainsKey("animationid"))
{
weapon[i].battleAnimations.animateBaseAttack = true;
weapon[i].battleAnimations.baseAttackAnimationID = int.Parse((string)val["animationid"]);
}
if(val.ContainsKey("movespeedreduction"))
{
weapon[i].bonus.speedBonus = -float.Parse((string)val["movespeedreduction"]);
}
ArrayList s = val[XMLHandler.NODES] as ArrayList;
foreach(Hashtable ht in s)
{
this.LoadLanguages(ht, i, subs.Count);
if(ht[XMLHandler.NODE_NAME] as string == WeaponData.EQUIPPART)
{
weapon[i].equipPart[int.Parse((string)ht["id"])] = bool.Parse((string)ht["enabled"]);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BLOCKPART)
{
weapon[i].blockPart[int.Parse((string)ht["id"])] = bool.Parse((string)ht["blocked"]);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BONUS)
{
int id = int.Parse((string)ht["id"]);
if(id < weapon[i].bonus.statusBonus.Length)
{
weapon[i].bonus.statusBonus[id] = int.Parse((string)ht["value"]);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.EFFECT)
{
weapon[i].skillEffect[int.Parse((string)ht["id"])] = (SkillEffect)System.Enum.Parse(typeof(SkillEffect), (string)ht["value"]);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.PREFAB)
{
weapon[i].prefabName = ht[XMLHandler.CONTENT] as string;
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.SKILL)
{
int j = int.Parse((string)ht["id"]);
weapon[i].equipmentSkill[j] = new EquipmentSkill(DataHolder.StatusValueCount);
weapon[i].equipmentSkill[j].skill = int.Parse((string)ht["skill"]);
if(ht.ContainsKey("slvl"))
{
weapon[i].equipmentSkill[j].skillLevel = int.Parse((string)ht["slvl"]);
}
if(ht.ContainsKey("level"))
{
weapon[i].equipmentSkill[j].requireLevel = true;
weapon[i].equipmentSkill[j].level = int.Parse((string)ht["level"]);
}
if(ht.ContainsKey("classlevel"))
{
weapon[i].equipmentSkill[j].requireClassLevel = true;
weapon[i].equipmentSkill[j].classLevel = int.Parse((string)ht["classlevel"]);
}
if(ht.ContainsKey("class"))
{
weapon[i].equipmentSkill[j].requireClass = true;
weapon[i].equipmentSkill[j].classNumber = int.Parse((string)ht["class"]);
}
if(ht.ContainsKey(XMLHandler.NODES))
{
ArrayList ss = ht[XMLHandler.NODES] as ArrayList;
foreach(Hashtable skill in ss)
{
if(skill[XMLHandler.NODE_NAME] as string == WeaponData.STATUS)
{
int k = int.Parse((string)skill["id"]);
weapon[i].equipmentSkill[j].requireStatus[k] = true;
weapon[i].equipmentSkill[j].statusValue[k] = int.Parse((string)skill["value"]);
weapon[i].equipmentSkill[j].statusRequirement[k] = (ValueCheck)System.Enum.Parse(typeof(ValueCheck), (string)skill["requirement"]);
}
}
}
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ANIMATIONS)
{
weapon[i].ownBaseAnimations = bool.Parse((string)ht["ownbase"]);
weapon[i].battleAnimations = new BattleAnimationSettings(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BASEATTACK)
{
int j = int.Parse((string)ht["id"]);
if(j < tmpAtk.Length)
{
tmpAtk[j].SetData(ht);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BONUSSETTINGS)
{
weapon[i].bonus.SetData(ht);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ATTACK)
{
int j = int.Parse((string)ht["id"]);
if(j < weapon[i].baseAttack.Length)
{
weapon[i].baseAttack[j] = int.Parse((string)ht["id2"]);;
}
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.RACE)
{
int id = int.Parse((string)ht["id"]);
if(id < weapon[i].raceValue.Length)
{
weapon[i].raceValue[id] = int.Parse((string)ht["value"]);
}
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ELEMENT)
{
int j = int.Parse((string)ht["id"]);
weapon[i].elementValue[j] = int.Parse((string)ht["value"]);
weapon[i].elementOperator[j] = (SimpleOperator)System.Enum.Parse(
typeof(SimpleOperator), (string)ht["operator"]);
}
else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.SIZE)
{
int id = int.Parse((string)ht["id"]);
if(id < weapon[i].sizeValue.Length)
{
weapon[i].sizeValue[id] = int.Parse((string)ht["value"]);
}
}
}
// old attack import
if(weapon[i].ownAttack && tmpAtk.Length > 0)
{
weapon[i].baseAttack = DataHolder.BaseAttacks().ImportOldAttack(tmpAtk, "Weapon");
}
}
}
}
}
}
}
}
void Start() {
baseAttack = gameObject.GetComponent<BaseAttack>();
}
