public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
int width = 0;
int height = 0;
foreach ( ProjectileObject Projectile in Projectiles )
{
if ( Projectile is AProj )
{
width = ( ( AProj )Projectile ).ScrWidth;
height = ( ( AProj )Projectile ).ScrHeight;
}
}
TimeSpan passedTime = ( gameTime.TotalGameTime - startTime );
if ( passedTime.TotalMilliseconds % 200 < 10 && !didShoot )
{
foreach ( TankObject Tank in Tanks )
{
if ( Tank.IsInGame )
{
Tank.Shoot( gameTime, width, height, Projectiles );
}
}
didShoot = true;
}
else didShoot = false;
base.Update( gameTime, Tanks );
return true;
}
public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
/*
if ( !didSuperNova )
{
//All of-
Random random = new Random();
HashSet<TankObject> TankSet = new HashSet<TankObject>( Tanks );
foreach ( TankObject tank in Tanks )
{
if ( !tank.IsInGame )
{
TankSet.Remove( tank );
}
}
TankObject SuperNover = ( TankSet.ToArray<TankObject>() )[ random.Next( TankSet.Count ) ];
//-that shit, for a random tank :(
Vector2 wh = GameTools.GetWH( Projectiles );
for ( float angle = 0; angle < 360; angle += 0.5F )
{
float supernovaSpeed = 1;
Projectiles.Add( new BasicBullet( wh / 2, angle, gameTime, ( int )wh.X, ( int )wh.Y, supernovaSpeed, new TankObject() ) ); // Either in the middle
//Projectiles.Add( new BasicBullet( SuperNover.Position, angle, gameTime, ( int )wh.X, ( int )wh.Y, supernovaSpeed, new TankObject() ) ); // or a random tank just blows the f**k up.
}
didSuperNova = true;
}*/
base.Update( gameTime, Tanks );
return true;
}
public PowerUp( TankObject owner, GameTime gameTime )
{
random = new Random();
Taken = true;
Owner = owner;
creationTime = gameTime.TotalGameTime;
}
public override void Use( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
foreach ( ProjectileObject Proj in Projectiles )
{
Proj.Turn( 180 );
}
}
public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
if ( width == 0 || height == 0 )
{
foreach ( ProjectileObject proj in Projectiles )
{
if ( proj is AProj )
{
width = ( ( AProj )proj ).ScrWidth;
height = ( ( AProj )proj ).ScrHeight;
}
}
}
if ( ( gameTime.TotalGameTime - startTime ).TotalMilliseconds % 2000 < 10 && !didShoot )
{
Projectiles.Add( new HomingBullet( new Vector2( 10, 10 ), 45, gameTime, width, height, 5, MyTank ) );
Projectiles.Add( new HomingBullet( new Vector2( width - 10, 10 ), 135, gameTime, width, height, 5, MyTank ) );
Projectiles.Add( new HomingBullet( new Vector2( 10, height - 10 ), 315, gameTime, width, height, 5, MyTank ) );
Projectiles.Add( new HomingBullet( new Vector2( width - 10, height - 10 ), 225, gameTime, width, height, 5, MyTank ) );
didShoot = true;
}
//else didShoot = false;
base.Update( gameTime, Tanks );
return true;
}
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups )
{
if ( ( gameTime.TotalGameTime - originalTime ).TotalMilliseconds > 2000 ) //If I should start homing,
{
TankObject ClosestTank = null; // I find the closest tank to me
float dist = float.PositiveInfinity;
foreach ( TankObject Tank in Tanks )
{
float d = Vector2.Distance( Tank.Position, Position ); // by taking the distance of every tank
if ( d < dist && Tank.IsInGame/* && ( !Owner.TeamShield || Tank.TeamString != Owner.TeamString )*/ ) // and finding the shortest.
{
dist = d;
ClosestTank = Tank;
}
}
if ( ClosestTank != null ) // Then if there is a tank i can home onto,
{
float ang = ( ( ( float )Math.Atan2( Position.Y - ClosestTank.Position.Y, Position.X - ClosestTank.Position.X ) * 180 / ( float )Math.PI ) + 180 ) % 360; // I home onto it by finding my angle from the tank
angle = ang; // and changing my flight angle into that.
// I know there are better ways of homing - I just don't know how to use them.
// If anyone could put a code that makes the homing bullet change only 5 degrees a second, that would be great.
}
}
return UpdatePhysics( gameTime, Tanks, Fences, false ) ? true : base.Update( gameTime, Tanks, Fences, Pickups );
}
public PowerUp( GameTime gameTime, int duration )
{
random = new Random();
Taken = false;
Owner = null;
creationTime = gameTime.TotalGameTime;
time = duration;
}
public override bool Draw( SpriteBatch spriteBatch, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, GameTime gameTime )
{
if ( BlackHoleTex != null && Position != Vector2.Zero )
{
spriteBatch.Draw( BlackHoleTex, Position, null, Color.White, 0, new Vector2( 16, 16 ), scale, SpriteEffects.None, 0 );
}
return true;
}
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
if ( position == Vector2.Zero )
{
position = GameTools.GetWH( Projectiles ) / 2;
}
return didExplode;
}
/// <summary>
/// Updates the game using the power-up's logic.
/// </summary>
/// <param name="gameTime">The current game time.</param>
/// <param name="Tanks">The playing tanks.</param>
/// <param name="Projectiles">The projectiles on-board.</param>
/// <param name="Fences">The fences on-board.</param>
/// <returns>Whether the power-up should disappear or not.</returns>
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
if ( Taken )
{
return true;
}
return false;
}
public Missile( Vector2 position, float angle, GameTime gameTime, int width, int height, float factor, TankObject owner, bool toExplode )
: base(position, angle, gameTime, width, height, factor, owner)
{
random = new Random();
if ( toExplode )
{
Explode( gameTime );
}
}
public override bool Draw( SpriteBatch spriteBatch, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, GameTime gameTime )
{
for ( int i = 0; i < awesomeFacePositions.Count; i++ )
{
spriteBatch.Draw( awesomeFace, awesomeFacePositions[ i ], null, awesomeFaceColors[ i ], 0, Vector2.Zero, 1, SpriteEffects.None, 1 );
awesomeFacePositions[ i ] += new Vector2( xAdvances[ i ], yAdvances[ i ] );
}
return false;
}
public override bool Hit( TankObject Hitten )
{
if ( !didHit )
{
didHit = true;
return false;
}
else return true;
}
/// <summary>
/// Updates the game with the power-up's effect.
/// </summary>
/// <param name="gameTime">The current game time.</param>
/// <param name="Tanks">The playing tanks.</param>
/// <param name="Projectiles">The projectiles on-board.</param>
/// <param name="Fences">The fences on-board.</param>
/// <returns>Whether the power-up should disappear or not.</returns>
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
TimeSpan now = gameTime.TotalGameTime;
if ( ( now - creationTime ).TotalMilliseconds > time )
{
return true;
}
return false;
}
protected void Update( GameTime gameTime, TankObject[] Tanks )
{
if ( ( gameTime.TotalGameTime - startTime ).TotalMilliseconds > time )
{
foreach ( TankObject t in Tanks )
{
t.Kill();
}
}
}
public static void CreateMyAsset()
{
TankObject asset = ScriptableObject.CreateInstance <TankObject>();
AssetDatabase.CreateAsset(asset, "Assets/ScriptableObjects/TankObject.asset");
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
}
public Concealer( GameTime gameTime )
: base(gameTime, 10000)
{
toSwitch = random.Next( 2 ) == 0;
if ( Owner != null )
{
SwitchedTank = Owner;
origColor = Owner.TankColor;
origKeys = Owner.Keys;
}
}
public ProjectileObject( Vector2 position, float angle, GameTime gameTime, int width, int height, float factor, TankObject owner )
{
this.Position = position;
this.speed = factor;
this.angle = angle;
originalTime = gameTime.TotalGameTime;
this.width = width;
this.height = height;
Owner = owner;
duration = Owner.ShotTime;
doesCount = true;
}
public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
foreach ( TankObject Tank in Tanks )
{
Tank.Scale -= 0.1F;
if ( Tank.Scale <= 0.1F )
{
Tank.Kill();
}
}
return false;
}
public override void Use( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
HashSet<Pickup> pickups = new HashSet<Pickup>( Pickups );
foreach ( Pickup pickup in pickups ) Pickups.Remove( pickup );
HashSet<ProjectileObject> projectiles = new HashSet<ProjectileObject>( Projectiles );
foreach ( ProjectileObject p in projectiles ) if ( !( p is AProj ) ) Projectiles.Remove( p );
foreach ( TankObject t in Tanks )
{
t.RemovePowerUps();
t.ShotsOnBoard = 0;
}
}
public override bool BulletHit( ProjectileObject Proj, TankObject Requestor )
{
if ( Requestor == Owner )
{
Proj.Turn( 180 );
return false;
}
else
{
Requestor.IsInGame = false;
return true;
}
}
public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
foreach ( TankObject Tank in Tanks )
{
if ( Tank.IsInGame )
{
Missile missile = new Missile( Tank.Position, Tank.Rotation, gameTime, 1000, 1000, 1F, Tank, true );
Projectiles.Add( missile );
Tank.Kill();
}
}
base.Update( gameTime, Tanks );
return true;
}
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
TimeSpan now = gameTime.TotalGameTime;
if ( Taken )
{
DoPickup( Tanks, Projectiles, Fences );
if ( ( now - takeTime ).TotalMilliseconds > time )
{
return true;
}
}
return false;
}
//[TestMethod]
public void CreateTankObjectTest()
{
GameSession.Tank testTank = new Tank(1, 1, true, new VTankObject.Point(1, 1),
new VTankObject.TankAttributes("test", .5f, .5f, 1, 100, "testModel",
new VTankObject.Weapon(1, 1, "testWeapon", "testWeaponModel", "testSoundEffect",
new VTankObject.Projectile(1, 1, 1, 1, "testProjectileModel")),
new VTankObject.VTankColor(1, 1, 1)), Alliance.NONE);
TankObject resultTank = manager.CreateTankObject(testTank);
Assert.AreEqual(resultTank.ClientID, testTank.id);
Assert.AreEqual(resultTank.Alive, testTank.alive);
Assert.AreEqual(resultTank.Angle, testTank.angle);
Assert.AreEqual(resultTank.Turret.TurretModel, testTank.attributes.weapon.model);
Assert.AreEqual(resultTank.Health, testTank.attributes.health);
}
void DestroyTank()
{
TankObject toDestroy = null;
foreach (TankObject t in EnemyTank.enemies)
{
if (t.GetGameObject().Equals(gameObject))
{
toDestroy = t;
break;
}
}
Destroy(gameObject);
EnemyTank.enemies.Remove(toDestroy);
}
void Update()
{
if (aimedAt != null)
{
Quaternion rotation = Quaternion.LookRotation(aimedAt.position - turret.position);
turret.rotation = Quaternion.Slerp(turret.rotation, rotation, Time.deltaTime * stats.turretRotation);
}
if (!modellLoaded)
{
GameObject tankModel = (GameObject)Resources.Load(TANKFOLDER + stats.modelname);
GameObject newModel = Instantiate(tankModel, transform.position, transform.rotation);
newModel.transform.SetParent(transform);
model = newModel.GetComponent <TankObject>();
modellLoaded = true;
}
}
public override void Use( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
TankObject ClosestTank = Owner;
float ShortestDistance = float.PositiveInfinity;
foreach ( TankObject Tank in Tanks )
{
float dist = Vector2.Distance( Owner.Position, Tank.Position );
if ( dist < ShortestDistance && !Tank.Equals( Owner ) && Tank.IsInGame )
{
ShortestDistance = dist;
ClosestTank = Tank;
}
}
Vector2 OwnerPos = Owner.Position;
float OwnerRot = Owner.Rotation;
bool isOwnerInGame = Owner.IsInGame;
float OwnerScale = Owner.Scale;
TimedPowerUp p = Owner.powerUp;
TimedPowerUp n = ClosestTank.powerUp;
Owner.Position = ClosestTank.Position;
Owner.Rotation = ClosestTank.Rotation;
if ( Owner.powerUp != null )
{
Owner.powerUp.Revert();
Owner.powerUp = null;
}
Owner.Scale = ClosestTank.Scale;
Owner.IsInGame = ClosestTank.IsInGame;
if ( n != null )
{
Owner.AppendPowerUp( n, gameTime );
}
ClosestTank.Position = OwnerPos;
ClosestTank.Rotation = OwnerRot;
if ( ClosestTank.powerUp != null )
{
ClosestTank.powerUp.Revert();
ClosestTank.powerUp = null;
}
if ( p != null )
{
ClosestTank.AppendPowerUp( p, gameTime );
}
ClosestTank.Scale = OwnerScale;
ClosestTank.IsInGame = isOwnerInGame;
}
// Use this for initialization
void Start()
{
// Mark the start of the gameplay scene
m_gameplayStartTime = Time.time;
// Spawn player
m_playerObject = Instantiate(m_PlayerObjectPrefab);
// Make sure to spawn player in the air
m_playerObject.transform.position += new Vector3(0, 5, 0);
m_playerObject.SetSceneManager(this);
// Spawn neutral objects
for (int i = 0; i < 10; i++)
{
NeutralObject newNeutral = Instantiate(m_NeutralObjectPrefab, Vector3.zero, Quaternion.identity, m_NeutralObjectStorage);
newNeutral.transform.position = RandomizeSpawn(newNeutral.transform.position);
}
// Spawn enemy objects
for (int i = 0; i < 10; i++)
{
EnemyObject newEnemy = Instantiate(m_EnemyObjectPrefab, Vector3.zero, Quaternion.identity, m_EnemyObjectStorage);
newEnemy.transform.position = RandomizeSpawn(newEnemy.transform.position);
}
// Spawn neutral buildings
for (int i = 0; i < 10; i++)
{
NeutralBuildingObject newNeutralBuilding = Instantiate(m_NeutralBuildingObjectPrefab, Vector3.zero, Quaternion.identity, m_NeutralBuildingObjectStorage);
newNeutralBuilding.transform.position = RandomizeSpawn(newNeutralBuilding.transform.position);
}
// Spawn enemy building
for (int i = 0; i < 10; i++)
{
EnemyBuildingObject newEnemyBuilding = Instantiate(m_EnemyBuildingObjectPrefab, Vector3.zero, Quaternion.identity, m_EnemyBuildingObjectStorage);
newEnemyBuilding.transform.position = RandomizeSpawn(newEnemyBuilding.transform.position);
}
TankObject newTankObject = Instantiate(m_TankObjectPrefab, Vector3.zero, Quaternion.identity, m_TankObjectStorage);
newTankObject.transform.position = RandomizeSpawn(newTankObject.transform.position);
}
public async Task <TankObject> GetLevel(int id)
{
List <TankObject> obj = new List <TankObject>();
Procedures p = new Procedures(_db, _config);
obj = await p.getObjects();
IEnumerable <TankObject> objects = obj.AsEnumerable();
TankObject returnV = new TankObject();
foreach (TankObject item in objects)
{
if (item.Id == id)
{
returnV = item;
}
}
return(returnV);
}
public void UpdateHitBox(TankObject parent)
{
HitBoxes.Position = parent.Position;
heightBox = parent.Model.AllSprites["TankBody"].Pos.h;
widthBox = parent.Model.AllSprites["TankBody"].Pos.w;
if (heightBox >= widthBox)
{
HitBoxes.CollisionRange = heightBox;
}
else
{
HitBoxes.CollisionRange = widthBox;
}
double angle = parent.DirectionBody;
HitBoxes.hitBoxesList["Tank"] = Helper.UpdateRectangleHitBox(HitBoxes.hitBoxesList["Tank"], HitBoxes.Position, angle, widthBox, heightBox);
//HitBoxes.hitBoxesList["Tank"] = Helper.UpdateCircleHitBox(HitBoxes.hitBoxesList["Tank"], HitBoxes.Position, widthBox/2);
}
public void TakeDamage(int dmg)
{
health = health - dmg;
if (health <= 0)
{
TankObject toDestroy = null;
foreach (TankObject t in EnemyTank.enemies)
{
if (t.GetGameObject().Equals(go))
{
toDestroy = t;
break;
}
}
Destroy(go);
EnemyTank.enemies.Remove(toDestroy);
Debug.Log(enemiesDestroyed);
enemiesDestroyed++;
}
}
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
if ( Position == Vector2.Zero )
{
Position = GameTools.GetRandomPos( Projectiles );
}
foreach ( TankObject t in Tanks )
{
var T = new Tuple<TankObject, TimeSpan>( t, gameTime.TotalGameTime );
bool i = TanksToAffect.Any<Tuple<TankObject, TimeSpan>>
( x =>
{
return x.Item1 == t;
}
);
if ( Vector2.Distance( t.Position, Position ) < 16 * Scale && !i )
{
T.Item1.Speed = T.Item1.OSP * 10;
TanksToAffect.Add( T );
}
}
HashSet<Tuple<TankObject, TimeSpan>> TanksToRemove = new HashSet<Tuple<TankObject, TimeSpan>>();
foreach ( var t in TanksToAffect )
{
if ( ( gameTime.TotalGameTime - t.Item2 ).TotalMilliseconds > 100 )
{
t.Item1.Speed = t.Item1.OSP;
TanksToRemove.Add( t );
}
}
foreach ( var t in TanksToRemove )
{
TanksToAffect.Remove( t );
}
if ( base.Update( gameTime, Tanks, Projectiles, Fences ) )
{
return true;
}
return false;
}
public override bool Update( GameTime gameTime, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
if ( Taken && Owner == null )
{
HashSet<TankObject> tanks = new HashSet<TankObject>( Tanks );
foreach ( TankObject Tank in Tanks )
{
if ( ( Tank.TeamString == OrigOwner.TeamString && OrigOwner.TeamShield ) || Tank == OrigOwner || !Tank.IsInGame )
{
tanks.Remove( Tank );
}
}
if ( tanks.Count == 0 ) return true;
TankObject newOwner = ( tanks.ToArray<TankObject>() )[ random.Next( tanks.Count ) ];
newOwner.powerUp = this;
Owner = newOwner;
OrigOwner.powerUp = null;
OrigOwner = null;
takeTime = gameTime.TotalGameTime;
}
return base.Update( gameTime, Tanks, Projectiles, Fences );
}
public override bool BulletHit( ProjectileObject Proj, TankObject Requestor )
{
if ( Requestor == Owner )
{
didHit = true;
if ( Proj is BasicBullet )
{
Proj.Turn( 180 );
Proj.Position = GameTools.ReturnMove( 10, Proj.Angle, Proj.Position );
}
else
{
return true;
}
return false;
}
else
{
Requestor.IsInGame = false;
return true;
}
}
public override void DoPickup( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences )
{
if ( SwitchedTank == null )
{
SwitchedTank = Owner;
origColor = Owner.TankColor;
origKeys = Owner.Keys;
}
if ( !didSwitch && Tanks.Count<TankObject>(x => x.IsInGame) > 1)
{
HashSet<TankObject> TankSet = new HashSet<TankObject>( Tanks );
foreach ( TankObject tank in Tanks )
{
if ( !tank.IsInGame || tank == Owner )
{
TankSet.Remove( tank );
}
}
SwitchedTank = ( TankSet.ToArray<TankObject>() )[ random.Next( TankSet.Count ) ];
if ( toSwitch )
{
Vector2 OwnerPos = Owner.Position;
float OwnerRot = Owner.Rotation;
float OwnerScale = Owner.Scale;
Owner.Position = SwitchedTank.Position;
Owner.Rotation = SwitchedTank.Rotation;
Owner.Scale = SwitchedTank.Scale;
SwitchedTank.Position = OwnerPos;
SwitchedTank.Rotation = OwnerRot;
SwitchedTank.Scale = OwnerScale;
}
didSwitch = true;
}
Owner.TankColor = SwitchedTank.TankColor;
Owner.Keys = SwitchedTank.Keys;
}
public override bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime )
{
double millisecs = ( gameTime.TotalGameTime - startTime ).TotalMilliseconds;
if ( millisecs > 1000 * awesomeFacePositions.Count && millisecs < 10000 && millisecs > 1000 )
{
awesomeFacePositions.Add( new Vector2( random.Next( 1000 ), random.Next( 1000 ) ) );
int PosNeg = random.Next( -10, 10 );
xAdvances.Add( ( float )( random.NextDouble() * PosNeg ) );
yAdvances.Add( ( float )( random.NextDouble() * PosNeg ) );
awesomeFaceColors.Add( new Color( random.Next( 256 ), random.Next( 256 ), random.Next( 256 ) ) );
}
else if ( millisecs > 10000 )
{
Add( 10 );
}
if ( ( gameTime.TotalGameTime - startTime ).TotalMilliseconds > 12000 )
{
foreach ( TankObject Tank in Tanks )
{
Tank.Kill();
}
}
return true;
}
//Accessors
//Methods
override public void Update(TankObject tank, ref WorldItems world)
{
List <TankObject> nearbyTanks = new List <TankObject>();
//Add each Tank to list only if they are in a square around "tank"
foreach (GameObject entry in world.allObjects)
{
TankObject tankEntry = entry as TankObject;
if (tankEntry != null)
{
if ((Math.Abs(tankEntry.Position.x - tank.Position.x) <= MAX_AGGRO_RANGE) && (Math.Abs(tankEntry.Position.y - tank.Position.y) <= MAX_AGGRO_RANGE))
{
nearbyTanks.Add(tankEntry);
}
}
}
if ((Math.Abs(world.player.Position.x - tank.Position.x) <= MAX_AGGRO_RANGE) && (Math.Abs(world.player.Position.y - tank.Position.y) <= MAX_AGGRO_RANGE))
{
nearbyTanks.Add(world.player);
}
if (targetTank == null)
{
//Look for new targetTank
targetTank = SearchForNewTargetTank(tank, nearbyTanks);
if (targetTank != null)
{
angleFromTarget = Math.PI * Helper.random.NextDouble(); //returns number between 0 and 2 * PI
}
}
else if (Helper.Distance(tank.Position, targetTank.Position) > MAX_TARGET_RANGE)
{
//Look for new targetTank and change to it. It might decide to keep same target.
targetTank = SearchForNewTargetTank(tank, nearbyTanks);
}//If current Target distance < MAX_TARGET_RANGE, then target doesn't change at all
//Update CannonTarget position of "tank"
if (targetTank != null)
{
tank.CannonTarget = targetTank.Position;
tank.UpdateCannonDirection();
//Try to shoot target if it is in the shooting range
if (Helper.Distance(tank.Position, targetTank.Position) <= MAX_SHOOTING_RANGE)
{
double random = Helper.random.NextDouble();
if (random >= 1 - SHOOTING_PROBABILITY)
{
tank.Shoot();
}
}
}
else //if tank has no target, cannon should aim in the direction of the tank!
{
tank.CannonTarget = tank.Position;
}
if (targetTank != null)
{
//UpdateTargetSpeedvektor();
angleFromTarget += Math.PI / 1000.0;
angleFromTarget = Helper.NormalizeRad(angleFromTarget);
Coordinate targetPosition;
targetPosition.x = targetTank.Position.x + MAX_SHOOTING_RANGE * 0.9 * Math.Cos(angleFromTarget);
targetPosition.y = targetTank.Position.y + MAX_SHOOTING_RANGE * 0.9 * Math.Sin(angleFromTarget);
double angleToTargetPosition;
Coordinate delta;
delta.x = targetPosition.x - tank.Position.x;
delta.y = targetPosition.y - tank.Position.y;
if (delta.x == 0 && delta.y == 0) //Just in case targetposition = current tank position
{
angleToTargetPosition = tank.DirectionBody;
}
else
{
angleToTargetPosition = Math.Atan2(delta.y, delta.x);
}
targetSpeedVektor.x = tank.GetTopSpeed() * Math.Cos(angleToTargetPosition);
targetSpeedVektor.y = tank.GetTopSpeed() * Math.Sin(angleToTargetPosition);
}
else
{
targetSpeedVektor.x = 0;
targetSpeedVektor.y = 0;
}
if (targetSpeedVektor.x == 0 && targetSpeedVektor.y == 0)
{
tank.TurnLeft(0);
tank.TurnRight(0);
tank.Reverse(0);
tank.Forward(0);
}
else
{
//DriveTank();
double turnDirection = tank.DirectionBody - Math.Atan2(targetSpeedVektor.y, targetSpeedVektor.x);
//Bring turn direction back to between -Pi and +Pi
if (turnDirection < -Math.PI)
{
turnDirection += 2 * Math.PI;
}
else if ((turnDirection > Math.PI))
{
turnDirection -= 2 * Math.PI;
}
if (turnDirection == 0)
{//tank is already on the right trajectory
/*Keep moving Forward*/
tank.TurnLeft(0);
tank.TurnRight(0);
tank.Reverse(0);
tank.Forward(ACCELERATION_RATE);
}
else if (turnDirection == Math.PI || turnDirection == -Math.PI)
{//targetvektor is 180degres behind tank
tank.TurnLeft(0);
tank.TurnRight(0);
tank.Reverse(ACCELERATION_RATE);
tank.Forward(0);
}
else if (turnDirection > 0)
{//if positive, turn left
tank.TurnLeft(1);
tank.TurnRight(0);
tank.Reverse(0);
tank.Forward(ACCELERATION_RATE);
}
else if (turnDirection < 0)
{//if negative, turn right
tank.TurnLeft(0);
tank.TurnRight(1);
tank.Reverse(0);
tank.Forward(ACCELERATION_RATE);
}
}
}
/// <summary> /// Update the game's physics according to sudden death logics. /// </summary> /// <param name="Tanks">The tanks in the game, alive of dead.</param> /// <param name="Projectiles">The projectiles on the board.</param> /// <param name="Fences">The fences on the board.</param> /// <param name="gameTime">The current game time.</param> /// <returns>Whether or not to keep updating.</returns> public abstract bool Update( TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, HashSet<Pickup> Pickups, GameTime gameTime );
/// <summary> /// Draws the game according to sudden death logics. /// </summary> /// <param name="spriteBatch">The SpriteBatch to draw with. Must be begun.</param> /// <returns>Whether or not to keep drawing.</returns> public abstract bool Draw( SpriteBatch spriteBatch, TankObject[] Tanks, HashSet<ProjectileObject> Projectiles, HashSet<FenceObject> Fences, GameTime gameTime );
public void HandleInput(InputStruct input)
{
switch (input.inputEvent)
{
case PRESS_S:
parent.World.player.Reverse(1);
break;
case RELEASE_S:
parent.World.player.Reverse(0);
break;
case PRESS_W:
parent.World.player.Forward(1);
break;
case RELEASE_W:
parent.World.player.Forward(0);
break;
case PRESS_A:
parent.World.player.TurnLeft(1);
break;
case RELEASE_A:
parent.World.player.TurnLeft(0);
break;
case PRESS_D:
parent.World.player.TurnRight(1);
break;
case RELEASE_D:
parent.World.player.TurnRight(0);
break;
case MOUSE_MOTION:
parent.World.player.TurretTarget(input.x, input.y);
break;
case PRESS_LEFT_BUTTON:
parent.World.player.Shoot();
break;
case PRESS_P:
Coordinate spawnPosition;
spawnPosition.x = input.x;
spawnPosition.y = input.y;
spawnPosition = camera.ConvertScreenToMapCoordinate(spawnPosition);
TankObject newTank;
double angle;
for (int i = 0; i < 30; i++)
{
angle = Helper.random.NextDouble();
spawnPosition.x += 200 * Math.Cos(2 * Math.PI * angle);
spawnPosition.y += 200 * Math.Sin(2 * Math.PI * angle);
newTank = new TankObject(spawnPosition, TankObject.TankColor.GREEN);
this.AddNewObject(newTank);
}
break;
}
}
public SceneStateEvent(Type eventType, TankObject target, TankObject sniper)
{
this.eventType = eventType;
this.target = target;
this.sniper = sniper;
}
public override void Update(TankObject tank, ref WorldItems world)
{
/*empty*/
}
//Accessors
//Methods
abstract public void Update(TankObject tank, ref WorldItems world);
//Constructors
public HideTankHPCommand(TankObject owner, Timer timer)
{
tank = owner;
this.timer = timer;
}
//Constructor
public TankAiComponent()
{
targetTank = null;
}
//Constructors
public TankPhysicsComponent(TankObject owner)
{
InitializeHitBoxes(owner);
}
