void fightHero()
{
TDWorld world = TDWorld.getWorld();
TDHero hero = world.getTDHero();
if (!hero.isAlive())
{
m_state = State.eRunToPlayer;
cleanPath();
return;
}
if ((hero.transform.position - transform.position).magnitude < fightRadius())
{
cleanPath();
TDDamage damage = new TDDamage(TDDamage.Type.ePhysical, physicalDamage() * Time.deltaTime, 0.0f); // Replace by override TDEnemy::getDamage
hero.receiveDamage(damage, this);
}
else
{
if ((null == m_path) || (Time.time - m_timer > world.m_configuration.enemyRecalcPathTime))
{
m_timer = Time.time;
hasPathTo(hero.gameObject);
}
}
}
public TDDamage clone(TDActor target)
{
TDDamage newDamage = new TDDamage(m_type, m_firstDamage, m_contDamagePerSec);
newDamage.setTarget(target);
return(newDamage);
}
private void fight()
{
TDWorld world = TDWorld.getWorld();
TDEnemy tdEnemy = world.getTDEnemy(target());
if (null == tdEnemy)
{
m_state = State.ePatrol;
return;
}
if ((target().transform.position - transform.position).magnitude > world.m_configuration.heroFightRadius)
{
if (hasPathTo(target()))
{
m_state = State.eWalk;
}
else
{
m_state = State.ePatrol;
}
return;
}
TDDamage damage = new TDDamage(TDDamage.Type.ePhysical, world.m_configuration.heroPhysicalDamagePerSec * Time.deltaTime, 0f);
tdEnemy.receiveDamage(damage, this);
}
public void shootTo(TDActor actor)
{
TDDamage damage = getTowerDamage();
TDProjectile projectile = createProjectile();
projectile.m_damage = damage;
projectile.setTarget(actor);
}
// Update is called once per frame
void Update()
{
float currentTime = Time.time;
float respawn = getRestoration();
if (currentTime < (m_restTime + respawn))
{
return;
}
GameObject [] aAllEnemies = TDWorld.getWorld().getAllEnemiesUnsafe();
double recDist = -1;
GameObject recObject = null;
TDDamage damage = getTowerDamage();
foreach (GameObject thisObject in aAllEnemies)
{
if (thisObject == null)
{
continue;
}
float dist = (transform.position - thisObject.transform.position).magnitude;
float efficientRadius = getEfficientRadius();
if (dist < efficientRadius)
{
TDEnemy enemy = TDWorld.getWorld().getTDEnemy(thisObject);
if (enemy.canFly())
{
if (!shootsFlying())
{
continue;
}
}
if (!TDWorld.getWorld().m_strategy.shouldShootAt(enemy, damage))
{
continue;
}
if ((recDist < 0) || (recDist > dist))
{
recDist = dist;
recObject = thisObject;
}
}
}
if (recObject == null)
{
return;
}
TDEnemy recEnemy = TDWorld.getWorld().getTDEnemy(recObject);
TDWorld.getWorld().m_strategy.shootingAt(recEnemy, damage);
shootTo(recEnemy);
m_restTime = Time.time;
}
override public void receiveDamage(TDDamage damage, TDActor source)
{
base.receiveDamage(damage, source);
if (null != source)
{
TDWorld world = TDWorld.getWorld();
TDHero hero = world.getTDHero();
if (source == hero)
{
m_state = State.eFightHero;
}
}
}
public override void receiveDamage(TDDamage damage, TDActor source)
{
base.receiveDamage(damage, source);
if (null != source)
{
TDWorld world = TDWorld.getWorld();
TDHero hero = world.getTDHero();
if (source == hero)
{
m_state = State.eFightHero;
}
}
}
public override bool shouldShootAt(TDEnemy enemy, TDDamage potentialDamage)
{
if (m_followedEnemies == null)
m_followedEnemies = new List<TDEnemy>();
m_counter++;
if (m_counter > m_counterLimit)
{
m_counter = 0;
m_followedEnemies.Clear();
}
if (!m_followedEnemies.Contains(enemy)) // New enemies always have preference
return true;
return false;
}
public bool shouldShootAt(TDEnemy enemy, TDDamage potentialDamage)
{
if (m_followedEnemies == null)
m_followedEnemies = new Dictionary<TDEnemy, float>();
if (!m_followedEnemies.ContainsKey(enemy))
{
m_followedEnemies[enemy] = 0;
enemy.OnEventDestroy += destroyCallback;
return true;
}
float followedDamage = m_followedEnemies[enemy];
if (followedDamage > enemy.getStartHP())
return false;
return true;
}
public bool shouldShootAt(TDEnemy enemy, TDDamage potentialDamage)
{
if (m_followedEnemies == null)
{
m_followedEnemies = new Dictionary <TDEnemy, float>();
}
if (!m_followedEnemies.ContainsKey(enemy))
{
m_followedEnemies[enemy] = 0;
enemy.OnEventDestroy += destroyCallback;
return(true);
}
float followedDamage = m_followedEnemies[enemy];
if (followedDamage > enemy.getStartHP())
{
return(false);
}
return(true);
}
public void receiveDamage(TDDamage.Type type, float val)
{
m_HP -= (1.0f - getResistance(type))*val;
}
public TDDamage clone(TDActor target)
{
TDDamage newDamage = new TDDamage(m_type, m_firstDamage, m_contDamagePerSec);
newDamage.setTarget(target);
return newDamage;
}
public abstract float getResistance(TDDamage.Type type);
public virtual void receiveDamage(TDDamage damage, TDActor source)
{
receiveModifier(damage);
}
public override bool shouldShootAt(TDEnemy enemy, TDDamage potentialDamage)
{
return true;
}
public override float getResistance(TDDamage.Type type)
{
return 0.0f;
}
virtual public void receiveDamage(TDDamage damage, TDActor source)
{
receiveModifier(damage);
}
public abstract void shootingAt(TDEnemy enemy, TDDamage potentialDamage);
public void shootingAt(TDEnemy enemy, TDDamage potentialDamage)
{
m_followedEnemies[enemy] += potentialDamage.estimatedFirstDamage();
}
private void fight()
{
TDWorld world = TDWorld.getWorld();
TDEnemy tdEnemy = world.getTDEnemy(target());
if (null == tdEnemy)
{
m_state = State.ePatrol;
return;
}
if ((target().transform.position - transform.position).magnitude > world.m_configuration.heroFightRadius)
{
if (hasPathTo(target()))
{
m_state = State.eWalk;
}
else
{
m_state = State.ePatrol;
}
return;
}
TDDamage damage = new TDDamage(TDDamage.Type.ePhysical, world.m_configuration.heroPhysicalDamagePerSec*Time.deltaTime, 0f);
tdEnemy.receiveDamage(damage, this);
}
public void shootingAt(TDEnemy enemy, TDDamage potentialDamage)
{
m_followedEnemies[enemy] += potentialDamage.estimatedFirstDamage();
}
public abstract bool shouldShootAt(TDEnemy enemy, TDDamage potentialDamage);
public override void shootingAt(TDEnemy enemy, TDDamage potentialDamage)
{
}
public override void shootingAt(TDEnemy enemy, TDDamage potentialDamage)
{
if (!m_followedEnemies.Contains(enemy))
m_followedEnemies.Add(enemy);
}
void fightHero()
{
TDWorld world = TDWorld.getWorld();
TDHero hero = world.getTDHero();
if (!hero.isAlive())
{
m_state = State.eRunToPlayer;
cleanPath();
return;
}
if ((hero.getGridPosition() - getGridPosition()).magnitude < fightRadius())
{
cleanPath();
TDDamage damage = new TDDamage(TDDamage.Type.ePhysical, physicalDamage()*Time.deltaTime, 0.0f); // Replace by override TDEnemy::getDamage
hero.receiveDamage(damage, this);
}
else
{
if ((null == m_path) || (Time.time - m_timer > world.m_configuration.enemyRecalcPathTime))
{
m_timer = Time.time;
hasPathTo(hero.gameObject);
}
}
}
