public void AddSolid()
{
if (!Dead)
{
_floor = BodyFactory.CreateRectangle(_world, ConvertUnits.ToSimUnits(Globals.SmallGridSize.X),
ConvertUnits.ToSimUnits(Globals.SmallGridSize.Y), 30f);
_floor.Position = ConvertUnits.ToSimUnits(_position.X + _centerVect.X, _position.Y + _centerVect.Y);
_floor.IsStatic = true;
_floor.Restitution = _stats.Restitution;
_floor.Friction = _stats.Friction;
//_bullet.LinearDamping = 0.2f;
//_bullet.AngularDamping = 0.2f;
_floor.Enabled = false;
_floor.UserData = "caveblock";
hull = ShadowHull.CreateRectangle(new Vector2(Globals.SmallGridSize.X, Globals.SmallGridSize.Y));
hull.Position.X = _position.X + _centerVect.X;
hull.Position.Y = _position.Y + _centerVect.Y;
krypton.Hulls.Add(hull);
hull.Visible = false;
SSolid = true;
GoingtobeSolid = false;
}
}
public void BufferAddShadowHull(ShadowHull hull)
{
// Why do we need all of these again? (hint: we don't)
var vertexMatrix = Matrix.Identity;
var normalMatrix = Matrix.Identity;
// Create the matrices (3X speed boost versus prior version)
var cos = (float)Math.Cos(hull.Angle);
var sin = (float)Math.Sin(hull.Angle);
// vertexMatrix = scale * rotation * translation;
vertexMatrix.M11 = hull.Scale.X * cos;
vertexMatrix.M12 = hull.Scale.X * sin;
vertexMatrix.M21 = hull.Scale.Y * -sin;
vertexMatrix.M22 = hull.Scale.Y * cos;
vertexMatrix.M41 = hull.Position.X;
vertexMatrix.M42 = hull.Position.Y;
// normalMatrix = scaleInv * rotation;
normalMatrix.M11 = 1f / hull.Scale.X * cos;
normalMatrix.M12 = 1f / hull.Scale.X * sin;
normalMatrix.M21 = 1f / hull.Scale.Y * -sin;
normalMatrix.M22 = 1f / hull.Scale.Y * cos;
// Where are we in the buffer?
var vertexCount = ShadowHullVertices.Count;
// Add the vertices to the buffer
for (var i = 0; i < hull.NumPoints; i++)
{
// Transform the vertices to screen coordinates
var point = hull.Points[i];
ShadowHullVertex hullVertex;
Vector2.Transform(
ref point.Position,
ref vertexMatrix,
out hullVertex.Position);
Vector2.TransformNormal(
ref point.Normal,
ref normalMatrix,
out hullVertex.Normal);
hullVertex.Color = new Color(
r: 0,
g: 0,
b: 0,
a: 1 - hull.Opacity);
ShadowHullVertices.Add(hullVertex);
}
foreach (var index in hull.Indicies)
{
ShadowHullIndicies.Add(vertexCount + index);
}
}
public override void Load(Core.Content.LoadManager content)
{
ShadowHull = GenerateShadowHull();
LightingComponent.Krypton.Hulls.Add(ShadowHull);
base.Load(content);
}
/// <summary>
/// Creates a circular shadow hull
/// </summary>
/// <param name="radius">radius of the circle</param>
/// <param name="sides">number of sides the circle will be comprised of</param>
/// <returns>A circular shadow hull</returns>
public static ShadowHull CreateCircle(float radius, int sides)
{
// Validate input
if (sides < 3)
{
throw new ArgumentException("Shadow hull must have at least 3 sides.");
}
ShadowHull hull = new ShadowHull();
hull.MaxRadius = radius;
// Calculate number of sides
hull.NumPoints = sides * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
var angle = (float)(-Math.PI * 2) / sides; // XNA Renders Clockwise
var angleOffset = angle / 2;
for (int i = 0; i < sides; i++)
{
// Create vertices
var v1 = new ShadowHullPoint();
var v2 = new ShadowHullPoint();
// Vertex Position
v1.Position.X = (float)Math.Cos(angle * i) * radius;
v1.Position.Y = (float)Math.Sin(angle * i) * radius;
v2.Position.X = (float)Math.Cos(angle * (i + 1)) * radius;
v2.Position.Y = (float)Math.Sin(angle * (i + 1)) * radius;
// Vertex Normal
v1.Normal.X = (float)Math.Cos(angle * i + angleOffset);
v1.Normal.Y = (float)Math.Sin(angle * i + angleOffset);
v2.Normal.X = (float)Math.Cos(angle * i + angleOffset);
v2.Normal.Y = (float)Math.Sin(angle * i + angleOffset);
// Copy vertices
hull.Points[i * 2 + 0] = v1;
hull.Points[i * 2 + 1] = v2;
}
for (int i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = (Int16)(i + 1);
hull.Indicies[i * 3 + 2] = (Int16)(i + 2);
}
return(hull);
}
public BasicHull(Vector2 position, Vector2 size)
{
Vector2 newPosition = new Vector2();
newPosition.X = position.X - Globals.ScreenWidthCenter + (size.X / 2);
newPosition.Y = -position.Y + Globals.ScreenHeightCenter - (size.Y / 2);
ShadowHull pHull = ShadowHull.CreateRectangle(size);
pHull.Position = newPosition;
mShadowHull = pHull;
}
/// <summary>
/// Creates a custom shadow hull based on a series of vertices
/// </summary>
/// <param name="points">The points which the shadow hull will be comprised of</param>
/// <returns>A custom shadow hulll</returns>
public static ShadowHull CreateConvex(ref Vector2[] points)
{
// Validate input
if (points == null)
{
throw new ArgumentNullException("Points cannot be null.");
}
if (points.Length < 3)
{
throw new ArgumentException("Need at least 3 points to create shadow hull.");
}
var numPoints = points.Length;
ShadowHull hull = new ShadowHull();
hull.NumPoints = numPoints * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
Vector2 pointMin = points[0];
Vector2 pointMax = points[0];
for (int i = 0; i < numPoints; i++)
{
var p1 = points[(i + 0) % numPoints];
var p2 = points[(i + 1) % numPoints];
hull.MaxRadius = Math.Max(hull.MaxRadius, p1.Length());
var line = p2 - p1;
var normal = new Vector2(-line.Y, +line.X);
normal.Normalize();
hull.Points[i * 2 + 0] = new ShadowHullPoint(p1, normal);
hull.Points[i * 2 + 1] = new ShadowHullPoint(p2, normal);
}
for (Int16 i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = (Int16)(i + 1);
hull.Indicies[i * 3 + 2] = (Int16)(i + 2);
}
return(hull);
}
public void BufferAddShadowHull(ShadowHull hull)
{
// Why do we need all of these again? (hint: we don't)
Matrix vertexMatrix = Matrix.Identity;
Matrix normalMatrix = Matrix.Identity;
float cos, sin;
ShadowHullPoint point;
ShadowHullVertex hullVertex;
// Create the matrices (3X speed boost versus prior version)
cos = (float)Math.Cos(hull.Angle);
sin = (float)Math.Sin(hull.Angle);
// vertexMatrix = scale * rotation * translation;
vertexMatrix.M11 = hull.Scale.X * cos;
vertexMatrix.M12 = hull.Scale.X * sin;
vertexMatrix.M21 = hull.Scale.Y * -sin;
vertexMatrix.M22 = hull.Scale.Y * cos;
vertexMatrix.M41 = hull.Position.X;
vertexMatrix.M42 = hull.Position.Y;
// normalMatrix = scaleInv * rotation;
normalMatrix.M11 = (1f / hull.Scale.X) * cos;
normalMatrix.M12 = (1f / hull.Scale.X) * sin;
normalMatrix.M21 = (1f / hull.Scale.Y) * -sin;
normalMatrix.M22 = (1f / hull.Scale.Y) * cos;
// Where are we in the buffer?
var vertexCount = this.mShadowHullVertices.Count;
// Add the vertices to the buffer
for (int i = 0; i < hull.NumPoints; i++)
{
// Transform the vertices to screen coordinates
point = hull.Points[i];
Vector2.Transform(ref point.Position, ref vertexMatrix, out hullVertex.Position);
Vector2.TransformNormal(ref point.Normal, ref normalMatrix, out hullVertex.Normal);
hullVertex.Color = Color.Black;
this.mShadowHullVertices.Add(hullVertex); // could this be sped up... ?
}
//// Add the indicies to the buffer
foreach (int index in hull.Indicies)
{
mShadowHullIndicies.Add(vertexCount + index); // what about this? Add range?
}
}
public void BufferAddShadowHull(ShadowHull hull)
{
// Why do we need all of these again? (hint: we don't)
Matrix vertexMatrix = Matrix.Identity;
Matrix normalMatrix = Matrix.Identity;
float cos, sin;
ShadowHullPoint point;
ShadowHullVertex hullVertex;
// Create the matrices (3X speed boost versus prior version)
cos = (float)Math.Cos(hull.Angle);
sin = (float)Math.Sin(hull.Angle);
// vertexMatrix = scale * rotation * translation;
vertexMatrix.M11 = hull.Scale.X * cos;
vertexMatrix.M12 = hull.Scale.X * sin;
vertexMatrix.M21 = hull.Scale.Y * -sin;
vertexMatrix.M22 = hull.Scale.Y * cos;
vertexMatrix.M41 = hull.Position.X;
vertexMatrix.M42 = hull.Position.Y;
// normalMatrix = scaleInv * rotation;
normalMatrix.M11 = (1f / hull.Scale.X) * cos;
normalMatrix.M12 = (1f / hull.Scale.X) * sin;
normalMatrix.M21 = (1f / hull.Scale.Y) * -sin;
normalMatrix.M22 = (1f / hull.Scale.Y) * cos;
// Where are we in the buffer?
var vertexCount = this.mShadowHullVertices.Count;
// Add the vertices to the buffer
for (int i = 0; i < hull.NumPoints; i++)
{
// Transform the vertices to screen coordinates
point = hull.Points[i];
Vector2.Transform(ref point.Position, ref vertexMatrix, out hullVertex.Position);
Vector2.TransformNormal(ref point.Normal, ref normalMatrix, out hullVertex.Normal);
hullVertex.Color = new Color(0, 0, 0, 1 - hull.Opacity);
this.mShadowHullVertices.Add(hullVertex); // could this be sped up... ?
}
//// Add the indicies to the buffer
foreach (int index in hull.Indicies)
{
mShadowHullIndicies.Add(vertexCount + index); // what about this? Add range?
}
}
/// <summary>
/// Creates a custom shadow hull based on a series of vertices
/// </summary>
/// <param name="points">The points which the shadow hull will be comprised of</param>
/// <returns>A custom shadow hulll</returns>
public static ShadowHull CreateConvex(ref Vector2[] points)
{
// Validate input
if (points == null)
{
throw new ArgumentNullException(nameof(points));
}
if (points.Length < 3)
{
throw new ArgumentOutOfRangeException(nameof(points), "Need at least 3 points to create shadow hull.");
}
var numPoints = points.Length;
var hull = new ShadowHull();
hull.NumPoints = numPoints * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new int[hull.NumIndicies];
for (var i = 0; i < numPoints; i++)
{
var p1 = points[(i + 0) % numPoints];
var p2 = points[(i + 1) % numPoints];
hull.MaxRadius = Math.Max(hull.MaxRadius, p1.Length());
var line = p2 - p1;
var normal = new Vector2(-line.Y, +line.X);
normal.Normalize();
hull.Points[i * 2 + 0] = new ShadowHullPoint(p1, normal);
hull.Points[i * 2 + 1] = new ShadowHullPoint(p2, normal);
}
for (var i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = i + 1;
hull.Indicies[i * 3 + 2] = i + 2;
}
return(hull);
}
/// <summary> Creates a circular shadow hull </summary>
/// <param name="radius">radius of the circle</param>
/// <param name="sides">number of sides the circle will be comprised of</param>
/// <returns>A circular shadow hull</returns>
public static ShadowHull CreateCircle(float radius, int sides)
{
// Validate input
if (sides < 3) { throw new ArgumentException("Shadow hull must have at least 3 sides."); }
var hull = new ShadowHull { MaxRadius = radius, NumPoints = sides * 2 };
// Calculate number of sides
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
var angle = (float)(-Math.PI * 2) / sides; // XNA Renders Clockwise
var angleOffset = angle / 2;
for (int i = 0; i < sides; i++) {
// Create vertices
var v1 = new ShadowHullPoint();
var v2 = new ShadowHullPoint();
// Vertex Position
v1.Position.X = (float)Math.Cos(angle * i) * radius;
v1.Position.Y = (float)Math.Sin(angle * i) * radius;
v2.Position.X = (float)Math.Cos(angle * (i + 1)) * radius;
v2.Position.Y = (float)Math.Sin(angle * (i + 1)) * radius;
// Vertex Normal
v1.Normal.X = (float)Math.Cos(angle * i + angleOffset);
v1.Normal.Y = (float)Math.Sin(angle * i + angleOffset);
v2.Normal.X = (float)Math.Cos(angle * i + angleOffset);
v2.Normal.Y = (float)Math.Sin(angle * i + angleOffset);
// Copy vertices
hull.Points[i * 2 + 0] = v1;
hull.Points[i * 2 + 1] = v2;
}
for (int i = 0; i < numTris; i++) {
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = i + 1;
hull.Indicies[i * 3 + 2] = i + 2;
}
return hull;
}
/// <summary>
/// Creates a rectangular shadow hull
/// </summary>
/// <param name="size">The dimensions of the rectangle</param>
/// <returns>A rectangular shadow hull</returns>
public static ShadowHull CreateRectangle(Vector2 size)
{
ShadowHull hull = new ShadowHull();
size *= 0.5f;
hull.MaxRadius = (float)Math.Sqrt(size.X * size.X + size.Y * size.Y);
hull.NumPoints = 4 * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
// Vertex position
var posTR = new Vector2(+size.X, +size.Y);
var posBR = new Vector2(+size.X, -size.Y);
var posBL = new Vector2(-size.X, -size.Y);
var posTL = new Vector2(-size.X, +size.Y);
// Right
hull.Points[0] = new ShadowHullPoint(posTR, Vector2.UnitX);
hull.Points[1] = new ShadowHullPoint(posBR, Vector2.UnitX);
// Bottom
hull.Points[2] = new ShadowHullPoint(posBR, -Vector2.UnitY);
hull.Points[3] = new ShadowHullPoint(posBL, -Vector2.UnitY);
// Left
hull.Points[4] = new ShadowHullPoint(posBL, -Vector2.UnitX);
hull.Points[5] = new ShadowHullPoint(posTL, -Vector2.UnitX);
// Top
hull.Points[6] = new ShadowHullPoint(posTL, Vector2.UnitY);
hull.Points[7] = new ShadowHullPoint(posTR, Vector2.UnitY);
// Create tris
for (int i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = i + 1;
hull.Indicies[i * 3 + 2] = i + 2;
}
return(hull);
}
/// <summary>
/// Creates a rectangular shadow hull
/// </summary>
/// <param name="size">The dimensions of the rectangle</param>
/// <returns>A rectangular shadow hull</returns>
public static ShadowHull CreateRectangle(Vector2 size)
{
ShadowHull hull = new ShadowHull();
size *= 0.5f;
hull.MaxRadius = (float)Math.Sqrt(size.X * size.X + size.Y * size.Y);
hull.NumPoints = 4 * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
// Vertex position
var posTR = new Vector2(+size.X, +size.Y);
var posBR = new Vector2(+size.X, -size.Y);
var posBL = new Vector2(-size.X, -size.Y);
var posTL = new Vector2(-size.X, +size.Y);
// Right
hull.Points[0] = new ShadowHullPoint(posTR, Vector2.UnitX);
hull.Points[1] = new ShadowHullPoint(posBR, Vector2.UnitX);
// Bottom
hull.Points[2] = new ShadowHullPoint(posBR, -Vector2.UnitY);
hull.Points[3] = new ShadowHullPoint(posBL, -Vector2.UnitY);
// Left
hull.Points[4] = new ShadowHullPoint(posBL, -Vector2.UnitX);
hull.Points[5] = new ShadowHullPoint(posTL, -Vector2.UnitX);
// Top
hull.Points[6] = new ShadowHullPoint(posTL, Vector2.UnitY);
hull.Points[7] = new ShadowHullPoint(posTR, Vector2.UnitY);
// Create tris
for (int i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = i + 1;
hull.Indicies[i * 3 + 2] = i + 2;
}
return hull;
}
public void LoadContent()
{
int blockface = MyRandom.Random.Next(0, 13);
txtrect = new Rectangle(0 + (25 * blockface), 0, (int)Globals.SmallGridSize.X, (int)Globals.SmallGridSize.Y);
int rot = MyRandom.Random.Next(0, 3);
txtrot = Math.Atan(90 * rot);
_centerVect = Globals.SmallGridSize / 2;
_floor = BodyFactory.CreateRectangle(_world, ConvertUnits.ToSimUnits(Globals.SmallGridSize.X), ConvertUnits.ToSimUnits(Globals.SmallGridSize.Y), 30f);
_floor.Position = ConvertUnits.ToSimUnits(_position.X + _centerVect.X, _position.Y + _centerVect.Y);
_floor.IsStatic = false;
_floor.Restitution = 0.2f;
_floor.Friction = 0.2f;
_floor.LinearDamping = 0.2f;
_floor.AngularDamping = 0.2f;
_blocktxture = Game.Content.Load<Texture2D>(".\\WallGraphics\\blocks");
hull = ShadowHull.CreateRectangle(new Vector2(Globals.SmallGridSize.X, Globals.SmallGridSize.Y));
hull.Position.X = _position.X + _centerVect.X;
hull.Position.Y = _position.Y + _centerVect.Y;
krypton.Hulls.Add(hull);
}
public void Initialize(Texture2D sprite, ProjectileType type, Player plr, Body b, Texture2D shadow)
{
B = b;
alreadyCollidedOnceOrMore = false;
shade = shadow;
foreach (var item in Game1.projectiles) {
B.IgnoreCollisionWith(item.B);
}
B.OnCollision += new OnCollisionEventHandler(B_OnCollision);
uint[] d = new uint[shade.Width * shade.Height];
shade.GetData(d);
Vertices v = PolygonTools.CreatePolygon(d, shade.Width, true);
Vector2[] a = v.ToArray();
h = ShadowHull.CreateConvex(ref a);
if (plr.direction == 1)
dir = 1;
lock (Game1.projectileLock)
Game1.lightingEngine.Hulls.Add(h);
// B.ApplyLinearImpulse(new Vector2(50, -10));
if (plr.direction == 1) {
B.Position = new Vector2(-plr.Position.X, plr.Position.Y + 1);
B.ApplyTorque(-250f);
B.LinearVelocity = new Vector2(-65, 7);
} else {
B.Position = new Vector2(-plr.Position.X, plr.Position.Y + 1);
B.ApplyTorque(250f);
B.LinearVelocity = new Vector2(65, 7);
}
Active = true;
position = ConvertUnits.ToDisplayUnits(-plr.Position);
texture = sprite;
Type = type;
Pelaaja = plr;
hitBox.Width = 17;
hitBox.Height = 17;
hitBox.X = (int)position.X;
hitBox.Y = (int)position.Y;
}
/// <summary>
/// Creates a custom shadow hull based on a series of vertices
/// </summary>
/// <param name="points">The points which the shadow hull will be comprised of</param>
/// <returns>A custom shadow hulll</returns>
public static ShadowHull CreateConvex(ref Vector2[] points)
{
// Validate input
if (points == null) { throw new ArgumentNullException("Points cannot be null."); }
if (points.Length < 3) { throw new ArgumentException("Need at least 3 points to create shadow hull."); }
var numPoints = points.Length;
ShadowHull hull = new ShadowHull();
hull.NumPoints = numPoints * 2;
var numTris = hull.NumPoints - 2;
hull.NumIndicies = numTris * 3;
hull.Points = new ShadowHullPoint[hull.NumPoints];
hull.Indicies = new Int32[hull.NumIndicies];
Vector2 pointMin = points[0];
Vector2 pointMax = points[0];
for (int i = 0; i < numPoints; i++)
{
var p1 = points[(i + 0) % numPoints];
var p2 = points[(i + 1) % numPoints];
hull.MaxRadius = Math.Max(hull.MaxRadius, p1.Length());
var line = p2 - p1;
var normal = new Vector2(-line.Y, +line.X);
normal.Normalize();
hull.Points[i * 2 + 0] = new ShadowHullPoint(p1, normal);
hull.Points[i * 2 + 1] = new ShadowHullPoint(p2, normal);
}
for (Int32 i = 0; i < numTris; i++)
{
hull.Indicies[i * 3 + 0] = 0;
hull.Indicies[i * 3 + 1] = (Int32)(i + 1);
hull.Indicies[i * 3 + 2] = (Int32)(i + 2);
}
return hull;
}
public PolygonHull(Vector2 position, List<Vector2> points)
{
Vector2[] pointsArray = points.ToArray();
for (int i = 0; i < pointsArray.Length; i++)
{
pointsArray[i] = worldToShadow(pointsArray[i]);
}
//Array.Reverse(pointsArray);
ShadowHull pHull = ShadowHull.CreateConvex(ref pointsArray);
Vector2 newPosition = new Vector2();
newPosition.X = position.X - Globals.ScreenWidthCenter;
newPosition.Y = -position.Y + Globals.ScreenHeightCenter;
pHull.Position = newPosition;
mShadowHull = pHull;
}
/// <summary>
/// Remove ShadowHull
/// </summary>
public void RemoveHull()
{
LightingEngine LE = ((LightingEngine)Renderer.GetRenderEffect("LightingEngine"));
LE.RemoveHull(Hull);
this._Hull = null;
}
/// <summary>
/// Set ShadowHull of Tile
/// </summary>
/// <param name="Size">Size</param>
/// <param name="Pos">Position</param>
public void SetRectHull(Vector2 Size, Vector2 Pos)
{
ShadowHull H = ShadowHull.CreateRectangle(Size);
H.Position = Pos;
LightingEngine LE = ((LightingEngine)Renderer.GetRenderEffect("LightingEngine"));
if (Hull != null)
{
LE.RemoveHull(Hull);
}
LE.AddHull(H);
this._Hull = H;
}
public void RemoveHull(ShadowHull Hull)
{
Krypton.Hulls.Remove(Hull);
}
public void AddHull(ShadowHull Hull)
{
Krypton.Hulls.Add(Hull);
}
public void Initialize(Texture2D texture, Texture2D healthbar, Vector2 position, int maxFrames, ContentManager cont, GraphicsDeviceManager graphics, World World, Texture2D Shade)
{
_world = World;
shadow = Shade;
bPlayer = BodyFactory.CreateRectangle(World, ConvertUnits.ToSimUnits(43), ConvertUnits.ToSimUnits(50), 1f);
// BodyFactory.CreateRectangle()
bPlayer.BodyType = BodyType.Dynamic;
bPlayer.Friction = 0.0f;
bPlayer.Restitution = 0.0f;
Joint rotationJoint = JointFactory.CreateFixedAngleJoint(World, bPlayer);
bPlayer.OnCollision += new OnCollisionEventHandler(bPlayer_OnCollision);
bPlayer.OnSeparation += new OnSeparationEventHandler(bPlayer_OnSeparation);
cm = cont;
PlayerSprite = texture;
shurikenPicture = cm.Load<Texture2D>("shuriken");
currentAnim.amountOfFrames = maxFrames;
currentAnim.currentFrame = new Point(0, 0);
currentAnim.frameSize = new Point(63, 63);
currentAnim.sheetSize = new Point(9, 0);
currentAnim.animInterval = 95.0f;
swingHitBox = new Rectangle((int)position.X, (int)position.Y, (int)currentAnim.frameSize.X, (int)currentAnim.frameSize.Y / 2);
playerTextureData = new Color[texture.Width * texture.Height];
texture.GetData(playerTextureData);
amountOfFrames = maxFrames;
idleAnim = texture;
currentAnimation = PlayerSprite;
Position = position;
hitBox.X = (int)position.X;
hitBox.Y = (int)position.Y;
hitBox.Width = texture.Width;
hitBox.Height = texture.Height;
HPBar = healthbar;
uint[] d = new uint[shadow.Width * shadow.Height];
shadow.GetData(d);
Vertices v = PolygonTools.CreatePolygon(d, shadow.Width);
List<Vertices> _list = FarseerPhysics.Common.Decomposition.EarclipDecomposer.ConvexPartition(v);
Vector2[] q = v.ToArray();
h = ShadowHull.CreateConvex(ref q);
h.Position = Position;
lock (Game1.projectileLock)
Game1.lightingEngine.Hulls.Add(h);
}
public void Draw(SpriteBatch spriteBatch)
{
//spriteBatch.Draw(PlayerSprite, Position, Color.White);
byte alpha = 0xff;
// 0x80 = 128, 0xFF = 255
if (stealth) alpha = 0x80;
// DrawPlayerHitbox(spriteBatch);
// DrawSwingHitbox(spriteBatch);
SpriteEffects s = SpriteEffects.None;
if (direction == 1) s = SpriteEffects.FlipHorizontally;
if (direction == 1 && mCurrentState == State.Attacking && currentAnim.state == State.Attacking)
{
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X) - currentAnim.frameSize.X, ConvertUnits.ToDisplayUnits(-Position.Y) - 32), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), 0, new Vector2(0, 0), 1,
s, 0);
}
else if (direction == 0 && mCurrentState == State.Attacking && currentAnim.state == State.Attacking)
{
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X), ConvertUnits.ToDisplayUnits(-Position.Y) - 32), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), 0, new Vector2(0, 0), 1,
s, 0);
}
else if (direction == 1 && mCurrentState == State.Hanging)
{
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X) - 40, ConvertUnits.ToDisplayUnits(-Position.Y) - 32), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), 0, new Vector2(0, 0), 1,
s, 0);
}
else if (direction == 0 && mCurrentState == State.Hanging)
{
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X) - 22, ConvertUnits.ToDisplayUnits(-Position.Y) - 32), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), 0, new Vector2(0, 0), 1,
s, 0);
}
else if (mCurrentState == State.WallJumping)
{
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X), ConvertUnits.ToDisplayUnits(-Position.Y)), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), angle, new Vector2(currentAnim.frameSize.X / 2, currentAnim.frameSize.Y / 2), 1,
s, 0);
}
else
{
int h = 0;
if (direction == 0)
h = 10;
spriteBatch.Draw(currentAnimation, new Vector2(ConvertUnits.ToDisplayUnits(-Position.X) - currentAnim.frameSize.X / 2 - h, ConvertUnits.ToDisplayUnits(-Position.Y) - 32), new Rectangle(
currentAnim.frameSize.X * currentAnim.currentFrame.X,
currentAnim.frameSize.Y * currentAnim.currentFrame.Y,
currentAnim.frameSize.X,
currentAnim.frameSize.Y),
new Color(255, 255, 255, alpha), 0, new Vector2(0, 0), 1,
s, 0);
}
}
