int UnitInd; //index of the next unit in one cell of gameobjects grid
#endregion Fields
#region Constructors
internal NearObjectsIterator(GameVector Center, float Radius, ArrayList[,] gameObjects)
{
this.gameObjects = gameObjects;
this.Radius = Radius;
UpdateCenter(Center);
Reset();
}
public override void Init(int PlayerNumber, IGame Game)
{
if (PlayerNumber == 0) sign = 1;
else sign = -1;
AngleForward=1.57f*(1-sign);
base.Init(PlayerNumber, Game);
cruisers= CreateSquadron();
corvettes= CreateSquadron();
destroyers= CreateSquadron();
for (int i = 0; i < friends.Count; i++)
{
if (friends[i].Type == ShipTypes.Cruiser) cruisers.AddUnit(friends[i]);
else
{
if (friends[i].Type == ShipTypes.Destroyer)
{
destroyers.AddUnit(friends[i]);
}
else
{
corvettes.AddUnit(friends[i]);
}
}
}
center = cruisers.formation.GetMassCenter();
cruisers.SetFormationTypeLine(600);
destroyers.SetFormationTypeBar(10,200,150);
corvettes.SetFormationTypeLine(600);
corvettes.ArrayOrder(center-GameVector.UnitX*1000*sign, AngleForward);
cruisers.ArrayOrder(center, AngleForward);
destroyers.ArrayOrder(center-GameVector.UnitX * 2000*sign, AngleForward);
timer = new Timer(3);
Stage = 0;
}
public Unit(ShipTypes ShipType, string Name, GameVector Position, GameVector Size, DerivativeControlledParameter Speed,
DerivativeControlledParameter RotationSpeed,
DerivativeControlledParameter RotationAngle, Gun Gun, float HP, int team, Shots shots, float BlowDamage, float BlowRadius)
{
shipType = ShipType;
blowDamage = BlowDamage;
blowRadius = BlowRadius;
name = Name;
position = Position;
size = Size;
speed = Speed;
rotationSpeed = RotationSpeed;
rotationAngle = RotationAngle;
gun = Gun;
gun.owner = this;
this.hp = HP;
this.team = team;
maxTimeAfterDeath = 5 * 0.2f;
timeAfterDeath = 0;
IsAliveInPrevLoop = true;
this.shots = Core.shots;
}
public void GetNearObjects(GameVector Position, float Radius, out List<Unit> NearUnits, out List<Shots.Shot> NearShots)
{
NearUnits = new List<Unit>();
NearShots = new List<Shots.Shot>();
int RadiusLogic = (int)(Radius / cellSize) + 1;// (int)(CruiserSize.Y / (border / (float)gameObjectsCCells)) + 1;
int X = GetLogicCoo(Position.X);
int Y = GetLogicCoo(Position.Y);
//if (RadiusLogic == 0 && (GetLogicCoo(X + 10) != X || GetLogicCoo(X - 10) != X || GetLogicCoo(Y + 10) != Y || GetLogicCoo(Y - 10) != Y))
//{
// RadiusLogic++;
//}
int minX, minY, maxX, maxY;
minX = (int)Math.Min(Math.Max(X - RadiusLogic, 0), gameObjectsCCells - 1);
minY = (int)Math.Min(Math.Max(Y - RadiusLogic, 0), gameObjectsCCells - 1);
maxX = (int)Math.Min(Math.Max(X + RadiusLogic, 0), gameObjectsCCells - 1);
maxY = (int)Math.Min(Math.Max(Y + RadiusLogic, 0), gameObjectsCCells - 1);
int i, j, k;
for (i = minX; i <= maxX; i++)
for (j = minY; j <= maxY; j++)
{
for (k = 0; k < gameObjects[i, j].Count; k++)
{
Unit nearUnit = gameObjects[i, j][k] as Unit;
if (nearUnit != null)
{
NearUnits.Add(nearUnit);
}
else
{
Shots.Shot nearShot = gameObjects[i, j][k] as Shots.Shot;
if (nearShot != null)
{
NearShots.Add(nearShot);
}
}
}
}
}
/// <summary>
/// finds distance square between two points
/// </summary>
/// <param name="pt1">first operand</param>
/// <param name="pt2">second operand</param>
/// <returns>float distance square</returns>
public static float DistanceSquared(GameVector pt1, GameVector pt2)
{
return (pt2 - pt1).LengthSquared();
}
public void Update()
{
lifeTime -= Core.Timing.DeltaTime;
PrevPos = pos;
pos += direction * Core.Timing.DeltaTime;
}
/// <summary>
/// mulls GameVector with specified matrix
/// </summary>
/// <param name="vec"></param>
/// <param name="matrix"></param>
/// <returns></returns>
public static GameVector Mull(GameVector vec, Matrix matrix)
{
return new GameVector(
matrix.values[0, 0] * vec.X + matrix.values[1, 0] * vec.Y + matrix.values[2, 0],
matrix.values[0, 1] * vec.X + matrix.values[1, 1] * vec.Y + matrix.values[2, 1]);
}
/// <summary>
/// calculates rotated vector
/// </summary>
/// <param name="Vector">vector to rotate</param>
/// <param name="Angle">angle in radians to rotate CCW</param>
/// <returns>rotated vector</returns>
public static GameVector Rotate(GameVector Vector, float Angle)
{
return new GameVector((float)(Vector.X * Math.Cos(Angle) - Vector.Y * Math.Sin(Angle)), (float)(Vector.X * Math.Sin(Angle) + Vector.Y * Math.Cos(Angle)));
}
public void HitSomebody(GameVector where)
{
hitSomebody = true;
}
/// <summary>
/// value is constant vector
/// </summary>
/// <param name="value">value vector</param>
public RelativeVector(GameVector value)
{
constValue = value;
mode = Modes.ConstVector;
}
public override void CreatePositions(GameVector CenterPosition, float Angle)
{
if (subordinates.Count > 0)
{
rotationAngle = Angle;
GameVector center = CenterPosition;
DefineLinesFormation(Angle);
int CLines = (subordinates.Count - 1) / cUnitsInLine + 1;
int ind = 0;
for (int currLine = 0; currLine < CLines; currLine++)
{
for (int currColumn = 0; currColumn < cUnitsInLine && ind < subordinates.Count; currColumn++)
{
subordinates[ind].Position =
new RelativeVector(center -
LinesPosDifference * (currLine - CLines * 0.5f + 0.5f) +
NearUnitsPosDifference * (currColumn - cUnitsInLine * 0.5f + 0.5f));
ind++;
}
}
SortUnitsByNearanceToPositions();
}
}
internal void Update()
{
if (hp > 0)
{
#region obsolete
if (goesToPoint)
{
float AngleToTgt = GetAngleTo(tgtLocation);
SetAngleGoingToTgt(AngleToTgt);
float distanceSq = GameVector.DistanceSquared(position, tgtLocation);
float timeToStop = speed.Value / speed.MaxDerivative;
float StopDistanceSq = speed.Value * timeToStop - speed.MaxDerivative * timeToStop * timeToStop / 2;
if (AngleClass.Distance(GetAngleTo(tgtLocation), rotationAngle.Value) < MathHelper.PiOver4 &&
(StopDistanceSq < GameVector.DistanceSquared(position, tgtLocation) || !stopsNearPoint))
SetSpeedGoingToTgt(MaxSpeed);
else SetSpeedGoingToTgt(0);
//if (distanceSq < 30*30&&speed.Value<10) { goesToPoint = false; }
}
#endregion
gun.Update();
if (rotationAngle.AimEnabled)
{
float AimIsNearDecrementing;
//rotationAngle.RotateCCWToAngle(rotationAngle.AimedValue, out AimIsNear);
if (rotationAngle.RotateCCWToAngle(rotationAngle.AimedValue, out AimIsNearDecrementing))
{
if (rotationSpeed.Value < 0)
rotationSpeed.Derivative = rotationSpeed.MaxDerivative;
else
rotationSpeed.Derivative = rotationSpeed.MaxDerivative * AimIsNearDecrementing;
}
else
{
if (rotationSpeed.Value > 0)
rotationSpeed.Derivative = -rotationSpeed.MaxDerivative;
else
rotationSpeed.Derivative = -rotationSpeed.MaxDerivative * AimIsNearDecrementing;
}
//if (StopRotation && Math.Abs(rotationSpeed.Value) < 0.08f)
// rotationSpeed = new DerivativeControlledParameter(0, rotationSpeed.Min, rotationSpeed.Max, rotationSpeed.MaxDerivative, false);
}
//rotationSpeed.Derivative *= AimIsNearDecrementing;
rotationSpeed.Update();
rotationAngle.Derivative = rotationSpeed.Value;
// rotationAngle.Derivative = (rotationAngle.AimedValue - rotationAngle.Value) * 0.05f;
rotationAngle.Update();
speed.Update();
position += ForwardVector * speed.Value * Core.Timing.DeltaTime;
isDying = false;
}
else
{
if (IsAliveInPrevLoop) isDying = true;
else isDying = false;
timeAfterDeath += Core.Timing.DeltaTime;
IsAliveInPrevLoop = false;
}
}
private float GetAngleTo(GameVector Target)
{
return (float)Math.Atan2(Target.Y - position.Y, Target.X - position.X);
}
public void GoTo(GameVector TargetLocation, bool Stop)
{
if (AccessDenied()) return;
goesToPoint = true;
stopsNearPoint = Stop;
tgtLocation = new GameVector(TargetLocation.X, TargetLocation.Y);
}
public bool IntersectsSector(GameVector pt1, GameVector pt2)
{
GameVector intersection;
return this.GetRectangle().IntersectsLine(
pt1, pt2, out intersection);
}
public MiniGameInterfaces.Rectangle GetRectangle()
{
GameVector forward = ForwardVector;
GameVector right = new GameVector(forward.Y, -forward.X);
forward *= size.X * 0.5f;
right *= size.Y * 0.5f;
return new MiniGameInterfaces.Rectangle(forward - right + position, forward + right + position,
-forward + right + position, -forward - right + position);
}
public float AngleTo(GameVector target)
{
return GetAngleTo(new GameVector(target.X, target.Y));
}
/// <summary>
/// Calculates angle direction to Target vector end from this vector end
/// </summary>
/// <param name="Target">target vector</param>
/// <returns>angle to target</returns>
public float AngleTo(GameVector Target)
{
return (Target - this).Angle();
}
public void UpdateCenter(GameVector NewCenter)
{
Center = NewCenter;
RadiusLogic = (int)(Radius / GameObjectsClass.cellSize) + 1;
int X = GameObjectsClass.GetLogicCoo(Center.X);
int Y = GameObjectsClass.GetLogicCoo(Center.Y);
minX = (int)Math.Min(Math.Max(X - RadiusLogic, 0), GameObjectsClass.gameObjectsCCells - 1);
minY = (int)Math.Min(Math.Max(Y - RadiusLogic, 0), GameObjectsClass.gameObjectsCCells - 1);
maxX = (int)Math.Min(Math.Max(X + RadiusLogic, 0), GameObjectsClass.gameObjectsCCells - 1);
maxY = (int)Math.Min(Math.Max(Y + RadiusLogic, 0), GameObjectsClass.gameObjectsCCells - 1);
}
public override void CreatePositions(GameVector CenterPosition, float Angle)
{
rotationAngle = Angle;
Line line = DefineLineFormation(rotationAngle, CenterPosition);
CreateLinePositions(line);
SortUnitsByNearanceToPositions();
}
/// <summary>
/// Converts vector to an outputable string
/// Output example for GameVector(56.45f,67.96f) is "(56;68)"
/// </summary>
/// <param name="vec">Vector to output</param>
/// <returns>Vector in a readable format</returns>
public static string VectorToString(GameVector vec)
{
return "(" + Math.Round(vec.X) + ";" + Math.Round(vec.Y).ToString() + ")";
}
public override void CreatePositions(GameVector CenterPosition, float Angle)
{
if (subordinates.Count > 0)
{
rotationAngle = Angle;
GameVector center = CenterPosition;
float FormationLength = heightBetweenUnits * subordinates.Count / 2;
GameVector forward = GameVector.UnitX.Rotate(Angle);
GameVector right = forward.Rotate(AngleClass.pi * 0.5f);
int PositionInd;
subordinates[0].Position = new RelativeVector(center + forward * FormationLength * 0.5f);
for (int currPilot = 1; currPilot < subordinates.Count; currPilot += 2)
{
PositionInd = currPilot / 2 + 1;
subordinates[currPilot].Position = new RelativeVector(center + forward * (FormationLength * 0.5f - PositionInd * heightBetweenUnits)
+ right * (PositionInd * widthBetweenUnits));
if (currPilot + 1 < subordinates.Count)
subordinates[currPilot + 1].Position = new RelativeVector(center + forward * (FormationLength * 0.5f - PositionInd * heightBetweenUnits)
- right * (PositionInd * widthBetweenUnits));
}
}
}
/// <summary> /// Creates positions for units in this formation /// </summary> /// <param name="CenterPosition">Center of the new order</param> /// <param name="Angle">Forward angle of the new position</param> public abstract void CreatePositions(GameVector CenterPosition, float Angle);
/// <summary>
/// finds a dot product of two vectors
/// </summary>
/// <param name="pt1">first vector</param>
/// <param name="pt2">second vector</param>
/// <returns>float dot product</returns>
public static float Dot(GameVector pt1, GameVector pt2)
{
return pt1.X * pt2.X + pt1.Y * pt2.Y;
}
private void DefineLinesFormation(float Angle)
{
LinesPosDifference = GameVector.UnitX.Rotate(Angle);
NearUnitsPosDifference = LinesPosDifference.Rotate(AngleClass.pi * 0.5f);
LinesPosDifference *= widthBetweenUnits;
NearUnitsPosDifference *= heightBetweenUnits;
}
/// <summary>
/// normalizes a given vector
/// </summary>
/// <param name="pt">vector to normalize</param>
/// <returns>normalized vector</returns>
public static GameVector Normalize(GameVector pt)
{
return pt / pt.Length();
}
private Line DefineLineFormation(float RotationAngle, GameVector center)
{
float length = distBetweenUnits * (subordinates.Count - 1);
GameVector toVertexDir = GameVector.UnitX.Rotate(RotationAngle + AngleClass.pi * 0.5f) * 0.5f * length;
return new Line(center + toVertexDir, center - toVertexDir);
}
public Unit(ShipTypes ShipType, int Player, GameVector Position, float Angle, string Name)
{
shipType = ShipType;
switch (shipType)
{
case ShipTypes.Destroyer:
blowDamage = 70;
blowRadius = 40;
name = Name;
position = Position;
size = Core.DestroyerSize;
speed = new DerivativeControlledParameter(0, 0, 20 * TimingClass.SpeedsMultiplier, 9 * TimingClass.SpeedsMultiplier, false);
rotationSpeed = new DerivativeControlledParameter(0, -0.22f * TimingClass.SpeedsMultiplier, 0.22f * TimingClass.SpeedsMultiplier, 0.5f * TimingClass.SpeedsMultiplier, false);
rotationAngle = new DerivativeControlledParameter(Angle, -MathHelper.Pi, MathHelper.Pi, 1000, true);
gun = new Gun(1, 50 * TimingClass.SpeedsMultiplier, 9 / TimingClass.SpeedsMultiplier, 15);
gun.owner = this;
this.hp = 80;
this.team = Player;
maxTimeAfterDeath = 5 * 0.2f;
timeAfterDeath = 0;
IsAliveInPrevLoop = true;
this.shots = Core.shots;
break;
case ShipTypes.Corvette:
blowDamage = 150;
blowRadius = 120;
maxTimeAfterDeath = 5 * 0.2f;
speed = new DerivativeControlledParameter(0, 0, 5 * TimingClass.SpeedsMultiplier, 1 * TimingClass.SpeedsMultiplier, false);
rotationSpeed = new DerivativeControlledParameter(0, -0.12f * TimingClass.SpeedsMultiplier, 0.12f * TimingClass.SpeedsMultiplier, 0.39f * TimingClass.SpeedsMultiplier, false);
gun = new Gun(1, 50 * TimingClass.SpeedsMultiplier, 18 / TimingClass.SpeedsMultiplier, 40);
this.hp = 400;
this.team = Player;
IsAliveInPrevLoop = true;
this.shots = Core.shots;
timeAfterDeath = 0;
name = Name;
position = Position;
size = Core.CorvetteSize;
//size.Y *= 0.9f; //real object size (see texture)
rotationAngle = new DerivativeControlledParameter(
Angle
, -MathHelper.Pi, MathHelper.Pi, 1000, true);
gun.owner = this;
break;
case ShipTypes.Cruiser:
blowDamage = 300;
blowRadius = 150;
maxTimeAfterDeath = 8 * 0.2f;
speed = new DerivativeControlledParameter(0, 0, 2 * TimingClass.SpeedsMultiplier, 1.0f * TimingClass.SpeedsMultiplier, false);
rotationSpeed = new DerivativeControlledParameter(0, -0.05f * TimingClass.SpeedsMultiplier, 0.05f * TimingClass.SpeedsMultiplier, 0.2f * TimingClass.SpeedsMultiplier, false);
gun = new Gun(4, 50 * TimingClass.SpeedsMultiplier, 27 / TimingClass.SpeedsMultiplier, 200);
this.hp = 800;
this.team = Player;
IsAliveInPrevLoop = true;
this.shots = Core.shots;
timeAfterDeath = 0;
name = Name;
position = Position;
size = Core.CruiserSize;
//size.X *= 0.7f; //real object size (see texture)
//size.Y *= 0.9f; //real object size (see texture)
rotationAngle = new DerivativeControlledParameter(
Angle
, -MathHelper.Pi, MathHelper.Pi, 1000, true);
gun.owner = this;
break;
}
}
public override void CreatePositions(GameVector CenterPosition, float Angle)
{
//nothing to do
}
public Shot(GameVector Pos, GameVector Dir, float Damage, float LifeTime, Unit ParentUnit)
{
parent = ParentUnit;
switch (parent.ShipType)
{
case ShipTypes.Destroyer:
size = 24; break;
case ShipTypes.Corvette:
size = 48; break;
case ShipTypes.Cruiser:
size = 90; break;
default: size = 1; break;
}
pos = Pos;
PrevPos = pos;
direction = Dir;
damage = Damage;
lifeTime = LifeTime;
hitSomebody = false;
forward = GameVector.Normalize(direction);
}