void OnTouchesEnded(List <CCTouch> touches, CCEvent touchEvent)
{
monkey.StopAllActions();
var location = touches [0].LocationOnScreen;
location = WorldToScreenspace(location);
if (location.Y >= allowableMovementRect.Size.Height)
{
location.Y = allowableMovementRect.Size.Height;
}
float ds = CCPoint.Distance(monkey.Position, location);
var dt = ds / monkeySpeed;
var moveMonkey = new CCMoveTo(dt, location);
//BUG: calling walkRepeat separately as it doesn't run when called in RunActions or CCSpawn
monkey.RunAction(walkRepeat);
monkey.RunActions(moveMonkey, walkAnimStop);
// move the clouds relative to the monkey's movement
MoveClouds(location.Y - monkey.Position.Y);
}
internal void PrepareForPlanningPhase(PlayLayer pl)
{
// first check the aggro
// i.e. if an enemy (i.e. a player aircraft) is close enough break formation
// also if one of the aircrafts is damaged break formation too
if (InFormation)
{
foreach (var aircraft in pl.PlayerAircrafts)
{
if (CCPoint.Distance(aircraft.Position, Position) < AggroRange)
{
//Console.WriteLine("TRIGGERED - DISTANCE");
InFormation = false;
break;
}
}
foreach (var aircraft in AircraftsWithRelPositions.Keys)
{
if (aircraft.Health < aircraft.MaxHealth)
{
//Console.WriteLine("TRIGGERED - HP");
InFormation = false;
break;
}
}
}
foreach (var aircraft in AircraftsWithRelPositions.Keys)
{
aircraft.PrepareForPlanningPhase();
}
if (!InFormation)
{
return; // squadrons only control their units while in formation
}
//Console.WriteLine("FLYING IN FORMATION");
const float dt = Constants.TURN_DURATION;
// if you're too close to the current Waypoint roll a new one
var diff = WayPoint - Leader.Position;
float advanceDistance = Velocity * dt;
if (diff.Length < advanceDistance)
{
GenerateWayPoint();
diff = WayPoint - Leader.Position;
}
LeaderWayPoint = Leader.Position + CCPoint.Normalize(diff) * advanceDistance;
// rotate all formation positions correctly around the leader and tell everyone to go to their positions
float angle = Constants.DxDyToRadians(diff.X, diff.Y);
foreach (var entry in AircraftsWithRelPositions)
{
var formationPoint = CCPoint.RotateByAngle(entry.Value, CCPoint.Zero, angle);
var yourWaypoint = LeaderWayPoint + formationPoint;
entry.Key.TryToSetFlightPathHeadTo(yourWaypoint);
}
}
void MoveShipTo(CCPoint location)
{
float ds = CCPoint.Distance(ship.Position, location);
var dt = ds / SHIP_SPEED;
var moveShip = new CCMoveTo(dt, location);
var easeShip = new CCEaseSineInOut(moveShip);
ship.RunAction(easeShip);
}
/// <summary>
/// Advance the current position some distance on the flight path.
/// </summary>
/// <param name="distance"></param>
/// <param name="destination">position after the advance</param>
/// <param name="cCfinalDirection">direction of the segment that the position is on after the advance</param>
internal void Advance(CCPoint currentPosition, float distance, out CCPoint destination, out float CCfinalDirection)
{
int currentIndex = (int)AdvancementAsQuasiIndex;
float relativeAdvancementToNextPoint = AdvancementAsQuasiIndex % 1;
if (currentIndex == Path.Length - 1) // if you've already reached the end you're done
{
destination = EndPoint;
CCfinalDirection = DirectionAt(currentIndex);
return;
}
float absoluteAdvancementToNextPoint = relativeAdvancementToNextPoint * CCPoint.Distance(Path[currentIndex], Path[currentIndex + 1]);
float directionToNextPointInRadians = Constants.CCDegreesToMathRadians(DirectionAt(currentIndex));
float absoluteXAdvancement = absoluteAdvancementToNextPoint * (float)Math.Cos(directionToNextPointInRadians);
float absoluteYAdvancement = absoluteAdvancementToNextPoint * (float)Math.Sin(directionToNextPointInRadians);
//CCPoint currentPosition = new CCPoint(Path[currentIndex].X + absoluteXAdvancement, Path[currentIndex].Y + absoluteYAdvancement);
// try to advance from the current position to the next point on the Path
float distanceToNextPoint = CCPoint.Distance(currentPosition, Path[currentIndex + 1]);
while (distanceToNextPoint < distance)
{
currentIndex = currentIndex + 1;
currentPosition = Path[currentIndex];
distance -= distanceToNextPoint;
AdvancementAsQuasiIndex = currentIndex;
if (currentIndex == Path.Length - 1)
{
break;
}
distanceToNextPoint = CCPoint.Distance(currentPosition, Path[currentIndex + 1]);
}
// if you can't go far enough just move towards the point
if (distance > 0 && currentIndex != Path.Length - 1)
{
// update the direction
directionToNextPointInRadians = Constants.CCDegreesToMathRadians(DirectionAt(currentIndex));
// calculate how far you can go
// relative between the points
float relativeAdvanche = distance / distanceToNextPoint;
// in x direction
float newX = currentPosition.X + distance * (float)Math.Cos(directionToNextPointInRadians);
// in y direction
float newY = currentPosition.Y + distance * (float)Math.Sin(directionToNextPointInRadians);
AdvancementAsQuasiIndex = (float)currentIndex + relativeAdvanche;
destination = new CCPoint(newX, newY);
CCfinalDirection = Constants.RadiansToCCDegrees(directionToNextPointInRadians);
}
else
{
destination = Path[currentIndex];
CCfinalDirection = DirectionAt(currentIndex);
}
//
}
public static float GetZoomOneTouchMoving(CCTouch movingTouch, CCPoint stableTouchLoc)
{
Console.WriteLine("CALLED");
// get the middlepoint and check if they both move towards it
//CCPoint midPoint = (movingTouch.Location + stableTouch.Location) / 2;
{
Console.WriteLine("output2: " + CCPoint.Distance(movingTouch.PreviousLocation, stableTouchLoc) / CCPoint.Distance(movingTouch.Location, stableTouchLoc));
return(CCPoint.Distance(movingTouch.PreviousLocation, stableTouchLoc) / CCPoint.Distance(movingTouch.Location, stableTouchLoc));
}
//else
// return float.NaN;
}
private void moveRemoteMonkey(float x)
{
Console.WriteLine("moveRemoteMonkey");
var location = new CCPoint();
location.X = x;
location.Y = remoteMonkey.PositionY;
float ds = CCPoint.Distance(remoteMonkey.Position, location);
float dt = ds / MONKEY_SPEED;
var moveMonkey = new CCMoveTo(dt, location);
remoteMonkey.RunAction(moveMonkey);
}
private EnemyBullet AddEnemyBullet(CCSprite sender)
{
EnemyBullet bullet = new EnemyBullet();
bullet.Position = new CCPoint(sender.Position.X, sender.Position.Y - sender.ContentSize.Height / 2);
AddChild(bullet, ENEMY_BULLET_INDEX);
CCPoint target = CCPoint.IntersectPoint(bullet.Position, player.Position, CCPoint.Zero, new CCPoint(VisibleBoundsWorldspace.MaxX, 0));
float distance = CCPoint.Distance(bullet.Position, target);
var moveBullet = new CCMoveTo(distance / ENEMY_BULLET_SPEED, target);
bullet.RunActions(moveBullet, moveOutOfView);
return(bullet);
}
void OnTouchesEnded(List <CCTouch> touches, CCEvent touchEvent)
{
base.TouchesEnded(touches, touchEvent);
var location = touches [0].Location;
float ds = CCPoint.Distance(monkey.Position, location);
float dt = ds / MONKEY_SPEED;
var moveMonkey = new CCMoveTo(dt, location);
monkey.RunAction(moveMonkey);
CCSimpleAudioEngine.SharedEngine.PlayEffect("Sounds/tap.mp3");
}
public void OnTouchesEnded(List <CCTouch> touches, CCEvent touchEvent)
{
monkey.StopAllActions();
var location = touches[0].LocationOnScreen;
location = WorldToScreenspace(location);
float ds = CCPoint.Distance(monkey.Position, location);
var dt = ds / Money_Speed;
var MoveMonkey = new CCMoveTo(dt, location);
monkey.RunAction(walkRepeat);
monkey.RunActions(MoveMonkey, walkAnimStop);
CCSimpleAudioEngine.SharedEngine.PlayEffect("Sounds/tap");
}
internal override void ActInPlanningPhase()
{
// first check whether you're hurt and go scared if you are
if (!Scared && Aircraft.Health < Aircraft.MaxHealth)
{
Scared = true;
}
// go through all aircrafts and find the closest enemy
// (for now an enemy is everyone who isn't on your team)
var myTeam = Aircraft.Team;
IEnumerable <Aircraft> aircrafts;
if (myTeam == Team.PlayerTeam)
{
aircrafts = Aircraft.ActiveAircraftsInLevel();
}
else
{
aircrafts = Aircraft.PlayerAircraftsInLevel();
}
Aircraft closestAircraft = null;
foreach (var aircraft in aircrafts)
{
if (aircraft.MyState != Aircraft.State.SHOT_DOWN && aircraft != Aircraft && aircraft.Team.IsEnemy(myTeam) && aircraft.IsActive())
{
// check the distance (closer is better)
if (closestAircraft == null ||
CCPoint.Distance(Aircraft.Position, aircraft.Position) < CCPoint.Distance(Aircraft.Position, closestAircraft.Position))
{
closestAircraft = aircraft;
}
}
}
// if it is too close run away
if (closestAircraft != null && (Scared || CCPoint.Distance(Aircraft.Position, closestAircraft.Position) < SCARE_DISTANCE))
{
//Console.WriteLine("FLEEING");
Aircraft.TryToSetFlightPathHeadTo(Aircraft.Position + (Aircraft.Position - closestAircraft.Position) * 16);
}
// else move randomly
else
{
//Console.WriteLine("Moving randomly");
Aircraft.TryToSetFlightPathHeadTo(Constants.RandomPointBoxnear(Aircraft.Position, 1000f));
}
}
/// <summary>
/// If the two touches have a common center that they move toward or away from, this function returns the relative change of distance between them.
/// Else it returns <c>float.NaN</c>.
/// </summary>
/// <param name="touch1"></param>
/// <param name="touch2"></param>
/// <returns>how the distance between the two touches changed</returns>
public static float GetZoom(CCTouch touch1, CCTouch touch2)
{
// get the middlepoint and check if they both move towards it
/*
* CCPoint midPoint = new CCPoint((touch1.Location.X + touch2.Location.X) / 2, (touch1.Location.Y + touch2.Location.Y) / 2);
* if ((CCPoint.Distance(touch1.Location, midPoint) < CCPoint.Distance(touch1.PreviousLocation, midPoint) &&
* CCPoint.Distance(touch2.Location, midPoint) < CCPoint.Distance(touch2.PreviousLocation, midPoint)) ||
* (CCPoint.Distance(touch1.Location, midPoint) > CCPoint.Distance(touch1.PreviousLocation, midPoint) &&
* CCPoint.Distance(touch2.Location, midPoint) > CCPoint.Distance(touch2.PreviousLocation, midPoint)))
*/
{
Console.WriteLine("output: " + CCPoint.Distance(touch1.PreviousLocation, touch2.PreviousLocation) / CCPoint.Distance(touch1.Location, touch2.Location));
return(CCPoint.Distance(touch1.PreviousLocation, touch2.PreviousLocation) / CCPoint.Distance(touch1.Location, touch2.Location));
}
//else
// return float.NaN;
}
public void MovePhase(float frameTimeInSeconds)
{
if (this.State == ActionState.walking)
{
double diffX = nextMove.X - Position.X;
double diffY = nextMove.Y - Position.Y;
double length = Math.Sqrt(diffX * diffX + diffY * diffY); //Pythagorean law
float dx = (float)(diffX / length * moveSpeed * frameTimeInSeconds); //higher speed is faster
float dy = (float)(diffY / length * moveSpeed * frameTimeInSeconds);
this.Position += new CCPoint(dx, dy);
UpdateNextMove();
if (CCPoint.Distance(this.Position, nextMove) < 5)
{
this.gridPos = GodClass.gridManager.GetTileFromScreenTouch(nextMove);
UpdateNextMove();
}
}
}
public override void TouchesEnded(List <CCTouch> touches)
{
base.TouchesEnded(touches);
var location = new CCPoint();
location.X = touches [0].Location.X;
location.Y = localMonkey.PositionY;
float ds = CCPoint.Distance(localMonkey.Position, location);
float dt = ds / MONKEY_SPEED;
var moveMonkey = new CCMoveTo(dt, location);
localMonkey.RunAction(moveMonkey);
byte[] message = buildMonkeyMessage(location.X);
sendWarpUpdate(message);
}
public void ReturningToHiveBehavior()
{
CCPoint parkingSpot = this.AlienHive.GetPositionOfSlot(this.PositionInHive);
float dist = CCPoint.Distance(this.Position, parkingSpot);
if (dist > GameParameters.ALIEN_INVADER_VELOCITY_VAL)
{
this.AimAtPoint2(parkingSpot, GameParameters.ALIEN_INVADER_VELOCITY_VAL);
UpdatePosition();
}
else
{
GameParameters.RENDERING_SURFACE_MUTEX.WaitOne();
this.Position = parkingSpot;
GameParameters.RENDERING_SURFACE_MUTEX.ReleaseMutex();
this.SetBehaviorDormantInHive();
this.IsAttacking = false;
this.IsLaunchingRockets = false;
}
}
/** override functions */
public virtual bool TouchBegan(CCTouch pTouch, CCEvent touchEvent)
{
if (!Visible)
{
return(false);
}
var frame = ViewRect;
//dispatcher does not know about clipping. reject _touches outside visible bounds.
if (_touches.Count > 2 ||
IsTouchMoved ||
!frame.ContainsPoint(_container.Layer.ScreenToWorldspace(pTouch.LocationOnScreen)))
{
return(false);
}
if (!_touches.Contains(pTouch))
{
_touches.Add(pTouch);
}
if (_touches.Count == 1)
{
// scrolling
_touchPoint = Layer.ScreenToWorldspace(pTouch.LocationOnScreen);
IsTouchMoved = false;
Dragging = true; //Dragging started
_dragginStartTime = DateTime.Now;
_scrollDistance = CCPoint.Zero;
_touchLength = 0.0f;
}
else if (_touches.Count == 2)
{
_touchPoint = CCPoint.Midpoint(Layer.ScreenToWorldspace(_touches[0].LocationOnScreen), Layer.ScreenToWorldspace(_touches[1].LocationOnScreen));
_touchLength = CCPoint.Distance(_container.Layer.ScreenToWorldspace(_touches[0].LocationOnScreen), _container.Layer.ScreenToWorldspace(_touches[1].LocationOnScreen));
Dragging = false;
}
return(true);
}
void OnTouchesMoved(List <CCTouch> touches, CCEvent touchEvent)
{
CCAffineTransform worldTransform = AffineWorldTransform;
CCTouch touch = touches[0];
CCPoint start = touch.Location;
CCPoint end = touch.PreviousLocation;
// begin drawing to the render texture
target.Begin();
// for extra points, we'll draw this smoothly from the last position and vary the sprite's
// scale/rotation/offset
float distance = CCPoint.Distance(start, end);
if (distance > 1)
{
var d = (int)distance;
for (int i = 0; i < d; i++)
{
float difx = end.X - start.X;
float dify = end.Y - start.Y;
float delta = i / distance;
brush.Position = new CCPoint(start.X + (difx * delta), start.Y + (dify * delta));
brush.Rotation = CCRandom.Next() % 360;
float r = (CCRandom.Next() % 50 / 50f) + 0.25f;
brush.Scale = r;
// Comment out the following line to show just the initial red color set
brush.Color = new CCColor3B((byte)(CCRandom.Next() % 127 + 128), 255, 255);
// Call visit to draw the brush, don't call draw..
brush.Visit(ref worldTransform);
}
}
// finish drawing and return context back to the screen
target.End();
}
void CheckEnemyCollisions()
{
if (enemies.ChildrenCount > 0 && shots.ChildrenCount > 0)
{
foreach (var enemy in enemies.Children)
{
foreach (var shot in shots.Children)
{
var d = CCPoint.Distance(shot.Position, enemy.Position);
if (d <= ENEMY_RADIUS + SHOT_RADIUS)
{
var pt = enemy.Position;
enemy.RemoveFromParent(true);
CCSimpleAudioEngine.SharedEngine.PlayEffect("sounds/explosion");
var explosion = new CCParticleSystemQuad("implode.plist");
explosion.Position = pt;
AddChild(explosion);
}
}
}
}
}
internal override void ActInPlanningPhase()
{
// first go through all aircrafts and find the closest enemy
// (for now an enemy is everyone who isn't on your team)
var myTeam = Aircraft.Team;
IEnumerable <Aircraft> aircrafts;
if (myTeam == Team.PlayerTeam)
{
aircrafts = Aircraft.ActiveAircraftsInLevel();
}
else
{
aircrafts = Aircraft.PlayerAircraftsInLevel();
}
Aircraft closestAircraft = null;
foreach (var aircraft in aircrafts)
{
if (aircraft.MyState != Aircraft.State.SHOT_DOWN && aircraft != Aircraft && aircraft.Team.IsEnemy(myTeam) && aircraft.IsActive())
{
// check the distance (closer is better)
if (closestAircraft == null ||
CCPoint.Distance(Aircraft.Position, aircraft.Position) < CCPoint.Distance(Aircraft.Position, closestAircraft.Position))
{
closestAircraft = aircraft;
}
}
}
// set path towards where he might be at the end of the next turn
if (closestAircraft != null)
{
//Console.WriteLine("Attacking!");
Aircraft.TryToSetFlightPathHeadTo(closestAircraft.Position + (closestAircraft.VelocityVector * Constants.TURN_DURATION));
}
}
void OnTouchesMoved(List <CCTouch> touches, CCEvent touchEvent)
{
if (touches.Count <= 0)
{
return;
}
float x = touches[0].LocationOnScreen.X;
float y = touches[0].LocationOnScreen.Y;
if (m_IsCardDragging)
{
CCSprite Spr = TexturePool.GetSprite(m_Game.m_CurrentCard.m_Hash);
Spr.Position = touches[0].LocationOnScreen;
foreach (CCTouch i in touches)
{
CCPoint p = i.LocationOnScreen;
p = m_Overlay.ScreenToWorldspace(p);
m_Overlay.m_CardButton.Position = p;
}
}
else
{
if (m_Touches == 1) // Pan
{
foreach (CCTouch i in touches)
{
var s = m_BoardLayer.Camera.CenterInWorldspace;
s.X += i.PreviousLocationOnScreen.X - i.LocationOnScreen.X;
s.Y += i.LocationOnScreen.Y - i.PreviousLocationOnScreen.Y;
m_BoardLayer.Camera.CenterInWorldspace = s;
var target = m_BoardLayer.Camera.TargetInWorldspace;
target.X = s.X;
target.Y = s.Y;
m_BoardLayer.Camera.TargetInWorldspace = target;
}
}
else if (m_Touches == 2) // Zoom
{
if (touches.Count < 2)
{
return;
}
for (int i = 0; i < touches.Count; i += 2)
{
CCPoint fir = touches[i].LocationOnScreen;
CCPoint sec = touches[i + 1].LocationOnScreen;
CCPoint third = touches[i].PreviousLocationOnScreen;
CCPoint four = touches[i + 1].PreviousLocationOnScreen;
float one = CCPoint.Distance(fir, sec);
float two = CCPoint.Distance(third, four);
if (one < two)
{
m_BoardLayer.UpdateScale(-0.05f);
}
else
{
m_BoardLayer.UpdateScale(0.05f);
}
}
}
}
}
/// <summary>
/// takes care of dragging and zoom
/// </summary>
/// <param name="touch"></param>
/// <param name="touchEvent"></param>
public virtual void TouchMoved(CCTouch touch, CCEvent touchEvent)
{
if (!Visible)
{
return;
}
if (_touches.Contains(touch))
{
if (_touches.Count == 1 && Dragging)
{ // scrolling
CCPoint moveDistance, newPoint; //, _maxInset, _minInset;
var frame = ViewRect;
newPoint = Layer.ScreenToWorldspace(_touches[0].LocationOnScreen);
moveDistance = newPoint - _touchPoint;
Debug.WriteLine("move distance: " + moveDistance);
float dis;
if (Direction == CcScrollViewDirection.Vertical)
{
dis = moveDistance.Y;
}
else if (Direction == CcScrollViewDirection.Horizontal)
{
dis = moveDistance.X;
}
else
{
dis = (float)Math.Sqrt(moveDistance.X * moveDistance.X + moveDistance.Y * moveDistance.Y);
}
if (!IsTouchMoved && Math.Abs(ConvertDistanceFromPointToInch(dis)) < MoveInch)
{
//CCLOG("Invalid movement, distance = [%f, %f], disInch = %f", moveDistance.x, moveDistance.y);
return;
}
if (!IsTouchMoved)
{
moveDistance = CCPoint.Zero;
}
_touchPoint = newPoint;
IsTouchMoved = true;
if (frame.ContainsPoint(_touchPoint))
{
switch (Direction)
{
case CcScrollViewDirection.Vertical:
moveDistance = new CCPoint(0.0f, moveDistance.Y);
break;
case CcScrollViewDirection.Horizontal:
moveDistance = new CCPoint(moveDistance.X, 0.0f);
break;
}
float newX = _container.Position.X + moveDistance.X;
float newY = _container.Position.Y + moveDistance.Y;
//Debug.WriteLine("Scroll Distance: " + _scrollDistance);
_scrollDistance = moveDistance;
Debug.WriteLine("new offset " + new CCPoint(newX, newY));
SetContentOffset(new CCPoint(newX, newY));
}
}
else if (_touches.Count == 2 && !Dragging)
{
//2 fingers no dragging? zoom
float len = CCPoint.Distance(Layer.ScreenToWorldspace(_touches[0].LocationOnScreen),
Layer.ScreenToWorldspace(_touches[1].LocationOnScreen));
var differenceTouchLength = (len / _touchLength);
ZoomScale = (differenceTouchLength < 1)
? ZoomScale * (1 - (1 - differenceTouchLength) * 0.5f)
: ZoomScale * (1 + (differenceTouchLength - 1) * 0.5f);
_touchLength = len;
}
}
}
protected void TouchesEnded(List <CCTouch> touches, CCEvent touchEvent)
{
if (_state == gamestates.kGameIntro && !isLoading)
{
_intro.Visible = false;
_pauseBtn.Visible = true;
_state = gamestates.kGamePlay;
resetGame();
return;
}
else if (_state == gamestates.kGamePaused)
{
//_pauseBtn.DisplayFrame = CCSpriteFrameCache.SharedSpriteFrameCache["btn_pause_off.png"];
_paused.Visible = false;
_state = gamestates.kGamePlay;
_running = true;
return;
}
else if (_state == gamestates.kGameOver)
{
_gameOver.Visible = false;
_pauseBtn.Visible = true;
_state = gamestates.kGamePlay;
resetGame();
return;
}
if (!_running)
{
return;
}
CCTouch touch = touches.FirstOrDefault();
if (touch != null)
{
CCPoint tap = touch.LocationOnScreen;;; //??¿¿?¿?
tap.Y = Window.WindowSizeInPixels.Height - tap.Y;
if (_pauseBtn.BoundingBox.ContainsPoint(tap))
{
_paused.Visible = true;
_state = gamestates.kGamePaused;
// _pauseBtn.DisplayFrame = CCApplication.SharedApplication.SpriteFrameCache["btn_pause_on.png"]; // CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName ("btn_pause_on.png"));
_running = false;
return;
}
//track if tapping on ship
_drawing = false;
_rocket.select(false);
//if we are showing a temp line
if (_lineContainer._lineType == lineTypes.LINE_TEMP)
{
//set up dashed line
_lineContainer._pivot = tap;
_lineContainer._lineLength = CCPoint.Distance(_rocket.Position, tap);
//set up rocket
_rocket._pivot = tap;
float circle_length = _lineContainer._lineLength * 2 * CCMathHelper.Pi;
int iterations = (int)Math.Floor(circle_length / _rocket._speed);
_rocket._angularSpeed = 2 * CCMathHelper.Pi / iterations;
CCPoint clockwise = CCPoint.PerpendicularCW(_rocket.Position - _rocket._pivot);
float dot = CCPoint.Dot(clockwise, _rocket._vector);
if (dot > 0)
{
_rocket._angularSpeed = (_rocket._angularSpeed * -1);
_rocket._rotationOrientation = Rocket.ROTATE_CLOCKWISE;
_rocket.setTargetRotation(MathHelper.ToDegrees((float)Math.Atan2(clockwise.Y, clockwise.X)));
}
else
{
_rocket._rotationOrientation = Rocket.ROTATE_COUNTER;
_rocket._targetRotation = MathHelper.ToDegrees((float)Math.Atan2(-1 * clockwise.Y, -1 * clockwise.X));
}
_lineContainer._lineType = lineTypes.LINE_DASHED;
}
}
}
bool isPeaceCloseToHome(Peace peace)
{
const int MIN_DISTANCE = 20;
return(CCPoint.Distance(peace.Sprite.Position, peace.AssembledPos) < MIN_DISTANCE);
}
new private protected void OnTouchesEnded(List <CCTouch> touches, CCEvent touchEvent)
{
base.OnTouchesEnded(touches, touchEvent);
switch (touches.Count)
{
case 1:
{
var touch = touches[0];
if (DragAndDropObject != null)
{
touchEvent.StopPropogation();
switch (HangarLayer.State)
{
case HangarLayer.HangarState.HANGAR:
var selectedAircraft = DragAndDropObject as Aircraft;
DragAndDropObject = null;
if (selectedAircraft != null)
{
// if an aircraft is dragged upon the takeoff node add it to the collection
if (!(TakeoffNode.BoundingBoxTransformedToParent.ContainsPoint(touch.Location) && TakeoffCollectionNode.AddToCollection(selectedAircraft)))
{
// if not, then place it back into the hangar
HangarLayer.AddAircraftChild(selectedAircraft);
selectedAircraft.Scale = Constants.STANDARD_SCALE;
HangarLayer.PlaceAircraft(selectedAircraft, HangarLayer.GUICoordinatesToHangar(selectedAircraft.Position));
}
if (TakeoffCollectionNode.Collection.Any())
{
GOButton.AddAction(HangarLayer.AddGOButton);
TakeoffCollectionLabel.Visible = false;
}
else if (!PopUp.TriggeredPlayLayer)
{
TakeoffCollectionLabel.Visible = true;
}
}
break;
case HangarLayer.HangarState.MODIFY_AIRCRAFT:
{
bool mounted = false;
HangarLayer.UpdateClosestMount();
// the object is a part
var part = (Part)DragAndDropObject;
DragAndDropObject = null;
// if it is a body and the aircraft currently has none (which means no parts at all)
if (HangarLayer.ModifiedAircraft.Body == null && part.Types.Contains(Part.Type.BODY) && CCPoint.IsNear(HangarLayer.GUICoordinatesToHangar(part.PositionWorldspace), HangarLayer.ModifiedAircraft.PositionWorldspace, MOUNT_DISTANCE))
{
// set it as the aircraft body
HangarLayer.ModifiedAircraft.InWorkshopConfiguration = false;
part.Scale = 1;
HangarLayer.ModifiedAircraft.Body = part;
HangarLayer.ModifiedAircraft.InWorkshopConfiguration = true;
HangarLayer.CalcBoundaries(); // the aircraft has changed size, so update the boundaries
HangarLayer.DrawInModifyAircraftState();
mounted = true;
}
// check if the part is currently at a mount point where it can be mounted
else if (!mounted)
{
var possibleMounts = new List <PartMount>();
foreach (var modPart in HangarLayer.ModifiedAircraft.TotalParts)
{
foreach (var mountPoint in modPart.PartMounts)
{
if (mountPoint.Available && mountPoint.CanMount(part))
{
if (CCPoint.IsNear(HangarLayer.GUICoordinatesToHangar(part.PositionWorldspace), mountPoint.PositionModifyAircraft, MOUNT_DISTANCE))
{
possibleMounts.Add(mountPoint);
}
}
}
}
// mount at the closest possible mount point
float minDistance = float.PositiveInfinity;
PartMount closestMount = null;
foreach (var mountPoint in possibleMounts)
{
float distance = CCPoint.Distance(HangarLayer.GUICoordinatesToHangar(part.PositionWorldspace), mountPoint.PositionModifyAircraft);
if (distance < minDistance)
{
minDistance = distance;
closestMount = mountPoint;
}
}
if (closestMount != null)
{
// better mount in non-workshop configuration
HangarLayer.ModifiedAircraft.InWorkshopConfiguration = false;
part.Scale = 1;
closestMount.MyPart.MountPart(closestMount, part);
HangarLayer.ModifiedAircraft.InWorkshopConfiguration = true;
HangarLayer.CalcBoundaries(); // the aircraft has probably changed size, so update the boundaries
HangarLayer.DrawInModifyAircraftState();
mounted = true;
}
}
// if the part has not been mounted the part is just dropped and added to the collection
if (!mounted)
{
// first disassemble it though
// and flip it if it is flipped
var totalParts = part.TotalParts;
part.Disassemble();
foreach (var singlePart in totalParts)
{
if (singlePart.Flipped)
{
singlePart.Flip();
}
HangarLayer.AddPart(singlePart);
}
}
}
break;
}
DragAndDropObject = null;
}
}
break;
default:
break;
}
}
public override void Update(float dt)
{
base.Update(dt);
switch (State)
{
case GameState.PLANNING:
break;
case GameState.EXECUTING_ORDERS:
{
TimeLeftExecutingOrders -= dt;
if (Aircraft.CloudFrameCountdown != 0)
{
Aircraft.CloudFrameCountdown--;
}
else
{
Aircraft.CloudFrameCountdown = Aircraft.CLOUD_FRAME_COUNTDOWN;
}
if (powerUpCheckCountDown != 0)
{
powerUpCheckCountDown--;
}
else
{
powerUpCheckCountDown = PU_CHECK_COUNTDOWN;
// check if any powerup is close enough to be picked up
foreach (var aircraft in PlayerAircrafts)
{
if (aircraft.MyState == Aircraft.State.SHOT_DOWN)
{
continue;
}
CCPoint aPos = aircraft.Position;
foreach (var powerUp in PowerUps)
{
// only pick up power-ups that are close in x-y but also in z direction
if (powerUp.VertexZ > -10f && CCPoint.Distance(powerUp.Position, aPos) < PowerUp.PICKUP_DISTANCE)
{
// pick up the powerup
if (!PopUp.TriggeredPowerUp)
{
PopUp.ShowPopUp(GUILayer, PopUp.Enum.TRIGGERED_POWERUP);
}
powerUp.StartPickupAnimation();
aircraft.ChangePowerUpCount(powerUp.Power, 1);
PowerUps.Remove(powerUp);
break;
}
}
}
}
// DEBUG: Console.WriteLine("EXECUTING ORDERS; dt: " + dt);
// go through all aircrafts and let them execute their orders
List <Aircraft> aircraftToBeRemoved = new List <Aircraft>();
// first the enemies (organized into squadrons)
foreach (var aircraft in ActiveAircrafts)
{
aircraft.ExecuteOrders(dt);
if (aircraft.ToBeRemoved)
{
aircraftToBeRemoved.Add(aircraft);
}
}
// then the player aircrafts
foreach (var aircraft in PlayerAircrafts)
{
aircraft.ExecuteOrders(dt);
if (aircraft.ToBeRemoved)
{
aircraftToBeRemoved.Add(aircraft);
}
}
// remove aircrafts that have to be removed
foreach (var aircraft in aircraftToBeRemoved)
{
if (!aircraft.ControlledByPlayer)
{
// add a powerup
if ((new Random()).Next(3) < 2)
{
var powerUp = aircraft.GeneratePowerUp();
if (powerUp != null)
{
powerUp.Position = aircraft.Position;
AddPowerUp(powerUp);
}
}
}
// add an explosion
var cloudNode = new CloudTailNode();
cloudNode.AddCloud(new CircleCloud(aircraft.Position, 0, CCColor4B.White, true, aircraft.ContentSize.Width * 16, 6f));
ExplosionNodes.Add(cloudNode);
// if the aircraft is not completely made up of scrap parts add it to the salvageable wrecks
foreach (var part in aircraft.TotalParts)
{
if (!(part is BodyScrap) && !(part is DoubleWingScrap) && !(part is RotorScrap) && !(part is RudderScrap) && !(part is WeaponScrap))
{
DownedAircrafts.Add(aircraft);
break;
}
}
RemoveAircraft(aircraft);
}
// go through all projectiles and let them advance
// check whether a projectile needs to be removed
List <Projectile> projectilesToBeRemoved = new List <Projectile>();
foreach (var projectile in Projectiles)
{
projectile.Advance(dt);
if (projectile.CanBeRemoved())
{
projectilesToBeRemoved.Add(projectile);
}
}
// go through all clouds that are directly bounds to you
List <CloudTailNode> cloudsToBeRemoved = new List <CloudTailNode>();
foreach (var cloudNode in ExplosionNodes)
{
cloudNode.Advance(dt);
if (!cloudNode.HasClouds())
{
cloudsToBeRemoved.Add(cloudNode);
}
}
foreach (var cloudNode in cloudsToBeRemoved)
{
ExplosionNodes.Remove(cloudNode);
}
UpdateDrawNodes();
if (TimeLeftExecutingOrders <= 0)
{
StartPlanningPhase();
}
}
break;
}
}
internal void CalculatePath(CCPoint startPosition, float startSlopeDx, float startSlopeDy, CCPoint endPosition, float endSlopeDx = float.NaN, float endSlopeDy = float.NaN)
{
//List<CCPoint> pathPoints = new List<CCPoint>();
// fixes for numerical problems
if (startSlopeDx < 0.0001 && 0 < startSlopeDx)
{
startSlopeDx = 0.001f;
}
if (startSlopeDx > -0.0001 && 0 > startSlopeDx)
{
startSlopeDx = -0.001f;
}
if (startSlopeDy < 0.0001 && 0 < startSlopeDy)
{
startSlopeDy = 0.001f;
}
if (startSlopeDy > -0.0001 && 0 > startSlopeDy)
{
startSlopeDy = -0.001f;
}
if (startSlopeDx == 0)
{
startSlopeDx = 0.001f;
}
if (startSlopeDy == 0)
{
startSlopeDy = 0.001f;
}
/*
* // ALTERNATIVE METHOD:
* // create a path that is a circular arc
* // for this 1. find the rotational center
* // 2. rotate the start point towards the end point around the rotational center, step by step, and add these points to the path
*
* // SPECIAL CASE: the path is a straight line
* CCPoint normalizedVectorStartEnd = CCPoint.Normalize(endPosition - startPosition);
* const float DELTA = 0.01f;
* if (CCPoint.Distance(normalizedVectorStartEnd, new CCPoint(startSlopeDx, startSlopeDy)) < DELTA)
* {
* pathPoints.Add(startPosition);
* pathPoints.Add(endPosition);
* }
* // 1.1 solve yStart = -1/(dy/dx) * xStart + n for n (line through start perpendicular to the start direction)
* // 1.2 get the midpoint between start and end
* // 1.3 solve yMid = -1/((endY-startY)/(endX-startX)) * xMid + n2 for n2 (line through midpoint perpendicular to the line from start to end)
* // 1.4 solve -1/(dy/dx) * x + n = -1/((endY-startY)/(endX-startX)) * x + n2 for x (intersection of the previous two lines, aka "the rotational center")
*
* // 1.1
* // yStart = - dx/dy * xStart + n
* // yStart + dx/dy * xStart = n
* float n = startPosition.Y + (startSlopeDx / startSlopeDy) * startPosition.X;
* // 1.2
* CCPoint midPoint = (endPosition + startPosition) / 2;
* // 1.3
* // yMid + ((endX-startX)/(endY-startY)) * xMid = n2
* float n2 = midPoint.Y + ((endPosition.X - startPosition.X) / (endPosition.Y - startPosition.Y)) * midPoint.X;
* // 1.4
* // - dx/dy * x + n = - ((endX-startX)/(endY-startY)) * x + n2
* // - dx/dy * x + ((endX-startX)/(endY-startY)) * x = n2 - n
* // x = (n2 - n) / ((dx/dy) - ((endX-startX)/(endY-startY)))
* float xRotCenter = (n2 - n) / (((endPosition.X - startPosition.X) / (endPosition.Y - startPosition.Y)) - (startSlopeDx / startSlopeDy));
* float yRotCenter = -(startSlopeDx / startSlopeDy) * xRotCenter + n;
* CCPoint rotationPoint = new CCPoint(xRotCenter, yRotCenter);
*
* // 2.1 find out whether to rotate left or right
* // for that rotate the start-direction-vector by 90° and by -90° and check which rotated vector is closer to the rotation point
* CCPoint rotatedLeft = CCPoint.RotateByAngle(new CCPoint(startSlopeDx, startSlopeDy), CCPoint.Zero, (float)Math.PI / 2) + startPosition;
* CCPoint rotatedRight = CCPoint.RotateByAngle(new CCPoint(startSlopeDx, startSlopeDy), CCPoint.Zero, -(float)Math.PI / 2) + startPosition;
* float angleSign;
* if (CCPoint.Distance(rotatedLeft, rotationPoint) < CCPoint.Distance(rotatedRight, rotationPoint))
* {
* // the rotation point is on your left, so rotate to the left
* angleSign = 1;
* }
* else
* {
* // the rotation point is on your right, so rotate to the right
* angleSign = -1;
* }
*
* // ALTERNATE PATH COMPUTATION:
* // compute the angle between the vectors starting at the rotational center and ending in a) the startpoint b) the endpoint.
* // The path points are then generated by rotating the startpoint (using that point for each rotation) and increasing the angle
* // of rotation until it reaches the computed angle between the vectors.
* // The number of steps is dependent on the length of the line, calculated from the radius * the angle.
* float radius = CCPoint.Distance(rotationPoint, startPosition);
* CCPoint normalizedVectorRotStart = CCPoint.Normalize(startPosition - rotationPoint);
* CCPoint normalizedVectorRotEnd = CCPoint.Normalize(endPosition - rotationPoint);
* float angleStart = Constants.DxDyToRadians(normalizedVectorRotStart.X, normalizedVectorRotStart.Y);
* float angleEnd = Constants.DxDyToRadians(normalizedVectorRotEnd.X, normalizedVectorRotEnd.Y);
* // make sure angles are positive
* if (angleStart < 0) angleStart = (float)(2.0 * Math.PI) + angleStart;
* if (angleEnd < 0) angleEnd = (float)(2.0 * Math.PI) + angleEnd;
* // normalize the angles
* float angleShift = (float)(2.0 * Math.PI) - angleStart;
* angleEnd = (angleEnd + angleShift) % (float)(2.0 * Math.PI);
* float angleDestination = angleSign == 1 ? angleEnd : (float)(2.0*Math.PI) - angleEnd;
* //int steps = (int)(radius * angleDestination);
* //if (steps < 200) steps = 200;
* int steps = 250;
* for (int i=0; i < steps; i++)
* {
* CCPoint pathPoint = CCPoint.RotateByAngle(startPosition, rotationPoint, angleSign * angleDestination * ((float)i / (float)steps));
* pathPoints.Add(pathPoint);
* }
* pathPoints.Add(endPosition);
* }
*/
// SPECIAL CASE: the path is a straight line
CCPoint normalizedVectorStartEnd = CCPoint.Normalize(endPosition - startPosition);
const float DELTA = 0.01f;
if (CCPoint.Distance(normalizedVectorStartEnd, new CCPoint(startSlopeDx, startSlopeDy)) < DELTA)
{
Path = new CCPoint[] { startPosition, endPosition };
}
else
{
// calculate a spline
// as the first point of the input-path add a new point
// this point realises the start slope
float firstX = startPosition.X - startSlopeDx;
float firstY = startPosition.Y - startSlopeDy;
// also create another point as the third point
// it makes sure that the plane HAS TO MOVE a little bit in a somewhat straight way first
float secondX = startPosition.X + 1 * startSlopeDx;
float secondY = startPosition.Y + 1 * startSlopeDy;
float thirdX = startPosition.X + 10 * startSlopeDx;
float thirdY = startPosition.Y + 10 * startSlopeDy;
// now calculate a special midpoint; it strongly defines the curvature of the path
// start with the midpoint between start and end
CCPoint midpoint = new CCPoint((endPosition.X + startPosition.X) / 2, (endPosition.Y + startPosition.Y) / 2);
// now we need the perpendicular line going through that point (midpoint.Y = (-1/m)*midpoint.X + np) (mp = -1/m)
float m = (endPosition.Y - startPosition.Y) / (endPosition.X - startPosition.X);
float mp = -1 / m;
float np = midpoint.Y - midpoint.X * mp;
// now get the line extending from the starting point with the startSlope (startPosition.Y = startSlope*startPosition.X + ns)
float ns = startPosition.Y - (startSlopeDy / startSlopeDx) * startPosition.X;
// next find the intersection point that these lines form (startSlope*x + ns = mp*x + np)
// x*(startSlope - mp) = np - ns;
float x = (np - ns) / ((startSlopeDy / startSlopeDx) - mp);
float y = mp * x + np;
// finally, as the special curvature point calculate the midpoint between the start-end-midpoint and intersection point
float curvaturePointX = midpoint.X + ((x - midpoint.X) / 3f);
float curvaturePointY = midpoint.Y + ((y - midpoint.Y) / 3f);
// ADDITIONAL PROCESS FOR REFINING THIS FURTHER:
// first get the curvature point as a vector relative to the midpoint
CCPoint curveVector = new CCPoint(curvaturePointX - midpoint.X, curvaturePointY - midpoint.Y);
// if it's not (0,0) (i.e. if there is any curvature at all)
float curveFactor = 0;
float halfDistance = CCPoint.Distance(startPosition, midpoint);
float magicDistanceFactor = halfDistance / 900f < 1 ? halfDistance / 900f : 1;
if (!curveVector.Equals(CCPoint.Zero))
{
// normalize it
curveVector = CCPoint.Normalize(curveVector);
// now we need to calculate the factor by which it is to be scaled
// for that we calculate the scalar product of the normalized direction vector of the starting slope and the normalized direction vector from start to end point
float scalarProduct = CCPoint.Dot(new CCPoint(startSlopeDx, startSlopeDy), CCPoint.Normalize(new CCPoint(endPosition.X - startPosition.X, endPosition.Y - startPosition.Y)));
// the larger this product, the less curvature
curveFactor = 1 - scalarProduct;
//Console.WriteLine("CurveVector: " + curveVector);
//Console.WriteLine("CurveFactor: " + curveFactor);
//Console.WriteLine("Distance: " + CCPoint.Distance(startPosition, midpoint));
// now calculate the curvature point
curvaturePointX = midpoint.X + curveVector.X * curveFactor * (1.3f - 0.8f * magicDistanceFactor) * halfDistance * (curveFactor > 1 ? -1 : 1);
curvaturePointY = midpoint.Y + curveVector.Y * curveFactor * (1.3f - 0.8f * magicDistanceFactor) * halfDistance * (curveFactor > 1 ? -1 : 1);
//Console.WriteLine("Midpoint: " + midpoint);
//Console.WriteLine("CurvaturePoint: " + curvaturePointX + "," + curvaturePointY);
}
float[] xValues, yValues;
magicDistanceFactor = halfDistance / 900f;
if (curveFactor / magicDistanceFactor > 0.55f)
{
xValues = new float[] { startPosition.X, secondX, thirdX, curvaturePointX, endPosition.X };
yValues = new float[] { startPosition.Y, secondY, thirdY, curvaturePointY, endPosition.Y };
}
else
{
xValues = new float[] { startPosition.X, secondX, thirdX, endPosition.X };
yValues = new float[] { startPosition.Y, secondY, thirdY, endPosition.Y };
}
//var xValues = new float[] { startPosition.X, curvaturePointX, endPosition.X };
//var yValues = new float[] { startPosition.Y, curvaturePointY, endPosition.Y };
CubicSpline.FitParametric(xValues, yValues, POINTS_PER_PATH / 4, out float[] pathX1, out float[] pathY1); // startSlopeDx, startSlopeDy, endSlopeDx, endSlopeDy);
// get the point before the endpoint to adjust the curvature
float xBeforeEnd = pathX1[pathX1.Length - 2];
float yBeforeEnd = pathY1[pathY1.Length - 2];
if (curveFactor / magicDistanceFactor > 0.55f)
{
xValues = new float[] { startPosition.X, secondX, thirdX, curvaturePointX, xBeforeEnd, endPosition.X };
yValues = new float[] { startPosition.Y, secondY, thirdY, curvaturePointY, yBeforeEnd, endPosition.Y };
}
else
{
xValues = new float[] { startPosition.X, secondX, thirdX, xBeforeEnd, endPosition.X };
yValues = new float[] { startPosition.Y, secondY, thirdY, yBeforeEnd, endPosition.Y };
}
CubicSpline.FitParametric(xValues, yValues, POINTS_PER_PATH, out float[] pathX, out float[] pathY);
var newPath = new CCPoint[pathX.Length];
// for the output skip the first point (start slope point)
// and replace it with the start point
newPath[0] = startPosition;
for (int i = 1; i < pathX.Length; i++)
{
newPath[i] = new CCPoint(pathX[i], pathY[i]);
}
Path = newPath;
}
// calculate and update the PathLength
var pathLength = 0f;
for (int i = 0; i < Path.Length - 1; i++)
{
pathLength += Constants.DistanceBetween(Path[i], Path[i + 1]);
}
PathLength = pathLength;
// reset the advancement to 0
AdvancementAsQuasiIndex = 0f;
}
private void HandleMoveCircle(CCTouch touch)
{
const float timeToTake = 1.5f; // in seconds
CCFiniteTimeAction coreAction = null;
CCNode nodeToAddTo = drawNodeRoot;
switch (VariableOptions [currentVariableIndex])
{
case "Position":
coreAction = new CCMoveTo(timeToTake, touch.Location);
break;
case "Scale":
var distance = CCPoint.Distance(touch.Location, drawNodeRoot.Position);
var desiredScale = distance / DefaultCircleRadius;
coreAction = new CCScaleTo(timeToTake, desiredScale);
break;
case "Rotation":
float differenceY = touch.Location.Y - drawNodeRoot.PositionY;
float differenceX = touch.Location.X - drawNodeRoot.PositionX;
float angleInDegrees = -1 * CCMathHelper.ToDegrees(
(float)System.Math.Atan2(differenceY, differenceX));
coreAction = new CCRotateTo(timeToTake, angleInDegrees);
break;
case "LineWidth":
coreAction = new LineWidthAction(timeToTake, touch.Location.X / 40.0f);
nodeToAddTo = lineNode;
break;
}
CCAction easing = null;
switch (EasingOptions [currentEasingIndex])
{
case "<None>":
// no easing, do nothing, it will be handled below
break;
case "CCEaseBack":
if (currentInOutIndex == 0)
{
easing = new CCEaseBackOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseBackIn(coreAction);
}
else
{
easing = new CCEaseBackInOut(coreAction);
}
break;
case "CCEaseBounce":
if (currentInOutIndex == 0)
{
easing = new CCEaseBounceOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseBounceIn(coreAction);
}
else
{
easing = new CCEaseBounceInOut(coreAction);
}
break;
case "CCEaseElastic":
if (currentInOutIndex == 0)
{
easing = new CCEaseElasticOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseElasticIn(coreAction);
}
else
{
easing = new CCEaseElasticInOut(coreAction);
}
break;
case "CCEaseExponential":
if (currentInOutIndex == 0)
{
easing = new CCEaseExponentialOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseExponentialIn(coreAction);
}
else
{
easing = new CCEaseExponentialInOut(coreAction);
}
break;
case "CCEaseSine":
if (currentInOutIndex == 0)
{
easing = new CCEaseSineOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseSineIn(coreAction);
}
else
{
easing = new CCEaseSineInOut(coreAction);
}
break;
}
if (easing != null)
{
nodeToAddTo.AddAction(easing);
}
else
{
nodeToAddTo.AddAction(coreAction);
}
}
/// <summary>
/// called by the Aircraft owning the part owning this WeaponAbility each frame
/// </summary>
/// <param name="dt">time since the previous frame</param>
internal void ExecuteOrders(float dt)
{
// cool down
CooldownUntilNextShot -= dt;
CooldownUntilNextTargetUpdate -= dt;
if (CooldownUntilNextShot < 0) CooldownUntilNextShot = 0;
// if you have a target check if it is still in range
if (TargetPart != null)
{
CCPoint vectorMyPartTarget = TargetPart.PositionWorldspace - MyPart.PositionWorldspace;
if (TargetPart.MyState == Part.State.DESTROYED || (TargetAircraft != null && TargetAircraft.MyState == Aircraft.State.SHOT_DOWN)
|| CooldownUntilNextTargetUpdate <= 0
|| CCPoint.Distance(MyPart.PositionWorldspace, TargetPart.PositionWorldspace) > AttentionRange
|| Constants.AbsAngleDifferenceDeg(MyPart.TotalRotation - MyPart.RotationFromNull, Constants.DxDyToCCDegrees(vectorMyPartTarget.X, vectorMyPartTarget.Y)) > AttentionAngle)
TargetPart = null;
}
if (TargetPart == null && CooldownUntilNextTargetUpdate <= 0) // if you currently do not aim at anything search for a target
{
CooldownUntilNextTargetUpdate = UpdateTargetDelay;
// collect aircrafts that are near enough to have parts which could be targets
// go through the parts of all of these planes and collect those that are in the attention angle
PartsInRange(out List<Part> partsInRange, out List<float> anglesFromTo, out List<float> distances);
// try to choose a part that is in reach
// choose the part that is closest anglewise
// but prioritize aircraft bodies:
// this means that you should only change target from a body to another part if the part you would choose instead (because it's closer)
// belongs to another plane
float minAngle = float.PositiveInfinity;
for (int i=0; i<partsInRange.Count(); i++)
{
if (distances[i] <= ShootingRange) // first only try parts that are already in reach
{
float absAngle = (float)Math.Abs(anglesFromTo[i]);
var part = partsInRange[i];
if (absAngle < minAngle) //&&
//(TargetPart == null || !(part.Parent == TargetPart.Parent && TargetPart == TargetAircraft.Body))) // don't switch from a body to a different part of the same aircraft
{
TargetPart = part;
minAngle = absAngle;
}
}
}
if (TargetPart == null) // if you found no target this way check the rest
{
minAngle = float.PositiveInfinity;
for (int i = 0; i < partsInRange.Count(); i++)
{
float absAngle = (float)Math.Abs(anglesFromTo[i]);
var part = partsInRange[i];
// now also try parts that are not already in reach
if (absAngle < minAngle) //&&
//(TargetPart == null || !(part.Parent == TargetPart.Parent && TargetPart == TargetAircraft.Body))) // don't switch from a body to a different part of the same aircraft
{
TargetPart = part;
minAngle = absAngle;
}
}
}
}
// calculate the perfect point to aim for in order to hit the target
if (TargetPart != null)
{
float angleToAimFor = AngleToAimFor();
if (!(MyPart is WingJet)) // a dirty fix to make sure jet wings don't rotate since rotation screws up the flip state; for other weapons this effect can be neglected since it is only visual
{
float angleToTurnTo = angleToAimFor;
float angleTurn = Constants.AngleFromToDeg(MyPart.NullRotation, angleToTurnTo);
// make sure you don't rotate further than your MountPoint allows
if (angleTurn > MyPart.MountPoint.MaxTurningAngle)
angleToTurnTo = MyPart.NullRotation + MyPart.MountPoint.MaxTurningAngle;
else if (angleTurn < -MyPart.MountPoint.MaxTurningAngle)
angleToTurnTo = MyPart.NullRotation - MyPart.MountPoint.MaxTurningAngle;
// make sure you don't rotate further than this weapons MaxTurningAngle allows
if (MaxTurningAngle < MyPart.MountPoint.MaxTurningAngle)
{
if (angleTurn > MaxTurningAngle)
angleToTurnTo = MyPart.NullRotation + MaxTurningAngle;
else if (angleTurn < -MaxTurningAngle)
angleToTurnTo = MyPart.NullRotation - MaxTurningAngle;
}
MyPart.RotateTowards(angleToTurnTo, TurningAnglePerSecond * dt);
}
// if you're now close enough to the perfect angle (and in range) start shooting
if (CanShoot()
&& CCPoint.Distance(MyPart.PositionWorldspace, TargetPart.PositionWorldspace) <= ShootingRange
&& (Constants.AbsAngleDifferenceDeg(angleToAimFor, MyPart.MyRotation) <= ToleratedError || WouldHit()))
{
TryShoot();
}
}
// and if you have no target try to get back to NullRotation
else if (!(MyPart is WingJet))
{
MyPart.RotateTowards(MyPart.NullRotation, TurningAnglePerSecond * dt);
}
}
void HandleMoveCircle(CCTouch touch)
{
const float timeToTake = 1.5f; // in seconds
CCFiniteTimeAction coreAction = null;
// By default all actions will be added directly to the
// root node - it has values for Position, Scale, and Rotation.
CCNode nodeToAddTo = drawNodeRoot;
switch (VariableOptions [currentVariableIndex])
{
case "Position":
coreAction = new CCMoveTo(timeToTake, touch.Location);
break;
case "Scale":
var distance = CCPoint.Distance(touch.Location, drawNodeRoot.Position);
var desiredScale = distance / DefaultCircleRadius;
coreAction = new CCScaleTo(timeToTake, desiredScale);
break;
case "Rotation":
float differenceY = touch.Location.Y - drawNodeRoot.PositionY;
float differenceX = touch.Location.X - drawNodeRoot.PositionX;
float angleInDegrees = -1 * CCMathHelper.ToDegrees(
(float)Math.Atan2(differenceY, differenceX));
coreAction = new CCRotateTo(timeToTake, angleInDegrees);
break;
case "LineWidth":
coreAction = new LineWidthAction(timeToTake, touch.Location.X / 40f);
// The LineWidthAction is a special action designed to work only on
// LineNode instances, so we have to set the nodeToAddTo to the lineNode:
nodeToAddTo = lineNode;
break;
}
CCAction easing = null;
switch (EasingOptions [currentEasingIndex])
{
case "CCEaseBack":
if (currentInOutIndex == 0)
{
easing = new CCEaseBackOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseBackIn(coreAction);
}
else
{
easing = new CCEaseBackInOut(coreAction);
}
break;
case "CCEaseBounce":
if (currentInOutIndex == 0)
{
easing = new CCEaseBounceOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseBounceIn(coreAction);
}
else
{
easing = new CCEaseBounceInOut(coreAction);
}
break;
case "CCEaseElastic":
if (currentInOutIndex == 0)
{
easing = new CCEaseElasticOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseElasticIn(coreAction);
}
else
{
easing = new CCEaseElasticInOut(coreAction);
}
break;
case "CCEaseExponential":
if (currentInOutIndex == 0)
{
easing = new CCEaseExponentialOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseExponentialIn(coreAction);
}
else
{
easing = new CCEaseExponentialInOut(coreAction);
}
break;
case "CCEaseSine":
if (currentInOutIndex == 0)
{
easing = new CCEaseSineOut(coreAction);
}
else if (currentInOutIndex == 1)
{
easing = new CCEaseSineIn(coreAction);
}
else
{
easing = new CCEaseSineInOut(coreAction);
}
break;
}
nodeToAddTo.AddAction(easing ?? coreAction);
}
