public override void Update(GameTime gameTime)
{
if (CloakingTokens > 0)
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > CloakSearchTime)
{
SearchTime -= CloakSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance)))
{
if (o.GetType().IsSubclassOf(typeof(UnitTurret)))
{
UnitTurret u = (UnitTurret)o;
u.fieldState = FieldState.Cloaked;
u.FieldStateTime = 1000000;
CloakingTokens--;
fieldState = FieldState.Cloaked;
FieldStateTime = 1000000;
if (CloakingTokens == 0)
{
break;
}
}
}
}
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > MaxSearchTime)
{
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip s = (UnitShip)o;
if (s.ShieldDamage < s.ShieldToughness)
{
s.ShieldFlash(1);
}
s.ShieldDamage += 10000;
}
}
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
if (!Dead)
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > MaxSearchTime)
{
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
int UnitCount = 0;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)) && Vector2.Distance(Position.get(), o.Position.get()) < MaxEngagementDistance)
{
UnitShip s = (UnitShip)o;
if (s.CanBeTargeted() && s.FreezeTime < 1)
{
UnitCount++;
}
}
}
if (UnitCount >= MaxUnitCount)
{
BlowUp();
}
}
}
base.Update(gameTime);
}
public override void Destroy()
{
SoundManager.Play3DSound("MineImpact",
new Vector3(Position.X(), Y, Position.Y()), 0.25f, 800, 2f);
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
float BulletExplosionDistance = 200;
for (int i = 0; i < 2; i++)
{
foreach (Basic2DObject o in grid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance)))
{
if (o.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
float dist = Vector2.Distance(s.Position.get(), Position.get()) - o.Size.X() / 2;
if (dist < BulletExplosionDistance && GetTeam() != s.GetTeam())
{
float DistMult = 1;
if (dist > 0)
{
DistMult = (BulletExplosionDistance - dist) / BulletExplosionDistance;
}
s.Damage(DistMult * 4, DistMult, Vector2.Normalize(s.Position.get() - Position.get()) * 1 * DistMult, this, AttackType.Green);
}
}
}
}
base.Destroy();
}
public override void Destroy()
{
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(GetEngagementDistance() * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBasic)))
{
UnitBasic s = (UnitBasic)o;
if (!s.Dead && !s.IsAlly(this) && Vector2.Distance(Position.get(), o.Position.get()) < GetEngagementDistance())
{
s.ShutDownTime = Math.Max(s.ShutDownTime, (int)(1000 * UnitLevel));
}
}
}
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * GetEngagementDistance() * 2, ParticleColor, 30, 5);
}
for (int i = 0; i < 2; i++)
{
FlareSystem.AddLightingPoint(Position3, new Vector3(0.3f), new Vector3(0, 0, 1), GetEngagementDistance(), 40, 5, 10);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, GetEngagementDistance() * 4, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, GetEngagementDistance() * 1.33f, 4);
}
base.Destroy();
}
private void AISearch(GameTime gameTime)
{
CurrentAttackTarget = null;
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
float BestDistance = MaxEngagementDistance;
foreach (Basic2DObject o in grid.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBasic)) && !o.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
if (!s.IsAlly(this) && s.CanBeTargeted())
{
float d = Vector2.Distance(Position.get(), o.Position.get()) - o.Size.X() / 2;
if (d / s.ThreatLevel < BestDistance)
{
BestDistance = d / s.ThreatLevel;
CurrentAttackTarget = s;
}
}
}
}
}
public override void Update(GameTime gameTime)
{
float Mult = 0.1f + TimeAlive / (float)LifeTime;
float Offset = 200 * Mult;
Vector3 Position3 = new Vector3(0, ParentUnit.Y, 0);
float Theta = -Logic.ToAngle(Speed) - (float)Math.PI * 1f;
float TargetTheta = Theta + (float)(Math.PI * 1.05);
float Alpha = 1 - (float)LifeTime / TimeAlive;
for (; Theta < TargetTheta; Theta += (float)Math.PI / 20)
{
Position3.X = Position.X() + (float)Math.Cos(Theta) * Offset;
Position3.Z = Position.Y() + (float)Math.Sin(Theta) * Offset;
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor * Alpha, Offset * 4, 1);
//ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, Offset, 0);
}
Position3.X = Position.X();
Position3.Z = Position.Y();
if (!Flashed)
{
Mult *= 2;
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 80 * Mult, 0);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 80 * Mult, 4);
Flashed = true;
}
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(Offset * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitTurret)) && o != FirstHitTurret &&
Vector2.Distance(o.Position.get(), Position.get()) < Offset)
{
UnitTurret u = (UnitTurret)o;
if (u.CanBeTargeted())
{
if (FirstHitTurret == null)
{
FirstHitTurret = u;
}
else
{
u.ShutDownTime = (int)(1000 * Level);
}
}
}
}
base.Update(gameTime);
}
public override void Destroy()
{
SoundManager.PlaySound("SmallBombExplode", 1, 0, 0);
SoundManager.DeafTone();
PlayerShip ParentPlayer = (PlayerShip)ParentUnit;
ParentPlayer.ShakeScreen(20);
this.Armed = false;
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 10; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * 6, ParticleColor, 20, 5);
}
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 4000, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 400, 7);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 300, 7);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 500, 7);
for (int i = 0; i < 10; i++)
{
FlamingChunkSystem.AddParticle(Position3, Rand.V3(), new Vector3(0, -0.25f, 0),
Rand.V3(), Rand.V3() / 10, 20, 60, new Vector3(1, 0.5f, 0.2f), new Vector3(1, 0.1f, 0.2f), 0, 3);
}
ParticleManager.CreateParticle(Position3, Vector3.Zero, new Color(1, 0.75f, 0.5f), 500, 4);
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * 10, new Color(1, 0.75f, 0.5f), 200, 5);
}
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
foreach (GameObject g in quadGrid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance)))
{
if (g.GetType().IsSubclassOf(typeof(UnitBasic)))
{
UnitBasic s = (UnitBasic)g;
if (Vector2.Distance(Position.get(), s.Position.get()) < BulletExplosionDistance / 4 && !s.IsAlly(ParentUnit) && !s.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
s.SmallBomb(ParentUnit);
}
}
}
base.Destroy();
}
public override void Update(GameTime gameTime)
{
int Mult = 4;
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, 60 * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (70 + Rand.F() * 70) * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (10 + Rand.F() * 20) * Mult, 2);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (10 + Rand.F() * 20) * Mult, 0);
FlareSystem.AddLightning(Position3, ParticleColor2, 4, 20, 4, 10);
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > MaxSearchTime || (AttackTarget != null && !AttackTarget.CanBeTargeted()))
{
SearchTime -= MaxSearchTime;
AttackTarget = null;
float BestDistance = SearchDistance;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(SearchDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitTurret)))
{
UnitBasic s = (UnitBasic)o;
if (s.CanBeTargeted() && !s.IsAlly(ParentUnit))
{
float d = Vector2.Distance(Position.get(), o.Position.get());
if (d < BestDistance && !o.GetType().Equals(typeof(CrystalWall)))
{
BestDistance = d;
AttackTarget = s;
}
}
}
}
}
if (AttackTarget != null)
{
Speed = Logic.ToVector2(Logic.Clerp(Logic.ToAngle(Speed), Logic.ToAngle(AttackTarget.Position.get() - Position.get()),
TurnSpeed * gameTime.ElapsedGameTime.Milliseconds * 60 / 1000f)) * SpeedL;
}
base.Update(gameTime);
}
public override void Destroy()
{
this.Armed = false;
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 10; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * 2000, ParticleColor, 20, 5);
}
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 4000, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 400, 7);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 300, 7);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 500, 7);
for (int i = 0; i < 2; i++)
{
FlamingChunkSystem.AddParticle(Position3, Rand.V3() / 1.5f, new Vector3(0, -0.25f, 0),
Rand.V3(), Rand.V3() / 10, 150, 30, new Vector3(0.2f, 0.5f, 1), new Vector3(0.2f, 0.5f, 1), 0, 3);
}
ParticleManager.CreateParticle(Position3, Vector3.Zero, new Color(0.5f, 0.75f, 1), Size.X() * 50, 4);
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * 200, new Color(0.5f, 0.75f, 1), 200, 5);
}
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
float MaxDist = 150 * Level;
foreach (GameObject g in quadGrid.Enumerate(Position.get(), new Vector2(MaxDist * 2)))
{
if (g.GetType().IsSubclassOf(typeof(UnitBasic)))
{
UnitBasic s = (UnitBasic)g;
if (Vector2.Distance(Position.get(), s.Position.get()) < MaxDist && !s.IsAlly(ParentUnit))
{
s.ShutDownTime = Math.Max(s.ShutDownTime, (int)(2000 * Level));
}
}
}
base.Destroy();
}
public override void Update(GameTime gameTime)
{
Vector2 StartPosition = Position.get();
Vector2 EndPosition = Position.get() + Vector2.Normalize(Speed) * 600;
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, ParticleColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, ParticleColor, 300, 7);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, ParticleColor, 300, 4);
for (int i = 0; i < 100; i++)
{
ParticleManager.CreateParticle(
new Vector3(StartPosition.X, 0, StartPosition.Y) + (new Vector3(EndPosition.X - StartPosition.X, 0, EndPosition.Y - StartPosition.Y) * i / 100),
Vector3.Zero, ParticleColor, 150, 5);
}
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, ParticleColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, ParticleColor, 300, 7);
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, ParticleColor, 300, 4);
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
Vector2 UpperLeftCorner = Logic.Min(StartPosition, EndPosition) - new Vector2(200);
Vector2 LowerRightCorner = Logic.Max(StartPosition, EndPosition) + new Vector2(200);
QuadGridXMin = (int)((UpperLeftCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridXMax = (int)((LowerRightCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridYMin = (int)((UpperLeftCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
QuadGridYMax = (int)((LowerRightCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
foreach (Basic2DObject g in quadGrid.Enumerate(QuadGridXMin, QuadGridYMin, QuadGridXMax, QuadGridYMax))
{
if (g.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)g;
if (!s.IsAlly(ParentUnit) && CheckCircle(s, StartPosition, EndPosition, AttackLineWidth))
{
s = s.ReturnCollision();
s.Damage(Damage, 1, EndPosition - StartPosition, ParentUnit, AttackType.Red);
}
}
}
Destroy();
}
public bool TestFree(Vector2 Position, float Angle, float Offset, float Size)
{
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Logic.ToVector2(Angle) * Offset, new Vector2(Size * 2)))
{
if (o.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
if (Vector2.Distance(Logic.ToVector2(Angle) * Offset, o.Position.get()) < (Size + o.Size.X()) / 2)
{
return(false);
}
}
}
return(true);
}
public override void Update(GameTime gameTime)
{
int Mult = 4;
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > MaxSearchTime)
{
MaxSearchTime -= SearchTime;
int EnemyCount = 0;
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
foreach (GameObject g in quadGrid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance)))
{
if (g.GetType().IsSubclassOf(typeof(UnitBasic)))
{
UnitBasic s = (UnitBasic)g;
if (Vector2.Distance(Position.get(), s.Position.get()) < BulletExplosionDistance / 8 && !s.IsAlly(ParentUnit) && !s.GetType().IsSubclassOf(typeof(UnitBuilding)) && !s.Dead)
{
EnemyCount += s.GetUnitWeight();
}
}
}
if (BestEnemyCount > 4 && EnemyCount < BestEnemyCount)
{
Destroy();
}
else
{
BestEnemyCount = EnemyCount;
}
}
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, 60 * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (70 + Rand.F() * 70) * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (10 + Rand.F() * 20) * Mult, 2);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (10 + Rand.F() * 20) * Mult, 0);
FlareSystem.AddLightning(Position3, ParticleColor2, 30, 20, 4, 10);
base.Update(gameTime);
}
public override void Destroy()
{
if (ShouldDodge && DodgeBullets.Contains(this))
{
DodgeBullets.Remove(this);
}
if (Commited && !NoInstanceCommit)
{
Commited = false;
BulletInstancer.RemoveChild(this);
}
Destroyed = true;
if (Armed && BulletExplosionDamage > 0 && BulletExplosionDistance > 0)
{
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in grid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance)))
{
if (o.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
float dist = Vector2.Distance(s.Position.get(), Position.get()) - o.Size.X() / 2;
if (dist < BulletExplosionDistance && !ParentUnit.IsAlly(s))
{
float DistMult = 1;
if (dist > 0)
{
DistMult = (BulletExplosionDistance - dist) / BulletExplosionDistance;
}
s.Damage(DistMult * BulletExplosionDamage, DistMult * PushTime, Vector2.Normalize(s.Position.get() - Position.get()) * PushVelocityMult * DistMult, ParentUnit, attackType);
}
}
}
}
SoundManager.Play3DSound(ImpactString, new Vector3(Position.X(), Y, Position.Y()),
ImpactVolume, ImpactDistance, ImpactExponent);
base.Destroy();
}
public virtual void Virus(int VirusTime)
{
if (this.VirusTime < VirusTime)
{
this.VirusTime = VirusTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(VirusTime / 50f * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitTurret)) && Vector2.Distance(o.Position.get(), Position.get()) < VirusTime / 50f)
{
UnitTurret u = (UnitTurret)o;
if (u.CanBeTargeted() && u.IsAlly(this))
{
u.Virus(VirusTime);
}
}
}
}
}
protected virtual PlayerShip AISearchForPlayers()
{
PlayerShip ReturnPlayer = null;
float BestDistance = 1000000;
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in grid.Enumerate(getPosition(), new Vector2(BestDistance) * 2))
{
if (o.GetType().IsSubclassOf(typeof(PlayerShip)))
{
PlayerShip s = (PlayerShip)o;
if (s.GetTeam() == WaveManager.ActiveTeam && !s.Dead && !PathFindingManager.CollisionLine(Position.get(), o.Position.get()))
{
ReturnPlayer = s;
}
}
}
return(ReturnPlayer);
}
public override void BlowUp()
{
if (!Dead)
{
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(EffectDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)) && Vector2.Distance(Position.get(), o.Position.get()) < EffectDistance)
{
UnitShip s = (UnitShip)o;
if (s.CanBeTargeted())
{
s.CanDeathSound = false;
s.CanCloak = false;
s.Damage(4, 0, Vector2.Zero, this, AttackType.Blue);
s.LastDamager = this;
s.StunState = AttackType.Blue;
s.FreezeTime = StasisTime;
s.CanDeathSound = true;
}
}
}
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * MaxEngagementDistance * 3, ParticleColor, 40, 5);
}
for (int i = 0; i < 2; i++)
{
FlareSystem.AddLightingPoint(Position3, new Vector3(0.3f), new Vector3(0, 0, 1), MaxEngagementDistance / 10, 40, 5, 10);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 6, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 3, 4);
}
}
base.BlowUp();
}
public override void Destroy()
{
this.Armed = true;
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * 600, ParticleColor, 30, 5);
}
for (int i = 0; i < 2; i++)
{
FlareSystem.AddLightingPoint(Position3, new Vector3(0.3f), new Vector3(0, 0, 1), 25, 40, 5, 10);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 1200, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 400, 4);
}
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
foreach (GameObject g in quadGrid.Enumerate(Position.get(), new Vector2(WinderMisslesAbility.ExplosionDistance)))
{
if (g.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip s = (UnitShip)g;
if (Vector2.Distance(Position.get(), s.Position.get()) < WinderMisslesAbility.ExplosionDistance / 4)
{
s.StunState = AttackType.White;
s.FreezeTime = 1000;
s.SetSpeed(Vector2.Normalize(s.Position.get() - Position.get()) * 12 / s.Mass);
}
}
}
base.Destroy();
}
public override void BlowUp()
{
if (!Dead)
{
for (int i = 0; i < 36; i++)
{
Guns[0].FireModes[0].Fire((float)Math.PI * (float)i / 18);
}
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
ParticleManager.CreateParticle(Position3, Vector3.Zero, new Color(1, 0.75f, 0.5f), Size.X() * 10, 4);
ParticleManager.CreateParticle(Position3, Vector3.Zero, new Color(1, 0.75f, 0.5f), Size.X() * 6, 6);
float BulletExplosionDistance = IsUpdgraded ? 300 : 500;
float BulletExplosionDamage = IsUpdgraded ? 0.5f : 1f;
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
for (int i = 0; i < 2; i++)
{
bool ActivateDeathSound = true;
foreach (Basic2DObject o in grid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
float dist = Vector2.Distance(s.Position.get(), Position.get()) - o.Size.X() / 2;
if (dist < BulletExplosionDistance && GetTeam() != s.GetTeam())
{
float DistMult = 1;
if (dist > 0)
{
DistMult = (BulletExplosionDistance - dist) / BulletExplosionDistance;
}
if (s.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip ship = (UnitShip)s;
ship.CanDeathSound = ActivateDeathSound;
}
s.Damage(DistMult * BulletExplosionDamage, DistMult,
Vector2.Normalize(s.Position.get() - Position.get()), this, AttackType.Explosion);
if (s.Dead)
{
ActivateDeathSound = false;
}
else if (s.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip ship = (UnitShip)s;
ship.CanDeathSound = true;
}
}
}
}
}
}
base.BlowUp();
}
public override void Update(GameTime gameTime)
{
if (!Dead)
{
MineAddTime += gameTime.ElapsedGameTime.Milliseconds;
if (MineAddTime > MaxMineAddTime)
{
MinesToAdd++;
MineAddTime = 0;
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBasic)))
{
UnitBasic s = (UnitBasic)o;
float d = Vector2.Distance(Position.get(), o.Position.get());
if (!s.IsAlly(this) && s.CanBeTargeted() && d < MaxEngagementDistance + o.Size.X() / 2)
{
if (Mines.Count > 0)
{
float BestDistance = 10000;
Mine BestMine = null;
foreach (Mine m in Mines)
{
float MineDist = Vector2.Distance(m.Position.get(), o.Position.get());
if (MineDist < BestDistance)
{
BestDistance = MineDist;
BestMine = m;
}
}
BestMine.SetAttackTarget(s);
Mines.Remove(BestMine);
SoundManager.Play3DSound("MineFieldTarget", new Vector3(Position.X(), Y, Position.Y()), 0.35f,
1000, 2);
}
if (d < (Size.X() + o.Size.X()))
{
MinesToAdd = 0;
}
break;
}
}
}
}
if (Mines.Count >= MaxMines)
{
MinesToAdd = 0;
}
while (MinesToAdd > 0)
{
Mine m = new Mine(this, FactionNumber);
ParentLevel.AddObject(m);
Mines.AddLast(m);
Vector2 toPosition = Position.get() + Rand.V2() * Size.X() / 2;
m.Position.set(toPosition);
MinesToAdd--;
}
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
float dist = BeamTurretCard.EngagementDistance;
Vector2 StartPosition = Position.get();
Vector2 EndPosition = Position.get() + Vector2.Normalize(Speed) * dist;
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, ParticleColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, ParticleColor, 300, 4);
for (int i = 0; i < 75; i++)
{
ParticleManager.CreateParticle(
new Vector3(StartPosition.X, 0, StartPosition.Y) + (new Vector3(EndPosition.X - StartPosition.X, 0, EndPosition.Y - StartPosition.Y) * i / 75),
Vector3.Zero, ParticleColor, 100, 5);
}
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, ParticleColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, ParticleColor, 300, 4);
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
Vector2 UpperLeftCorner = Logic.Min(StartPosition, EndPosition) - new Vector2(200);
Vector2 LowerRightCorner = Logic.Max(StartPosition, EndPosition) + new Vector2(200);
QuadGridXMin = (int)((UpperLeftCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridXMax = (int)((LowerRightCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridYMin = (int)((UpperLeftCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
QuadGridYMax = (int)((LowerRightCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
if (QuadGridXMax > quadGrid.CellsX - 1)
{
QuadGridXMax = quadGrid.CellsX - 1;
}
if (QuadGridXMin > quadGrid.CellsX - 1)
{
QuadGridXMin = quadGrid.CellsX - 1;
}
if (QuadGridYMax > quadGrid.CellsY - 1)
{
QuadGridYMax = quadGrid.CellsY - 1;
}
if (QuadGridYMin > quadGrid.CellsY - 1)
{
QuadGridYMin = quadGrid.CellsY - 1;
}
if (QuadGridXMax < 0)
{
QuadGridXMax = 0;
}
if (QuadGridXMin < 0)
{
QuadGridXMin = 0;
}
if (QuadGridYMax < 0)
{
QuadGridYMax = 0;
}
if (QuadGridYMin < 0)
{
QuadGridYMin = 0;
}
foreach (Basic2DObject g in quadGrid.Enumerate(QuadGridXMin, QuadGridYMin, QuadGridXMax, QuadGridYMax))
{
if (g.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)g;
if (!s.IsAlly(ParentUnit) && CheckCircle(s, StartPosition, EndPosition, AttackLineWidth))
{
s = s.ReturnCollision();
if (s != null)
{
s.Damage(Damage, 4, EndPosition - StartPosition, ParentUnit, AttackType.Green);
}
}
}
}
Destroy();
}
public void FireShot(Vector2 StartPosition, Vector2 EndPosition, float LineWidth)
{
SoundManager.Play3DSound("SiegeLaserFire", new Vector3(Position.X(), Y, Position.Y()), 0.75f, 1000, 1.5f);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, LaserColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, LaserColor, 300, 7);
ParticleManager.CreateParticle(new Vector3(StartPosition.X, 0, StartPosition.Y), Vector3.Zero, LaserColor, 300, 4);
int c = (int)Vector2.Distance(StartPosition, EndPosition) / 10;
for (int i = 0; i < c; i++)
{
ParticleManager.CreateParticle(
new Vector3(StartPosition.X, 0, StartPosition.Y) + (new Vector3(EndPosition.X - StartPosition.X, 0, EndPosition.Y - StartPosition.Y) * i / c),
Vector3.Zero, LaserColor, 100, 5);
}
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, LaserColor, 300, 5);
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, LaserColor, 300, 7);
ParticleManager.CreateParticle(new Vector3(EndPosition.X, 0, EndPosition.Y), Vector3.Zero, LaserColor, 300, 4);
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
Vector2 UpperLeftCorner = Logic.Min(StartPosition, EndPosition) - new Vector2(200);
Vector2 LowerRightCorner = Logic.Max(StartPosition, EndPosition) + new Vector2(200);
QuadGridXMin = (int)((UpperLeftCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridXMax = (int)((LowerRightCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridYMin = (int)((UpperLeftCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
QuadGridYMax = (int)((LowerRightCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
if (QuadGridXMax > quadGrid.CellsX - 1)
{
QuadGridXMax = quadGrid.CellsX - 1;
}
if (QuadGridXMin > quadGrid.CellsX - 1)
{
QuadGridXMin = quadGrid.CellsX - 1;
}
if (QuadGridYMax > quadGrid.CellsY - 1)
{
QuadGridYMax = quadGrid.CellsY - 1;
}
if (QuadGridYMin > quadGrid.CellsY - 1)
{
QuadGridYMin = quadGrid.CellsY - 1;
}
if (QuadGridXMax < 0)
{
QuadGridXMax = 0;
}
if (QuadGridXMin < 0)
{
QuadGridXMin = 0;
}
if (QuadGridYMax < 0)
{
QuadGridYMax = 0;
}
if (QuadGridYMin < 0)
{
QuadGridYMin = 0;
}
foreach (Basic2DObject g in quadGrid.Enumerate(QuadGridXMin, QuadGridYMin, QuadGridXMax, QuadGridYMax))
{
if (g.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)g;
if (!s.IsAlly(this) && CheckCircle(s, StartPosition, EndPosition, LineWidth))
{
s = s.ReturnCollision();
s.Damage(LaserDamage * GetDamageMult(), 1, EndPosition - StartPosition, this, AttackType.Red);
}
}
}
}
public virtual Vector2 GetPlacePosition(int FactionNumber)
{
float BestScore = -500000;
Vector2 BestPosition = Vector2.Zero;
float Distance = 1000;
float JumpSize = 100;
Vector2 MinPos = new Vector2(10000);
Vector2 MaxPos = new Vector2(-10000);
foreach (MiningPlatform m in GameManager.GetLevel().getCurrentScene().Enumerate(typeof(MiningPlatform)))
{
if (m.GetTeam() == FactionManager.GetTeam(FactionNumber) && !m.Dead)
{
MinPos = Vector2.Min(MinPos, m.Position.get() - new Vector2(Distance));
MaxPos = Vector2.Max(MaxPos, m.Position.get() + new Vector2(Distance));
}
}
Basic2DScene b = (Basic2DScene)GameManager.GetLevel().getCurrentScene();
MinPos = Vector2.Max(MinPos, b.MinBoundary.get());
MaxPos = Vector2.Min(MaxPos, b.MaxBoundary.get());
for (float x = MinPos.X; x < MaxPos.X; x += JumpSize)
{
for (float y = MinPos.Y; y < MaxPos.Y; y += JumpSize)
{
if (TestFree(new Vector2(x, y), TurretSize, FactionNumber) &&
PathFindingManager.GetCellValue(new Vector2(x, y)) != PathFindingManager.DeadCell)
{
float score = 5000;
if (GetTurretFragility() != 0)
{
if (PathFindingManager.CollisionLine(new Vector2(x, y), 1, 0, 3))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), -1, 0, 3))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), 0, 1, 3))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), 0, -1, 3))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), -1, -1, 2))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), 1, -1, 2))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), -1, 1, 2))
{
score += 100 * GetTurretFragility();
}
if (PathFindingManager.CollisionLine(new Vector2(x, y), 1, 1, 2))
{
score += 100 * GetTurretFragility();
}
}
foreach (NeutralSpawn spawn in NeutralManager.SpawnList)
{
if (PathFindingManager.GetCellValue(spawn.Position.get()) > PathFindingManager.StartingCell - 50 &&
PathFindingManager.GetCellValue(spawn.Position.get()) < PathFindingManager.StartingCell - 20 &&
PathFindingManager.GetAreaClear(spawn.Position.get()))
{
if (GetTurretFragility() != 0 && PathFindingManager.CollisionLine(new Vector2(x, y), spawn.Position.get()))
{
score += 500 * GetTurretFragility();
}
if (score > BestScore)
{
MiningPlatform NearestMiningPlatform = null;
float NearestDistance = 10000;
foreach (MiningPlatform m2 in GameManager.GetLevel().getCurrentScene().Enumerate(typeof(MiningPlatform)))
{
if (m2.GetTeam() == FactionManager.GetTeam(FactionNumber) && !m2.Dead)
{
float d = Vector2.Distance(m2.Position.get(), spawn.Position.get());
if (d < NearestDistance)
{
NearestDistance = d;
NearestMiningPlatform = m2;
}
}
}
score -= Logic.DistanceLineSegmentToPoint(spawn.Position.get(),
NearestMiningPlatform.Position.get(), new Vector2(x, y)) * GetTurretAgression();
}
}
}
if (score > BestScore)
{
Basic2DScene Parent2DScene = (Basic2DScene)GameManager.GetLevel().getCurrentScene();
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(new Vector2(x, y), new Vector2(200)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
UnitBuilding s = (UnitBuilding)o;
if (s.GetTeam() == FactionManager.GetTeam(FactionNumber))
{
float d = Vector2.Distance(o.Position.get(), new Vector2(x, y));
if (d < 2000)
{
score -= (2000 - d) * GetBuildingAvoidence();
if (s.GetType().IsSubclassOf(typeof(MiningPlatform)))
{
score -= (2000 - d) * GetBaseAvoidence();
}
else if (s.GetType().IsSubclassOf(typeof(UnitTurret)))
{
UnitTurret t = (UnitTurret)s;
if (t.MyCard != null)
{
if (t.MyCard.StrongVs.Equals(StrongVs))
{
score -= (2000 - d) * GetTurretAvoidence();
}
}
else
{
if (StrongVs.Equals("Heavy"))
{
score -= (2000 - d) * GetTurretAvoidence();
}
}
}
}
}
}
}
if (score > BestScore)
{
BestScore = score;
BestPosition = new Vector2(x, y);
}
}
}
}
}
return(BestPosition);
}
public override void Update(GameTime gameTime)
{
if (!Dead)
{
if (ShutDownTime > 0 || VirusTime > 0)
{
if (ShutDownTime > 0)
{
ShutDownTime -= gameTime.ElapsedGameTime.Milliseconds * 3;
}
else
{
Rotation.set(Rotation.get() + MathHelper.ToRadians(gameTime.ElapsedGameTime.Milliseconds * 20));
}
}
else
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > SnapSearchTime)
{
SearchTime -= SnapSearchTime;
bool Found = false;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip s = (UnitShip)o;
if (!s.Dead && !s.IsAlly(this) && Vector2.Distance(Position.get(), o.Position.get()) < MaxEngagementDistance)
{
if (s.CanBeTargeted() && s.SnapBounce())
{
s.EMP(this, IsUpdgraded ? 1 : 0);
}
SnapSearchTime += (int)(StartingMaxSearchTime / 20 * (1.5f + s.UnitLevel) / 2f);
Found = true;
}
}
}
if (Found)
{
SoundManager.Play3DSound("SnapTurretFire",
new Vector3(Position.X(), Y, Position.Y()),
0.75f, 800, 2);
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * MaxEngagementDistance / 1000f * 3, ParticleColor, 40, 5);
}
for (int i = 0; i < 2; i++)
{
FlareSystem.AddLightingPoint(Position3, new Vector3(0.3f), new Vector3(0, 0, 1), MaxEngagementDistance / 10, 40, 5, 10);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 6, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 3, 4);
}
}
}
}
}
base.Update(gameTime);
}
public override void BlowUp()
{
if (Dead || Lives < 1)
{
return;
}
Vector3 P3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 10; i++)
{
LineParticleSystem.AddParticle(P3, P3 + Rand.V3() * MaxEngagementDistance, TeamInfo.GetColor(GetTeam()));
}
foreach (Faction f in FactionManager.Factions)
{
if (MyCard == null)
{
MyCard = (TurretCard)FactionCard.FactionTurretDeck[0];
}
if (f.Team != GetTeam())
{
f.roundReport.TurretsKilled++;
f.AddEvent(MyCard.Name + " Destroyed", new Color(1, 0.5f, 0.5f), FactionEvent.KillTexture);
}
else
{
f.roundReport.TurretsLost++;
f.AddEvent(MyCard.Name + " Lost", new Color(1, 0.5f, 0.5f), FactionEvent.LossTexture);
}
}
if (ShouldDeathSound)
{
SoundManager.Play3DSound(DeathSound, new Vector3(Position.X(), Y, Position.Y()), DeathVolume, 1000, 1);
ShouldDeathSound = false;
}
FreezeMult = 0;
VirusTime = 0;
DeathParticles();
Lives--;
Dead = true;
if (MyBustedTurret == null)
{
MyBustedTurret = new BustedTurret(this);
ParentLevel.AddObject(MyBustedTurret);
MyBustedTurret.SetPosition(getPosition());
}
MyBustedTurret.WorldMatrix = WorldMatrix;
MyBustedTurret.Activate();
InstanceManager.RemoveChild(this);
RemoveTag(GameObjectTag._2DSolid);
RemoveTag(GameObjectTag._2DForward);
LinkedList <GameObject> GList = Parent2DScene.GetList(GameObjectTag._2DSolid);
if (GList.Contains(this))
{
GList.Remove(this);
}
BuildTimer = 0;
float BulletExplosionDistance = 200;
float BulletExplosionDamage = 1f;
QuadGrid grid = Parent2DScene.quadGrids.First.Value;
for (int i = 0; i < 2; i++)
{
bool ActivateDeathSound = true;
foreach (Basic2DObject o in grid.Enumerate(Position.get(), new Vector2(BulletExplosionDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
float dist = Vector2.Distance(s.Position.get(), Position.get()) - o.Size.X() / 2;
if (dist < BulletExplosionDistance && GetTeam() != s.GetTeam() && s.CanBeTargeted())
{
float DistMult = 1;
if (dist > 0)
{
DistMult = (BulletExplosionDistance - dist) / BulletExplosionDistance;
}
if (s.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip ship = (UnitShip)s;
ship.CanDeathSound = ActivateDeathSound;
}
s.Damage(DistMult * BulletExplosionDamage, DistMult, Vector2.Normalize(s.Position.get() - Position.get()), this, AttackType.Explosion);
if (s.Dead)
{
ActivateDeathSound = false;
}
else if (s.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip ship = (UnitShip)s;
ship.CanDeathSound = true;
}
}
}
}
}
if (ShieldAlpha > 0)
{
ShieldInstancer.Remove(this);
ShieldAlpha = -1;
}
}
private void TestCollisions()
{
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
Vector2 UpperLeftCorner = Vector2.Zero;
Vector2 LowerRightCorner = Vector2.Zero;
if (SearchTime < MaxSearchTime)
{
UpperLeftCorner = Logic.Min(PreviousPosition, getPosition());
LowerRightCorner = Logic.Max(PreviousPosition, getPosition());
}
else
{
SearchTime = 0;
UpperLeftCorner = Logic.Min(PreviousPosition, getPosition() - BulletDodgeDistance);
LowerRightCorner = Logic.Max(PreviousPosition, getPosition() + BulletDodgeDistance);
}
if (UpperLeftCorner.X < quadGrid.Min.X || UpperLeftCorner.Y < quadGrid.Min.Y ||
LowerRightCorner.X > quadGrid.Max.X || LowerRightCorner.Y > quadGrid.Max.Y)
{
return;
}
QuadGridXMin = (int)((UpperLeftCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridXMax = (int)((LowerRightCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X);
QuadGridYMin = (int)((UpperLeftCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
QuadGridYMax = (int)((LowerRightCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y);
foreach (Basic2DObject g in quadGrid.Enumerate(QuadGridXMin, QuadGridYMin, QuadGridXMax, QuadGridYMax))
{
if (g.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
if (CheckCircle(g))
{
BasicShipGameObject s = (BasicShipGameObject)g;
s = s.ReturnCollision();
if (s != null && s.StopsBullet(ParentUnit))
{
Collide(s);
if (Destroyed)
{
return;
}
}
}
else if (g.GetType().IsSubclassOf(typeof(UnitShip)))
{
float d = Vector2.Distance(getPosition(), g.getPosition());
if (d < BulletDodgeDistance.X && d - Speed.Length() / 4 > Vector2.Distance(Position.get() + Speed, g.getPosition()))
{
UnitShip u = (UnitShip)g;
if (u.BulletDodgeDistance > 0 && !u.IsAlly(ParentUnit))
{
u.SetBulletToDodge(this);
}
}
}
}
}
}
public override void Update(GameTime gameTime)
{
if (!BulletHasBounced)
{
if (CurrentAttackTarget != null && CurrentAttackTarget.CanBeTargeted())
{
Speed = Vector2.Normalize(CurrentAttackTarget.Position.get() - Position.get()) * Speed.Length();
}
else
{
if (CurrentAttackTarget == null)
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
}
else
{
SearchTime = MaxSearchTime + 1;
}
if (SearchTime > MaxSearchTime)
{
CurrentAttackTarget = null;
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
float BestDistance = SearchDistance;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(SearchDistance)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBasic)) && !o.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
float d = Vector2.Distance(Position.get(), o.Position.get());
if (d < BestDistance)
{
UnitBasic u = (UnitBasic)o;
if (!u.IsAlly(ParentUnit))
{
CurrentAttackTarget = u;
BestDistance = d;
}
}
}
}
}
}
}
float Mult = (TimeAlive * 2 / LifeTime + 1) * 0.5f;
Vector3 Position3 = new Vector3(Position.X(), Y, Position.Y());
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 60 * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, (70 + Rand.F() * 70) * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, (60 + Rand.F() * 20) * Mult, 2);
if (!Flashed)
{
Mult = 1.5f;
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 80 * Mult, 0);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, 80 * Mult, 4);
Flashed = true;
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
if (!Dead)
{
if (ShutDownTime > 0 || VirusTime > 0)
{
ShutDownTime = 0;
VirusTime = 0;
}
else
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > PulseSearchTime)
{
SearchTime -= PulseSearchTime;
bool Found = false;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(MaxEngagementDistance * 2)))
{
if (o.GetType().IsSubclassOf(typeof(UnitShip)))
{
UnitShip s = (UnitShip)o;
if (!s.Dead && !s.IsAlly(this) && Vector2.Distance(Position.get(), o.Position.get()) < MaxEngagementDistance)
{
if (s.CanBeTargeted() && s.SnapBounce())
{
s.ShieldDamage = s.ShieldToughness + 1;
s.LastDamager = this;
s.FreezeTime = 1000;
s.StunState = AttackType.Melee;
s.SetSpeed(Vector2.Normalize(s.Position.get() - Position.get()) * 16);
}
PulseSearchTime += (int)(StartingMaxSearchTime / 100f * (1.5f + s.UnitLevel));
Found = true;
}
}
}
if (Found)
{
SoundManager.Play3DSound("PulseTurretFire",
new Vector3(Position.X(), Y, Position.Y()),
0.75f, 800, 2);
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
for (int i = 0; i < 30; i++)
{
ParticleManager.CreateParticle(Position3, Rand.V3() * MaxEngagementDistance / 1000f * 3, ParticleColor, 40, 5);
}
for (int i = 0; i < 2; i++)
{
FlareSystem.AddLightingPoint(Position3, new Vector3(0.3f), new Vector3(0, 0, 1), MaxEngagementDistance / 10, 40, 5, 10);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 6, 5);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor, MaxEngagementDistance * 3, 4);
}
}
}
}
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
SoundInstance = SoundManager.PlayLoopingSound(SoundInstance, "FieldHum",
new Vector3(Position.X(), Y, Position.Y()), 0.05f, 800, 2);
/*
* if (Parent2DScene.WorldViewerChildren.Count != ActiveSounds.Count)
* {
* SoundManager.Play3DSound("FieldCast", new Vector3(Position.X(), Y, Position.Y()), Vector3.Zero, 1, false);
*
* foreach (SoundManager.ActiveSound a in ActiveSounds)
* a.Instance.Stop();
*
* SoundManager.Play3DSound("MiningRingHum", new Vector3(Position.X(), Y, Position.Y()), Vector3.Zero, 0.25f, true);
* ActiveSounds.Clear();
*
* for (int i = 0; i < Parent2DScene.WorldViewerChildren.Count; i++)
* ActiveSounds.AddLast(SoundManager.ActiveSounds[SoundManager.ActiveSoundCount - (i + 1)]);
* }
*/
for (int i = 0; i < CircleGlows; i++)
{
float R = (float)(((float)i / CircleGlows * 2 * Math.PI) + (Level.Time % 2 / 2f * Math.PI) / 2);
Vector3 P = new Vector3((float)Math.Cos(R) * Size.X() + Position.X(), 0, (float)Math.Sin(R) * Size.X() + Position.Y());
ParticleManager.CreateParticle(P, Vector3.Zero, CircleColor * Alpha, 64, 0);
}
TimeAlive += gameTime.ElapsedGameTime.Milliseconds;
if (TimeAlive > LifeTime)
{
Alpha -= gameTime.ElapsedGameTime.Milliseconds * 60 / 1000f * AlphaChangeRate;
if (Alpha < 0)
{
Destroy();
}
}
else
{
TargetSize -= Vector2.One * 0.25f * gameTime.ElapsedGameTime.Milliseconds * 60 / 1000f;
Size.setNoPerform(Size.get() + Vector2.One * 4 * gameTime.ElapsedGameTime.Milliseconds * 60 / 1000f);
if (Size.X() > TargetSize.X)
{
Size.setNoPerform(TargetSize);
}
if (Alpha < 1)
{
Alpha += gameTime.ElapsedGameTime.Milliseconds * 60 / 1000f * AlphaChangeRate;
if (Alpha > 1)
{
Alpha = 1;
}
}
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
if (SearchTime > MaxSearchTime)
{
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), Size.get()))
{
if ((o.GetType().IsSubclassOf(typeof(UnitShip)) || o.GetType().IsSubclassOf(typeof(PlayerShip))) && Vector2.Distance(o.Position.get(), Position.get()) < Size.X())
{
UnitBasic u = (UnitBasic)o;
if (u.GetTeam() != WaveManager.ActiveTeam)
{
EffectUnit((UnitBasic)o, gameTime);
}
}
}
}
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
if (!BulletHasBounced)
{
if (CurrentAttackTarget != null && CurrentAttackTarget.CanBeTargeted())
{
Speed = Vector2.Normalize(CurrentAttackTarget.Position.get() - Position.get()) * Speed.Length();
}
else
{
if (CurrentAttackTarget == null)
{
SearchTime += gameTime.ElapsedGameTime.Milliseconds;
}
else
{
SearchTime = MaxSearchTime + 1;
}
if (SearchTime > MaxSearchTime)
{
CurrentAttackTarget = null;
SearchTime -= MaxSearchTime;
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
float BestDistance = SearchDistance;
foreach (Basic2DObject o in quad.Enumerate(Position.get(), new Vector2(SearchDistance)))
{
if (o.GetType().IsSubclassOf(typeof(UnitBasic)) && !o.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
float d = Vector2.Distance(Position.get(), o.Position.get());
if (d < BestDistance)
{
UnitBasic u = (UnitBasic)o;
if (u.CanBeTargeted() && !ParentUnit.IsAlly(u))
{
CurrentAttackTarget = u;
BestDistance = d;
}
}
}
}
}
}
}
float Mult = (TimeAlive - MinCollideTimeAlive) / (LifeTime - MinCollideTimeAlive) * 8;
if (Mult < 1)
{
Mult = 1;
}
Mult *= 3;
Vector3 Position3 = new Vector3(Position.X(), 0, Position.Y());
FlareSystem.AddLightning(Position3, ParticleColor2, 10, 70, 3, 6);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, 60 * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (70 + Rand.F() * 70) * Mult, 1);
ParticleManager.CreateParticle(Position3, Vector3.Zero, ParticleColor2, (10 + Rand.F() * 20) * Mult, 2);
base.Update(gameTime);
}
