void Update()
{
if (this.GetComponent <RPGActor>().State == ActorState.Dead)
{
return;
}
RPGActor leader = GameManager.Instance.GetPartyLeader().GetComponent <RPGActor>();
//Engage when party leader target has changed
if (leader != null && leader.State == ActorState.Engaged)
{
if (GetComponent <RPGActor>().TargetObject != leader.TargetObject)
{
GameManager.Instance.Log("Actor " + this.name + " now starts engaging party leader target");
GetComponent <RPGActor>().SetTarget(leader.TargetObject);
GetComponent <RPGActor>().EngageTarget();
}
}
//drop target when party leader is not engaged.
if (leader != null && leader.State == ActorState.Idle && GetComponent <RPGActor>().State == ActorState.Engaged)
{
GetComponent <RPGActor>().DisengageAllEngagedEnemies();
}
}
void Start()
{
Cooldown = Random.Range(6, 10);
Name = LocalizationManager.Instance.GetLocalizedValue("whiteMage_N");
ActionVariable += () =>
{
var partyMembers = GameManager.Instance.GetPartyMembers();
RPGActor weakestUnit = this.GetComponent <RPGActor>();
float lowestHealth = 99999999;
foreach (var player in partyMembers.Where(p => p.State != ActorState.Dead))
{
if (player.Properties.CurrentHealth < lowestHealth)
{
lowestHealth = player.Properties.CurrentHealth;
weakestUnit = player;
}
}
if (weakestUnit.Properties.CurrentHealth < weakestUnit.Properties.MaxHealth)
{
weakestUnit.RestoreHP(30, true);
}
};
ResetCommand();
IsEnabled = true;
GetComponent <RPGActor>().PartyMemberCommands.Add(this);
}
public override void Start()
{
base.Start();
RPGActor thisActor = GetComponent <RPGActor>();
thisActor.Properties.EarnedGold = thisActor.Properties.Level * 120;
}
// Update is called once per frame
void Update()
{
if (TypeOfSource == SourceType.CurrentSoftTarget)
{
data = ActorData.SoftTarget;
}
else
{
data = ActorData;
}
if (data == null)
{
return;
}
switch (TypeOfControl)
{
case ControlType.Text:
SetTextControl();
break;
case ControlType.Slider:
SetSliderControl();
break;
case ControlType.ImageVisibility:
SetImageVisibility();
break;
default:
break;
}
}
void Update()
{
//Party members should never be deleted
RPGActor leader = GameManager.Instance.CurrentPartyMembers[0].GetComponent<RPGActor>();
if (leader != null && leader.State == ActorState.Engaged)
{
//Check if the current enemy isn't targetting us already. the leader might be engaged, but its target might not have a TargetObject (i.e: the leader) yet.
/* if (leader.Target == null)
return; */
if (leader.Target.TargetObject == null)
return;
if (leader.Target.TargetObject == this.gameObject)
return;
currentTimer -= Time.deltaTime;
if (currentTimer <= 0)
{
CoreUIManager.Instance.SpawnLabel(LocalizationManager.Instance.GetLocalizedValue("Aggro") + "↑", this.gameObject);
GetComponent<RPGActor>().Target.PullAggro(this.gameObject);
currentTimer = AggroTimer;
}
}
}
public void SetTargets(RPGActor nTargets)
{
var singleTarget = new List <RPGActor>();
singleTarget.Add(nTargets);
targetsToHit = singleTarget;
}
public void InitializeSkills()
{
//At the beginning of a battle, starting all cooldowns
leaderActor = GameManager.Instance.CurrentPartyMembers[0].GetComponent <RPGActor>();
foreach (var displaySkill in ActiveSkillsUIObjects)
{
displaySkill.SetActive(false);
}
foreach (Command cmd in leaderActor.PartyMemberCommands)
{
ActiveSkillsUIObjects[cmd.Slot].SetActive(true);
//cmd.ResetCommand(); //Done manually for each command in case some skills have to be active from the start etc.
//icon
Transform iconTransform = ActiveSkillsUIObjects[cmd.Slot].gameObject.transform.FindDeepChild("SkillIcon");
if (iconTransform != null)
{
iconTransform.gameObject.GetComponent <Image>().sprite = Resources.Load <Sprite>(cmd.Illustration);
}
}
SelectedIndex = 2;
Command startBattleCommand = leaderActor.GetCommandAtSlotIndex(SelectedIndex);
startBattleCommand.IsEnabled = true; //enable second skill
startBattleCommand.IsCooledDown = true;
}
public void BindToActor(RPGActor bindToActor)
{
myActor = bindToActor;
//lock transform to actor so you know the target location on screen!
myActor.myTransform = myTransform;
initialPosition = myTransform.position;
Setup();
}
public void AddPlayerBoxMini(RPGActor player)
{
if (PlayerBoxMiniPrefab != null)
{
GameObject gO = Instantiate <GameObject>(PlayerBoxMiniPrefab);
gO.GetComponent <RectTransform>().SetParent(PlayerHealthPanel.transform);
gO.GetComponent <ChangeActorForAllUI>().ActorToDisplay = player;
}
}
public virtual void Start()
{
actor = GetComponent <RPGActor>();
actor.OnDestroyCallBack.AddListener(actorDestroyed);
CalculateAutoAttackDelayBasedOnSpeed();
currentAttackTimer = StartAttackTimer;
StartCoroutine(UpdateCoroutine());
}
public BattleResults CalculateBattleResults(RPGActor defeatedEnemy)
{
//allocate exp
BattleResults results = default(BattleResults);
int expToAdd = defeatedEnemy.Properties.EarnedExperience;
//add additional exp from passive bonusses, rest time, etc, extra gold.
results.Experience = expToAdd;
return(results);
}
void Update()
{
RPGActor current = GetComponent <RPGActor>();
if (current.State == ActorState.Engaged && GameManager.Instance.GetLeaderActor().State == ActorState.Dead && ChainBarDisplayController.Instance.HasSegmentReady())
{
ChainBarDisplayController.Instance.UseChainSegment();
GameManager.Instance.GetLeaderActor().Revive();
CoreUIManager.Instance.SpawnLabel("('ω')ノ", GameManager.Instance.GetPartyLeader());
}
}
// Update is called once per frame
void Update()
{
RPGActor actor = GetComponent <RPGActor>();
bool isOutOfCombat = GameManager.Instance.CurrentState == GameManager.Instance.StateIdle;
if (actor.State == ActorState.Dead && isOutOfCombat)
{
actor.EnterIdleState();
actor.RestoreHP(50, true);
}
}
public void Initialize(int index)
{
myActor = RpgBattleSystemMain.instance.heroParty[index];
myActor.SetMenuController(this);
enemyTargets = CloneList(RpgBattleSystemMain.instance.enemyParty);
CreateAttackTargetsList(false);
//skills you can perform
availibleActions = myActor.skills;
if (availibleActions.Count <= 0)
{
availibleActions.Add(new AttackActionStd("Debug Attack"));
}
}
public override void StateExit()
{
//Revive any dead party members
foreach (var unit in gameManager.CurrentPartyMembers)
{
RPGActor actor = unit.GetComponent <RPGActor>();
if (actor.Properties.CurrentHealth == 0)
{
actor.RestoreHP(20, true);
}
//Potentially check against the state of the unit (i.e: Dead) and clear status ailments,...
}
}
void Start()
{
Cooldown = 25;
Name = GetName();
ActionVariable += () =>
{
RPGActor leader = GameManager.Instance.CurrentPartyMembers[0].GetComponent <RPGActor>();
if (leader != null && leader.State == ActorState.Engaged)
{
CoreUIManager.Instance.SpawnLabel(GetName(), this.gameObject);
GetComponent <RPGActor>().Target.PullAggro(this.gameObject);
}
};
ResetCommand();
GetComponent <RPGActor>().PartyMemberCommands.Add(this);
}
public void Revive()
{
if (State != ActorState.Dead)
{
GameManager.Instance.LogError("Trying to revive actor " + this.name + " while alive.");
}
TargetObject = null;
EngagedEnemies.Clear();
SoftTargetObject = null;
RestoreHP(30, true);
//Engage this unit in battle again
if (GameManager.Instance.CurrentState == GameManager.Instance.StateBattle)
{
if (IsLeader)
{
RPGActor activeUnit = null;
foreach (var pMember in GameManager.Instance.CurrentPartyMembers)
{
if (pMember.GetComponent <RPGActor>().State == ActorState.Engaged)
{
activeUnit = pMember.GetComponent <RPGActor>();
}
}
if (activeUnit != null)
{
TargetObject = activeUnit.TargetObject;
SoftTargetObject = activeUnit.SoftTargetObject;
EngagedEnemies = new List <GameObject>(activeUnit.EngagedEnemies);
}
}
else
{
TargetObject = GameManager.Instance.GetLeaderActor().TargetObject;
SoftTargetObject = GameManager.Instance.GetLeaderActor().SoftTargetObject;
EngagedEnemies = new List <GameObject>(GameManager.Instance.GetLeaderActor().EngagedEnemies);
}
EnterEngagedState();
}
}
void Update()
{
if (GameManager.Instance.IsGameOver || GameManager.Instance.GetLeaderActor().State == ActorState.Dead)
{
return;
}
RPGActor enemyActor = GetComponent <RPGActor>();
if (enemyActor.State == ActorState.Idle)
{
float distance = Vector3.Distance(this.transform.position, GameManager.Instance.GetPartyLeader().transform.position);
if (Mathf.Abs(distance) < Range)
{
enemyActor.SetTarget(GameManager.Instance.GetPartyLeader());
enemyActor.EngageTarget(); //notify the enemy too.
}
}
}
void ConnectToActor(int index)
{
if (rpg.heroParty == null)
{
return;
}
if (rpg.heroParty.Count - 1 < index)
{
//out of bounds, disable this UI element.
this.gameObject.SetActive(false);
return;
}
myActor = rpg.heroParty[index];
myActor.onHpChangedEvents += HpChanged;
nameDisplay.text = myActor.displayName;
//setup rolling number effect:
ConfigureRollingNumber();
ConfigureLifeBar();
}
void Start()
{
line = GetComponent <LineRenderer>();
if (line == null)
{
line = transform.GetComponentInParent <LineRenderer>();
}
if (line == null)
{
line = this.gameObject.AddComponent <LineRenderer>();
}
actor = GetComponent <RPGActor>();
if (actor == null)
{
actor = transform.GetComponentInParent <RPGActor>();
}
Assert.IsNotNull(actor, "No RPGActor component could be found");
}
void SetTextControl()
{
GetComponent <Text>().text = data.Properties.GetPropertyString(PropertyToDisplay);
if (PropertyToDisplay == RPGPropertyType.CurrentGold)
{
GetComponent <Text>().text = GameManager.Instance.Gold.ToString();
}
if (PropertyToDisplay == RPGPropertyType.CurrentSkillName)
{
GameObject gO = SkillbarController.Instance.ActiveSkillsUIObjects[SkillbarController.Instance.SelectedIndex];
if (gO != null)
{
RPGActor leaderActor = GameManager.Instance.GetPartyLeader().GetComponent <RPGActor>();
Command c = leaderActor.GetCommandAtSlotIndex(SkillbarController.Instance.SelectedIndex);
if (c != null)
{
GetComponent <Text>().text = c.GetName();
}
}
}
if (PropertyToDisplay == RPGPropertyType.CurrentSkillDescription)
{
GameObject gO = SkillbarController.Instance.ActiveSkillsUIObjects[SkillbarController.Instance.SelectedIndex];
if (gO != null)
{
RPGActor leaderActor = GameManager.Instance.GetPartyLeader().GetComponent <RPGActor>();
Command c = leaderActor.GetCommandAtSlotIndex(SkillbarController.Instance.SelectedIndex);
if (c != null)
{
GetComponent <Text>().text = c.GetDescription();
}
}
}
}
void FallingAoECallback()
{
if (Instigator == null || Instigator.GetComponent <RPGActor>().State != ActorState.Engaged)
{
GameObject.Destroy(this.gameObject);
return;
}
var intersectList = GetIntersects();
foreach (var item in intersectList)
{
RPGActor actor = item.GetComponent <RPGActor>();
if (actor.IsLeader)
{
item.GetComponent <RPGActor>().ReceiveIncidentalDamage(4, MagicElemancy.None);
}
CoreUIManager.Instance.SpawnLabel("AoE", GameManager.Instance.GetPartyLeader(), true);
}
GameObject.Destroy(this.gameObject);
GameManager.Instance.ActiveAOEs--;
}
void Start()
{
Cooldown = 15;
Name = LocalizationManager.Instance.GetLocalizedValue("skillInflictBreak_N");
ActionVariable += () =>
{
var enemies = GetComponent <RPGActor>().EngagedEnemies;
RPGActor enemyToBreak = null;
foreach (var enemy in enemies)
{
if (enemy.GetComponent <RPGActor>().Properties.IsBreak == false)
{
enemyToBreak = enemy.GetComponent <RPGActor>();
}
}
CoreUIManager.Instance.SpawnLabel(Name, this.gameObject);
GetComponent <RPGActor>().InflictBreak(enemyToBreak);
};
ResetCommand();
IsEnabled = true;
GetComponent <RPGActor>().PartyMemberCommands.Add(this);
}
public void DoDamageAttack(int damage, MagicElemancy element, GameObject target, float fontIncrement = 0, bool isSpecialDamage = false)
{
if (isPlayer)
{
ChainBarDisplayController.Instance.AddToChainBar(1.5f);
}
RPGActor targetActor = target.GetComponent <RPGActor>();
//If target is not engaged, engage it with this actor
if (targetActor.State == ActorState.Idle)
{
if (target.tag == "Player" /* && GameManager.Instance.CurrentState == GameManager.Instance.StateIdle */)
{
targetActor.SetSoftTarget(this.gameObject);
GameManager.Instance.Log("Attacked target is a player who was idle, now entering battle state and showing UI");
}
this.TargetObject = target; //Set current target to this enemy
targetActor.SetTarget(this.gameObject);
targetActor.EngageTarget(); //notify the enemy.
}
else if (targetActor.State == ActorState.Engaged)
{
AddToEngaged(target); //When target is already in battle, add to engaged but don't set the current target
}
//
var playerShoot = GetComponent <PlayerShoot>();
if (playerShoot != null && target != null)
{
//playerShoot.TargetObject = target;
playerShoot.ShootBullet(target);
}
DamageInfo damageInfo = ResolveDamageUnitAGivesUnitB(this.Properties, targetActor.Properties, damage);
int dmg = (int)damageInfo.TotalDamage;
targetActor.Properties.ChangeHealth(-dmg);
targetActor.SpawnDamageParticles(element);
if (fontIncrement == 0)
{
fontIncrement = damageInfo.CritMultiplier * 1.3f;
//for auto attack size variation
if (damage == 1)
{
fontIncrement *= 0.6f;
}
if (damage == 2)
{
fontIncrement *= 0.9f;
}
if (damage == 3)
{
fontIncrement *= 1.1f;
}
if (damage > 5)
{
fontIncrement *= 1.6f;
}
}
Color playerDMG = CoreUIManager.Instance.PlayerTakeDamageColor;
Color enemyDMG = CoreUIManager.Instance.EnemyTakeDamageColor;
Color specialDMG = CoreUIManager.Instance.SpecialDamageColor;
if (isSpecialDamage)
{
CoreUIManager.Instance.SpawnText(dmg.ToString(), target, specialDMG, 2.6f);
}
else if (this.tag == "Enemy")
{
CoreUIManager.Instance.SpawnText(dmg.ToString(), target, playerDMG, fontIncrement);
}
else
{
CoreUIManager.Instance.SpawnText(dmg.ToString(), target, enemyDMG, fontIncrement);
}
}
//on custom object
public void InflictBreak(RPGActor target)
{
target.Properties.InflictBreak();
CoreUIManager.Instance.SpawnLabel(LocalizationManager.Instance.GetLocalizedValue("Break"), target.gameObject, "Textures/Break_Icon");
}
void Start()
{
actor = GetComponent <RPGActor>();
controller = GetComponent <CharacterController>();
}
