public override void HandleCollisions(CollisionBody collider, CollisionType colliderType)
{
if (collider is Projectile)
{
Projectile collidingProjectile = collider as Projectile;
health -= 1;
Explosion.NewExplosion(collidingProjectile.position, Vector2.Zero);
collidingProjectile.DestroyInstance(collidingProjectile);
}
}
Vector2 GetExtrudedIndex(CollisionBody body, int index)
{
if (index < 0 || index >= body.vertices.Length)
{
return(Vector2.zero);
}
var pos = body.vertices[index];
var posP1 = index == body.vertices.Length - 1 ? body.vertices[0] : body.vertices[index + 1];
var posM1 = index == 0 ? body.vertices[body.vertices.Length - 1] : body.vertices[index - 1];
var dir = posP1 + posM1 - 2 * pos;
return(pos - dir.normalized * m_outDistance);
}
/// <summary>
/// Returns the node with the smallest distance to goal.
/// </summary>
private SearchNode FindBestNode(CollisionBody collisionBody)
{
SearchNode currentTile = openList[0];
float smallestDistanceToGoal = float.MaxValue;
// Find the closest node to the goal.
for (int i = 0; i < openList.Count; i++)
{
if (openList[i].DistanceToGoal < smallestDistanceToGoal && !collisionBody.Collides(openList[i].CollisionArea))
{
currentTile = openList[i];
smallestDistanceToGoal = currentTile.DistanceToGoal;
}
}
return(currentTile);
}
protected override void OnComponentDetached(EntityComponent component)
{
var body = component as CollisionBody;
if (body != null)
{
if (_bodies.Contains(body))
{
_bodies.Remove(body);
}
else
{
_playerBody = null;
}
}
base.OnComponentDetached(component);
}
public Player(PlayerModel descriptor, PlayerConnection connection)
{
_descriptor = descriptor;
_connection = connection;
_connection.Player = this;
this.State = ActorStates.Idle;
this.Descriptor.CollisionBounds = new Rect(16, 52, 16, 20);
this.CollisionBody = new CollisionBody(this);
_inventory = new Inventory(this);
_equipment = new Equipment(this);
_networkComponent = new PlayerNetworkComponent(this, connection);
_packetHandler = new PlayerPacketHandler(this);
_actionProcessor = new ActionProcessor <Player>(this);
_eventHandlers = new Dictionary <string, List <Action <EventArgs> > >();
Script script = Engine.Services.Get <ScriptManager>().CreateScript(Constants.FILEPATH_SCRIPTS + "player.py");
_script = script;
try
{
this.Behavior = script.GetVariable <ActorBehaviorDefinition>("BehaviorDefinition");
}
catch { }
if (this.Behavior == null)
{
Engine.Services.Get <Logger>().LogEvent("Error hooking player behavior definition.", LogTypes.ERROR, new Exception("Error hooking player behavior definition."));
}
else
{
this.Behavior.OnCreated(this);
this.Behavior.EventOccured += this.BehaviorDescriptor_EventOccured;
}
this.Descriptor.Stats.Changed += (o, args) =>
{
this.NetworkComponent.SendPlayerStats();
};
}
protected override void OnComponentAttached(EntityComponent component)
{
var body = component as CollisionBody;
if (body != null)
{
if (body.Entity.Name == "Player")
{
_playerBody = body;
}
else
{
_bodies.Add(body);
body.BoundingBox = new BoundingBox(new Vector3(body.Entity.Position, 0), new Vector3(body.Entity.Position.X + body.Size.Width, body.Entity.Position.Y + body.Size.Height, 0));
}
}
base.OnComponentAttached(component);
}
public override void HandleCollisions(CollisionBody collider, CollisionType colliderType)
{
if (collider is Projectile)
{
Projectile collidingProjectile = collider as Projectile;
health -= 1;
if (deathTimer > 0)
{
deathTimer = 80;
}
Explosion.NewExplosion(collidingProjectile.position, Vector2.Zero);
collidingProjectile.DestroyInstance(collidingProjectile);
}
if (collider is Asteroid)
{
Asteroid collidingAsteroid = collider as Asteroid;
collidingAsteroid.health -= 2;
Explosion.NewExplosion(collidingAsteroid.position, Vector2.Zero);
health = 0;
}
}
public override void HandleCollisions(CollisionBody collider, CollisionType colliderType)
{
if (collider is Projectile)
{
Projectile collidingProjectile = collider as Projectile;
health -= 1;
if (health <= 0)
{
DropPowerUp(1, new Vector2(Width / 2f, Height / 2f));
SpawnGore(Main.random.Next(8, 10 + 1), Width, Height, Main.random.Next(1, 2 + 1));
GenerateSmoke(Color.Orange, Color.Gray, Width, Height, 16);
if (beam != null)
{
beam.DestroyInstance(beam);
beam = null;
}
DestroyInstance(this);
}
Explosion.NewExplosion(collidingProjectile.position, Vector2.Zero);
collidingProjectile.DestroyInstance(collidingProjectile);
}
if (collider is Asteroid)
{
Asteroid collidingAsteroid = collider as Asteroid;
collidingAsteroid.health -= 2;
Explosion.NewExplosion(collidingAsteroid.position, Vector2.Zero);
DropPowerUp(1, new Vector2(Width / 2f, Height / 2f));
SpawnGore(Main.random.Next(8, 10 + 1), Width, Height, Main.random.Next(1, 2 + 1));
GenerateSmoke(Color.Orange, Color.Gray, Width, Height, 16);
if (beam != null)
{
beam.DestroyInstance(beam);
beam = null;
}
DestroyInstance(this);
}
}
void GetFarestVertex(CollisionBody body, Vector2 startPos, Vector2 endPos, out int leftIndex, out int rightIndex, out bool farestLeft)
{
leftIndex = -1;
rightIndex = -1;
var dir = endPos - startPos;
float leftAngle = 0;
float rightAngle = 0;
float epsilonSqrMax = m_outDistance * m_outDistance * 2;
for (int i = 0; i < body.vertices.Length; i++)
{
var dPoint = body.vertices[i] - startPos;
if (dPoint.sqrMagnitude < epsilonSqrMax)
{
continue;
}
var angle = Vector2.SignedAngle(dir, dPoint);
if (angle > leftAngle)
{
leftIndex = i;
leftAngle = angle;
}
if (angle < rightAngle)
{
rightIndex = i;
rightAngle = angle;
}
}
farestLeft = Mathf.Abs(leftAngle) > Mathf.Abs(rightAngle);
}
/// <summary>
/// Finds the optimal path from one point to another.
/// </summary>
public List <Vector> FindPath(Vector startPoint, Vector endPoint, CollisionBody collisionBody)
{
Vector normStartPoint = new Vector((int)(startPoint.X / Settings.TileSize), (int)(startPoint.Y / Settings.TileSize));
Vector normEndPoint = new Vector((int)(endPoint.X / Settings.TileSize), (int)(endPoint.Y / Settings.TileSize));
if (normStartPoint.X < _mapBounds.X || normStartPoint.Y < _mapBounds.Y ||
normEndPoint.X < _mapBounds.X || normEndPoint.Y < _mapBounds.Y)
{
return(new List <Vector>());
}
if (normStartPoint.X >= _mapBounds.Width || normStartPoint.Y >= _mapBounds.Height ||
normEndPoint.X >= _mapBounds.Width || normEndPoint.Y >= _mapBounds.Height)
{
return(new List <Vector>());
}
// Only try to find a path if the start and end points are different.
if (normStartPoint.X == normEndPoint.X && normStartPoint.Y == normEndPoint.Y)
{
return(new List <Vector>());
}
/////////////////////////////////////////////////////////////////////
// Step 1 : Clear the Open and Closed Lists and reset each node’s F
// and G values in case they are still set from the last
// time we tried to find a path.
/////////////////////////////////////////////////////////////////////
ResetSearchNodes();
// Store references to the start and end nodes for convenience.
SearchNode startNode = _searchNodes[(int)normStartPoint.X, (int)normStartPoint.Y];
SearchNode endNode = _searchNodes[(int)normEndPoint.X, (int)normEndPoint.Y];
/////////////////////////////////////////////////////////////////////
// Step 2 : Set the start node’s G value to 0 and its F value to the
// estimated distance between the start node and goal node
// (this is where our H function comes in) and add it to the
// Open List.
/////////////////////////////////////////////////////////////////////
startNode.InOpenList = true;
startNode.DistanceToGoal = Heuristic(normStartPoint, normEndPoint);
startNode.DistanceTraveled = 0;
openList.Add(startNode);
/////////////////////////////////////////////////////////////////////
// Setp 3 : While there are still nodes to look at in the Open list :
/////////////////////////////////////////////////////////////////////
while (openList.Count > 0)
{
/////////////////////////////////////////////////////////////////
// a) : Loop through the Open List and find the node that
// has the smallest F value.
/////////////////////////////////////////////////////////////////
SearchNode currentNode = FindBestNode(collisionBody);
/////////////////////////////////////////////////////////////////
// b) : If the Open List empty or no node can be found,
// no path can be found so the algorithm terminates.
/////////////////////////////////////////////////////////////////
if (currentNode == null)
{
break;
}
/////////////////////////////////////////////////////////////////
// c) : If the Active Node is the goal node, we will
// find and return the final path.
/////////////////////////////////////////////////////////////////
if (currentNode.Position.X == endNode.Position.X && currentNode.Position.Y == endNode.Position.Y)
{
// Trace our path back to the start.
return(FindFinalPath(startNode, endNode));
}
/////////////////////////////////////////////////////////////////
// d) : Else, for each of the Active Node’s neighbours :
/////////////////////////////////////////////////////////////////
for (int i = 0; i < currentNode.GetNeighbors().Length; i++)
{
SearchNode neighbor = currentNode.GetNeighbors()[i];
//////////////////////////////////////////////////
// i) : Make sure that the neighbouring node can
// be walked across.
//////////////////////////////////////////////////
if (neighbor == null || neighbor.Walkable == false)
{
continue;
}
//////////////////////////////////////////////////
// ii) Calculate a new G value for the neighbouring node.
//////////////////////////////////////////////////
float distanceTraveled = currentNode.DistanceTraveled + 1;
// An estimate of the distance from this node to the end node.
float heuristic = Heuristic(neighbor.Position, normEndPoint);
//////////////////////////////////////////////////
// iii) If the neighbouring node is not in either the Open
// List or the Closed List :
//////////////////////////////////////////////////
if (neighbor.InOpenList == false && neighbor.InClosedList == false)
{
// (1) Set the neighbouring node’s G value to the G value
// we just calculated.
neighbor.DistanceTraveled = distanceTraveled;
// (2) Set the neighbouring node’s F value to the new G value +
// the estimated distance between the neighbouring node and
// goal node.
neighbor.DistanceToGoal = distanceTraveled + heuristic;
// (3) Set the neighbouring node’s Parent property to point at the Active
// Node.
neighbor.Parent = currentNode;
// (4) Add the neighbouring node to the Open List.
neighbor.InOpenList = true;
openList.Add(neighbor);
}
//////////////////////////////////////////////////
// iv) Else if the neighbouring node is in either the Open
// List or the Closed List :
//////////////////////////////////////////////////
else if (neighbor.InOpenList || neighbor.InClosedList)
{
// (1) If our new G value is less than the neighbouring
// node’s G value, we basically do exactly the same
// steps as if the nodes are not in the Open and
// Closed Lists except we do not need to add this node
// the Open List again.
if (neighbor.DistanceTraveled > distanceTraveled)
{
neighbor.DistanceTraveled = distanceTraveled;
neighbor.DistanceToGoal = distanceTraveled + heuristic;
neighbor.Parent = currentNode;
}
}
}
/////////////////////////////////////////////////////////////////
// e) Remove the Active Node from the Open List and add it to the
// Closed List
/////////////////////////////////////////////////////////////////
openList.Remove(currentNode);
currentNode.InClosedList = true;
}
// No path could be found.
return(new List <Vector>());
}
public void Connect(string strName, out CollisionBody item)
{
ExAddProperty(this.m_pSelf, strName, 4, 0x2ee0);
item = null;
}
public void Connect(string strName, out CollisionBody item)
{
item = RuntimeObject.FromPtr(ExGetProperty(this.m_pSelf, strName, 4, 0x2ee0)) as CollisionBody;
}
public abstract void removeBody(CollisionBody body);
public abstract void addBody(CollisionBody body);
public AbstractCollisionComponent(IEntity owner, CollisionBody body)
: base(owner)
{
this.bodyList = new List<CollisionBody>();
this.bodyList.Add(body);
}
