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)
{
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);
}
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 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();
}
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 QuadGrid Add(QuadGrid quadGrid)
{
if (MinBoundary != null)
{
quadGrid.SetDimensions(MinBoundary.get(), MaxBoundary.get(), Cells.get());
}
quadGrids.AddFirst(quadGrid);
return(quadGrid);
}
public void SetQuadGridPosition(QuadGrid quadGrid)
{
Vector2 UpperLeftCorner = getTopLeftCorner();
Vector2 LowerRightCorner = getBottomRightCorner();
QuadGridXMin = (int)MathHelper.Clamp((UpperLeftCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X, 0, quadGrid.CellsX);
QuadGridXMax = (int)MathHelper.Clamp((LowerRightCorner.X - quadGrid.Min.X) / quadGrid.CellSize.X, 0, quadGrid.CellsX - 1);
QuadGridYMin = (int)MathHelper.Clamp((UpperLeftCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y, 0, quadGrid.CellsY);
QuadGridYMax = (int)MathHelper.Clamp((LowerRightCorner.Y - quadGrid.Min.Y) / quadGrid.CellSize.Y, 0, quadGrid.CellsY - 1);
}
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 void SetQuadGridPosition(Vector2 UpperLeftCorner, Vector2 LowerRightCorner)
{
QuadGrid quadGrid = Parent2DScene.quadGrids.First.Value;
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);
QuadGridXMin = QuadGridXMin > quadGrid.CellsX - 1 ? quadGrid.CellsX - 1 : QuadGridXMin > 0 ? QuadGridXMin : 0;
QuadGridXMax = QuadGridXMax > quadGrid.CellsX - 1 ? quadGrid.CellsX - 1 : QuadGridXMax > 0 ? QuadGridXMax : 0;
QuadGridYMin = QuadGridYMin > quadGrid.CellsY - 1 ? quadGrid.CellsY - 1 : QuadGridYMin > 0 ? QuadGridYMin : 0;
QuadGridYMax = QuadGridYMax > quadGrid.CellsY - 1 ? quadGrid.CellsY - 1 : QuadGridYMax > 0 ? QuadGridYMax : 0;
}
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);
}
private void SearchForNearby()
{
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
TurretsInRange.Clear();
foreach (GameObject o in Parent2DScene.Children)
{
if (o.GetType().IsSubclassOf(typeof(BasicShipGameObject)))
{
BasicShipGameObject s = (BasicShipGameObject)o;
if (o != this && o.GetType().IsSubclassOf(typeof(UnitTurret)) && !o.GetType().Equals(typeof(MedicTurret)) && Vector2.Distance(Position.get(), s.Position.get()) < MaxEngagementDistance)
{
TurretsInRange.AddLast((UnitTurret)o);
}
}
}
}
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 bool TestFree(Vector2 Position, float Size, int FactionNumber)
{
Basic2DScene Parent2DScene = (Basic2DScene)GameManager.GetLevel().getCurrentScene();
QuadGrid quad = Parent2DScene.quadGrids.First.Value;
foreach (UnitBasic o in FactionManager.SortedUnits[FactionManager.GetTeam(FactionNumber)])
{
if (o.GetType().IsSubclassOf(typeof(UnitBuilding)))
{
UnitBuilding s = (UnitBuilding)o;
if (Vector2.Distance(Position, o.Position.get()) < (Size + o.Size.X()))
{
return(false);
}
}
}
return(true);
}
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();
}
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 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);
}
}
}
}
}
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 Create()
{
SoundLibrary.Load();
InstanceManager.Clear();
ParticleManager.Load();
Load();
OverDrawChildren2D = AddTag(GameObjectTag._2DOverDraw);
OverDrawViewsChildren = AddTag(GameObjectTag.OverDrawViews);
Draw2DChildren = AddTag(GameObjectTag._2DForward);
#if EDITOR && WINDOWS
if (ParentLevel.LevelForEditing)
{
PreDrawChildren = AddTag(GameObjectTag._2DPreDraw);
}
else
#endif
{
ForwardChildren = AddTag(GameObjectTag._3DForward);
BackgroundChildren = AddTag(GameObjectTag._3DBackground);
DepthOverChildren = AddTag(GameObjectTag._3DDepthOver);
}
SolidChildren = AddTag(GameObjectTag._2DSolid);
ShipChildren = AddTag(GameObjectTag.ShipGameUnitBasic);
DistortionChildren = AddTag(GameObjectTag._3DDistortion);
SolidQuadGrid = Add(new QuadGrid());
#if DRAWQUAD
DrawQuadGrid = Add(new QuadGrid());
#endif
FactionManager.Init();
base.Create();
}
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 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);
}
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 (!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 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 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 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);
}
