/// <summary>
/// Actualiza la posicion e inclinacion del cilindro
/// </summary>
public void updateValues()
{
BoundingCylinder.Radius = FastMath.Max(
FastMath.Abs(TopRadius), FastMath.Abs(BottomRadius));
BoundingCylinder.updateValues();
updateDraw();
}
/// <inheritdoc />
public override void Initialize()
{
Game.Background = Color.CornflowerBlue;
// Creates a Static Camera pointing to the center
Camera = new StaticCamera(GraphicsDevice.Viewport.AspectRatio,
Vector3.Forward * 100f + Vector3.Up * 100f,
-Vector3.Normalize(Vector3.Forward + Vector3.Up),
Vector3.Up);
// Robot position and matrix initialization
RobotPosition = Vector3.Zero;
RobotWorld = Matrix.CreateScale(0.3f);
// Chair position and matrix initialization
ChairAngle = MathHelper.PiOver4;
ChairScale = Matrix.CreateScale(0.5f);
ChairTranslation = Matrix.CreateTranslation(Vector3.UnitX * 50f);
ChairWorld = ChairScale * Matrix.CreateRotationY(ChairAngle) * ChairTranslation;
// Tank position and matrix initialization
TankPosition = -Vector3.UnitX * 10f + Vector3.UnitZ * 10f;
TankWorld = Matrix.CreateScale(3f) * Matrix.CreateTranslation(TankPosition);
// Robot two position and matrix initialization
var robotTwoPosition = Vector3.UnitX * -50f + Vector3.UnitZ * 10f;
RobotTwoWorld = Matrix.CreateScale(0.25f) * Matrix.CreateRotationY(MathHelper.PiOver4 + MathHelper.PiOver2) * Matrix.CreateTranslation(robotTwoPosition);
RobotTwoCylinder = new BoundingCylinder(robotTwoPosition, 5f, 10f);
base.Initialize();
}
public void BoundingCylinder_Ray_Test()
{
BoundingCylinder cyl = new BoundingCylinder (sideA: Vector3.Zero, sideB: Vector3.Up * 100, radius: 100f);
Ray ray;
ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Up);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Down);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Forward);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 0, 0), direction: Vector3.Left);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, -1, 0), direction: Vector3.Forward);
Assert.IsNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, -1, 0), direction: Vector3.Left);
Assert.IsNull (ray.Intersects (cyl));
// hier sollte eigentlich (0,100,0) auch noch drin sein, nicht nur (0,99,0),
// also wie bei SideA!
ray = new Ray (position: new Vector3 (0, 99, 0), direction: Vector3.Forward);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 99, 0), direction: Vector3.Left);
Assert.IsNotNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 101, 0), direction: Vector3.Forward);
Assert.IsNull (ray.Intersects (cyl));
ray = new Ray (position: new Vector3 (0, 101, 0), direction: Vector3.Left);
Assert.IsNull (ray.Intersects (cyl));
}
public bool IntersectsAny(DrawableGameComponent component, Vector3 offset)
{
BoundingCylinder cylinder = component.GetBoundingCylinder();
cylinder.Point += offset;
return(vegetationList.Any(v => cylinder.Intersects(v.GetBoundingCylinder())));
}
public void Dispose()
{
if (texture != null)
{
texture.dispose();
}
sideTrianglesVertices = null;
BoundingCylinder.Dispose();
}
public override BoundingCylinder GetBoundingCylinder()
{
BoundingCylinder cylinder = base.GetBoundingCylinder();
cylinder.Point += Vector3.Down * cylinder.Height;
cylinder.Height *= 2;
return(cylinder);
}
private bool CheckPigEscape(BoundingCylinder cylinder, float elapsed, Vector3 velocity)
{
BoundingCylinder pigCylinder = Pig.GetBoundingCylinder();
BoundingCylinder newPigCylinder = pigCylinder;
newPigCylinder.Point = Pig.Position + velocity * elapsed;
return(cylinder.Contains(pigCylinder) && !cylinder.Contains(newPigCylinder));
}
private bool TestTerrainCollisionCylinder(Vector3 velocity, out Vector3 adjustedVelocity, List <ColoredBoundingBox> boxes)
{
adjustedVelocity = velocity;
var testBox = GetAABBVelocityBox(velocity);
var testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
Entity.Width / 2f);
bool collision = false;
for (int x = (int)(Math.Floor(testBox.Min.X)); x <= (int)(Math.Ceiling(testBox.Max.X)); x++)
{
for (int z = (int)(Math.Floor(testBox.Min.Z)); z <= (int)(Math.Ceiling(testBox.Max.Z)); z++)
{
for (int y = (int)(Math.Floor(testBox.Min.Y)); y <= (int)(Math.Ceiling(testBox.Max.Y)); y++)
{
var blockState = Entity.Level.GetBlockState(x, y, z);
if (!blockState.Block.Solid)
{
continue;
}
var coords = new Vector3(x, y, z);
foreach (var box in blockState.Block.GetBoundingBoxes(coords))
{
if (testCylinder.Intersects(box))
{
if (testBox.Intersects(box))
{
if (boxes != null)
{
boxes.Add(new ColoredBoundingBox(box, Color.Orange));
}
collision = true;
AdjustVelocityForCollision(ref velocity, box);
testBox = GetAABBVelocityBox(velocity);
testCylinder = new BoundingCylinder(
testBox.Min, testBox.Max,
Entity.Width / 2f);
adjustedVelocity = velocity;
}
}
}
}
}
}
return(collision);
}
public void TestIntersectsBox()
{
// x
// /
// x
var cylinder = new BoundingCylinder(Vector3.Zero, Vector3.One * 10, 3);
var doesNotIntersect = new BoundingBox(Vector3.One * 10 + 5, Vector3.One * 10 + 5);
Assert.IsFalse(cylinder.Intersects(doesNotIntersect));
var intersects = new BoundingBox(Vector3.Zero, Vector3.One);
Assert.IsTrue(cylinder.Intersects(intersects));
}
protected Actor()
{
maxHealth = health = 1000;
prevPos = bCylinder.Position = vel = Vector3k.Zero;
speed = angle = pitch = Accum.Zero;
prevAngle = prevPitch = Accum.Zero;
flags = 0;
gravity = Accum.One;
bCylinder = new BoundingCylinder(new Accum(16), new Accum(20), new Vector3k(Accum.Zero, Accum.Zero, Accum.Zero));
cam = new Camera();
}
public void TestIntersectsPoint()
{
// x
// /
// x
var cylinder = new BoundingCylinder(Vector3.Zero, Vector3.One, 1);
Assert.IsTrue(cylinder.Intersects(cylinder.Min));
Assert.IsTrue(cylinder.Intersects(cylinder.Max));
Assert.IsTrue(cylinder.Intersects(cylinder.Min + (Vector3.One / 2)));
Assert.IsTrue(cylinder.Intersects(cylinder.Max - (Vector3.One / 2)));
Assert.IsTrue(cylinder.Intersects(new Vector3(0.25, 0, 0)));
Assert.IsFalse(cylinder.Intersects(new Vector3(5, 5, 5)));
}
public void TestIntersectsBox()
{
// x
// /
// x
var cylinder = new BoundingCylinder(Vector3.Zero, Vector3.One * 10, 3);
var doesNotIntersect = new BoundingBox(Vector3.One * 10f + new Vector3(5, 5, 5), Vector3.One * 10f + new Vector3(5, 5, 5));
Assert.IsFalse(cylinder.Intersects(doesNotIntersect));
var intersects = new BoundingBox(Vector3.Zero, Vector3.One);
Assert.IsTrue(cylinder.Intersects(intersects));
}
public void TestIntersectsPoint()
{
// x
// /
// x
var cylinder = new BoundingCylinder(Vector3.Zero, Vector3.One, 1);
Assert.IsTrue(cylinder.Intersects(cylinder.Min));
Assert.IsTrue(cylinder.Intersects(cylinder.Max));
Assert.IsTrue(cylinder.Intersects(cylinder.Min + Vector3.One / 2));
Assert.IsTrue(cylinder.Intersects(cylinder.Max - Vector3.One / 2));
Assert.IsTrue(cylinder.Intersects(new Vector3(0.25f, 0, 0)));
Assert.IsFalse(cylinder.Intersects(new Vector3(5, 5, 5)));
}
public bool TestTerrainCollisionCylinder(Entity entity, out Vector3 collisionPoint)
{
collisionPoint = Vector3.Zero;
var testBox = GetAABBVelocityBox(entity);
var testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
Vector3.Distance(entity.BoundingBox.Min, entity.BoundingBox.Max));
bool collision = false;
for (int x = (int)(Math.Floor(testBox.Min.X)); x <= (int)(Math.Ceiling(testBox.Max.X)); x++)
{
for (int z = (int)(Math.Floor(testBox.Min.Z)); z <= (int)(Math.Ceiling(testBox.Max.Z)); z++)
{
for (int y = (int)(Math.Floor(testBox.Min.Y)); y <= (int)(Math.Ceiling(testBox.Max.Y)); y++)
{
var blockState = entity.Level.GetBlockState(x, y, z);
if (blockState?.Model == null || !blockState.Block.Solid)
{
continue;
}
var coords = new Vector3(x, y, z);
foreach (var box in blockState.Model.GetBoundingBoxes(coords))
{
if (testCylinder.Intersects(box))
{
if (testBox.Intersects(box))
{
collision = true;
AdjustVelocityForCollision(entity, box);
testBox = GetAABBVelocityBox(entity);
testCylinder = new BoundingCylinder(
testBox.Min, testBox.Max,
Vector3.Distance(entity.BoundingBox.Min, entity.BoundingBox.Max));
collisionPoint = coords;
}
}
}
}
}
}
return(collision);
}
public bool TestTerrainCollisionCylinder(IAABBEntity entity, out Vector3 collisionPoint)
{
collisionPoint = Vector3.Zero;
var testBox = GetAABBVelocityBox(entity);
var testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
entity.BoundingBox.Min.DistanceTo(entity.BoundingBox.Max));
var collision = false;
for (var x = (int)Math.Floor(testBox.Min.X); x <= (int)Math.Ceiling(testBox.Max.X); x++)
{
for (var z = (int)Math.Floor(testBox.Min.Z); z <= (int)Math.Ceiling(testBox.Max.Z); z++)
{
for (var y = (int)Math.Floor(testBox.Min.Y); y <= (int)Math.Ceiling(testBox.Max.Y); y++)
{
var coords = new Coordinates3D(x, y, z);
if (!World.IsValidPosition(coords))
{
continue;
}
var _box = BlockPhysicsProvider.GetBoundingBox(World, coords);
if (_box == null)
{
continue;
}
var box = _box.Value.OffsetBy(coords.AsVector3());
if (testCylinder.Intersects(box))
{
if (testBox.Intersects(box))
{
collision = true;
AdjustVelocityForCollision(entity, box);
testBox = GetAABBVelocityBox(entity);
testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
entity.BoundingBox.Min.DistanceTo(entity.BoundingBox.Max));
collisionPoint = coords.AsVector3();
}
}
}
}
}
return(collision);
}
/// <inheritdoc />
public override void Initialize()
{
Game.Background = Color.Black;
// Robot position and matrix initialization
RobotPosition = Vector3.UnitX * 30f;
RobotScale = Matrix.CreateScale(0.3f);
RobotRotation = Matrix.Identity;
// Create the BoundingCylinder enclosing the Robot
RobotCylinder = new BoundingCylinder(RobotPosition, 10f, 20f);
// Create the Camera
Camera = new TargetCamera(GraphicsDevice.Viewport.AspectRatio, Vector3.One * 100f, Vector3.Zero);
// Create the Matrices for drawing the Floor and Walls
FloorWorld = Matrix.CreateScale(200f);
WallWorldMatrices = new Matrix[5];
var scale = new Vector3(200f, 1f, 200f);
WallWorldMatrices[0] = Matrix.CreateScale(scale) * Matrix.CreateRotationX(MathHelper.PiOver2) * Matrix.CreateTranslation(-Vector3.UnitZ * 200f + Vector3.UnitY * 200f);
WallWorldMatrices[1] = Matrix.CreateScale(scale) * Matrix.CreateRotationX(-MathHelper.PiOver2) * Matrix.CreateTranslation(Vector3.UnitZ * 200f + Vector3.UnitY * 200f);
WallWorldMatrices[2] = Matrix.CreateScale(scale) * Matrix.CreateRotationZ(MathHelper.PiOver2) * Matrix.CreateTranslation(Vector3.UnitX * 200f + Vector3.UnitY * 200f);
WallWorldMatrices[3] = Matrix.CreateScale(scale) * Matrix.CreateRotationZ(-MathHelper.PiOver2) * Matrix.CreateTranslation(-Vector3.UnitX * 200f + Vector3.UnitY * 200f);
WallWorldMatrices[4] = Matrix.CreateScale(new Vector3(100f, 1f, 100f)) * Matrix.CreateRotationZ(MathHelper.PiOver2) * Matrix.CreateTranslation(Vector3.UnitZ * 100f + Vector3.UnitY * 100f);
// Create Bounding Boxes to enclose the Walls,
// and to test the Robot and Camera against them
WallBoxes = new BoundingBox[5];
var minVector = Vector3.One * 0.25f;
WallBoxes[0] = new BoundingBox(new Vector3(-200f, 0f, -200f) - minVector, new Vector3(200f, 200f, -200f) + minVector);
WallBoxes[1] = new BoundingBox(new Vector3(-200f, 0f, 200f) - minVector, new Vector3(200f, 200f, 200f) + minVector);
WallBoxes[2] = new BoundingBox(new Vector3(200f, 0f, -200f) - minVector, new Vector3(200f, 200f, 200f) + minVector);
WallBoxes[3] = new BoundingBox(new Vector3(-200f, 0f, -200f) - minVector, new Vector3(-200f, 200f, 200f) + minVector);
WallBoxes[4] = new BoundingBox(new Vector3(0f, 0f, 0f) - minVector, new Vector3(0f, 200f, 200f) + minVector);
base.Initialize();
}
public bool TestTerrainCollisionCylinder(IAABBEntity entity, out Vector3 collisionPoint)
{
collisionPoint = Vector3.Zero;
var testBox = GetAABBVelocityBox(entity);
var testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
entity.BoundingBox.Min.DistanceTo(entity.BoundingBox.Max));
bool collision = false;
for (int x = (int)(Math.Floor(testBox.Min.X)); x <= (int)(Math.Ceiling(testBox.Max.X)); x++)
{
for (int z = (int)(Math.Floor(testBox.Min.Z)); z <= (int)(Math.Ceiling(testBox.Max.Z)); z++)
{
for (int y = (int)(Math.Floor(testBox.Min.Y)); y <= (int)(Math.Ceiling(testBox.Max.Y)); y++)
{
var coords = new Coordinates3D(x, y, z);
if (!World.IsValidPosition(coords))
continue;
var _box = BlockPhysicsProvider.GetBoundingBox(World, coords);
if (_box == null)
continue;
var box = _box.Value.OffsetBy(coords);
if (testCylinder.Intersects(box))
{
if (testBox.Intersects(box))
{
collision = true;
AdjustVelocityForCollision(entity, box);
testBox = GetAABBVelocityBox(entity);
testCylinder = new BoundingCylinder(testBox.Min, testBox.Max,
entity.BoundingBox.Min.DistanceTo(entity.BoundingBox.Max));
collisionPoint = coords;
}
}
}
}
}
return collision;
}
public void BoundingCylinder_Equals_Test()
{
BoundingCylinder cyl1 = new BoundingCylinder (sideA: Vector3.Zero, sideB: Vector3.Up * 100, radius: 100f);
BoundingCylinder cyl2 = new BoundingCylinder (sideA: Vector3.Up * 100, sideB: Vector3.Zero, radius: 100f);
IsEqual (cyl1, cyl1);
IsEqual (cyl1, cyl2);
IsEqual (cyl2, cyl1);
BoundingCylinder cyl3 = new BoundingCylinder (sideA: Vector3.Up * 100, sideB: Vector3.Zero, radius: 200f);
IsNotEqual (cyl1, cyl3);
IsNotEqual (cyl2, cyl3);
IsNotEqual (cyl3, cyl1);
IsNotEqual (cyl3, cyl2);
BoundingCylinder cyl4 = new BoundingCylinder (sideA: Vector3.Up * 50, sideB: Vector3.Down * 50, radius: 100f);
IsNotEqual (cyl1, cyl4);
IsNotEqual (cyl2, cyl4);
IsNotEqual (cyl4, cyl1);
IsNotEqual (cyl4, cyl2);
Assert.IsTrue (cyl1.Equals ((object)cyl1));
Assert.IsFalse (cyl1.Equals ((object)cyl4));
Assert.IsFalse (cyl1.Equals ((object)null));
}
public void Move(float x, float y, float z)
{
BoundingCylinder.move(x, y, z);
}
public void Move(TGCVector3 v)
{
BoundingCylinder.move(v);
}
/// <inheritdoc />
public override void Initialize()
{
Game.Background = Color.Black;
// Set the ground flag to false, as the Robot starts in the air
OnGround = false;
// Robot position and matrix initialization
RobotPosition = Vector3.UnitX * 30f;
RobotScale = Matrix.CreateScale(0.3f);
RobotCylinder = new BoundingCylinder(RobotPosition, 10f, 15f);
RobotRotation = Matrix.Identity;
RobotFrontDirection = Vector3.Backward;
// Create the Camera
Camera = new TargetCamera(GraphicsDevice.Viewport.AspectRatio, Vector3.One * 100f, Vector3.Zero);
// Create World matrices for our stairs
StairsWorld = new Matrix[]
{
Matrix.CreateScale(70f, 6f, 15f) * Matrix.CreateTranslation(0f, 3f, 125f),
Matrix.CreateScale(70f, 6f, 15f) * Matrix.CreateTranslation(0f, 9f, 140f),
Matrix.CreateScale(70f, 6f, 15f) * Matrix.CreateTranslation(0f, 15f, 155f),
Matrix.CreateScale(70f, 6f, 40f) * Matrix.CreateTranslation(0f, 21f, 182.5f),
Matrix.CreateScale(15f, 6f, 40f) * Matrix.CreateTranslation(-42.5f, 27f, 182.5f),
Matrix.CreateScale(15f, 6f, 40f) * Matrix.CreateTranslation(-57.5f, 33f, 182.5f),
Matrix.CreateScale(15f, 6f, 40f) * Matrix.CreateTranslation(-72.5f, 39f, 182.5f),
Matrix.CreateScale(100f, 6f, 100f) * Matrix.CreateTranslation(-130f, 45f, 152.5f),
};
// Create World matrices for the Floor and Box
FloorWorld = Matrix.CreateScale(200f, 0.001f, 200f);
BoxWorld = Matrix.CreateScale(30f) * Matrix.CreateTranslation(85f, 15f, -15f);
// Create Bounding Boxes for the static geometries
// Stairs + Floor + Box
Colliders = new BoundingBox[StairsWorld.Length + 2];
// Instantiate Bounding Boxes for the stairs
int index = 0;
for (; index < StairsWorld.Length; index++)
{
Colliders[index] = BoundingVolumesExtensions.FromMatrix(StairsWorld[index]);
}
// Instantiate a BoundingBox for the Box
Colliders[index] = BoundingVolumesExtensions.FromMatrix(BoxWorld);
index++;
// Instantiate a BoundingBox for the Floor. Note that the height is almost zero
Colliders[index] = new BoundingBox(new Vector3(-200f, -0.001f, -200f), new Vector3(200f, 0f, 200f));
// Set the Acceleration (which in this case won't change) to the Gravity pointing down
RobotAcceleration = Vector3.Down * Gravity;
// Initialize the Velocity as zero
RobotVelocity = Vector3.Zero;
base.Initialize();
}
public static float? Intersects(this Ray ray, BoundingCylinder cylinder)
{
Vector3 dirAB = cylinder.SideB - cylinder.SideA;
// Raystart innerhalb des Zylinders
if (Vector3.Cross ((ray.Position - cylinder.SideA), ray.Direction).Length () < cylinder.Radius && !(Vector3.Dot (dirAB, ray.Position - cylinder.SideA) < 0 || Vector3.Dot (dirAB, cylinder.SideB - ray.Position) < 0)) {
return 0.0f;
}
Vector3 perpendicular = Vector3.Cross (dirAB, ray.Direction);
// if !(Ray Parallel zum Zylinder)
if (perpendicular.Length () > 0.0000001f) {
perpendicular.Normalize ();
if (Vector3.Dot (perpendicular, ray.Direction) > 0) {
perpendicular = -perpendicular;
}
Vector3 perpendicular2 = Vector3.Cross (dirAB, perpendicular);
// If (Ray Senkrecht zum Zylinder)
if (perpendicular2.Length () < 0.0000001f) {
if (Vector3.Dot (dirAB, ray.Position - cylinder.SideA) < 0 || Vector3.Dot (dirAB, cylinder.SideB - ray.Position) < 0) {
return null;
}
float? result = Vector3.Cross ((ray.Position - cylinder.SideA), ray.Direction).Length () - cylinder.Radius;
if (result < 0) {
result = 0.0f;
}
return result;
}
if (Vector3.Dot (perpendicular2, ray.Direction) > 0) {
perpendicular2 = -perpendicular2;
}
perpendicular2.Normalize ();
float minDist = System.Math.Abs (Vector3.Dot (cylinder.SideA - ray.Position, perpendicular));
if (minDist > cylinder.Radius) {
return null;
}
Vector3 plainNorm = perpendicular * minDist + (float)System.Math.Sqrt (cylinder.Radius * cylinder.Radius - minDist * minDist) * perpendicular2;
plainNorm.Normalize ();
float? other_result = ray.Intersects (new Plane (plainNorm, Vector3.Dot (plainNorm, cylinder.SideA + plainNorm * cylinder.Radius)));
if (other_result == null) {
return null;
}
Vector3 cutA = ray.Position + ray.Direction * (float)other_result - cylinder.SideA;
Vector3 cutB = ray.Position + ray.Direction * (float)other_result - cylinder.SideB;
if (Vector3.Dot (dirAB, cutA) > 0 && Vector3.Dot (-dirAB, cutB) > 0) {
return other_result;
}
}
if (Vector3.Distance (ray.Position, cylinder.SideA) < Vector3.Distance (ray.Position, cylinder.SideB)) {
dirAB.Normalize ();
float? result = ray.Intersects (new Plane (dirAB, Vector3.Dot (dirAB, cylinder.SideA)));
if (result == null || Vector3.Distance (ray.Position + ray.Direction * (float)result, cylinder.SideA) > cylinder.Radius) {
return null;
}
return result;
}
else {
dirAB.Normalize ();
dirAB = -dirAB;
float? result = ray.Intersects (new Plane (dirAB, Vector3.Dot (dirAB, cylinder.SideB)));
if (result == null || Vector3.Distance (ray.Position + ray.Direction * (float)result, cylinder.SideB) > cylinder.Radius) {
return null;
}
return result;
}
/*
Vector3 diffA = capsule.CornerA - ray.Position;
Vector3 diffB = capsule.CornerB - ray.Position;
float diffASquared = diffA.LengthSquared ();
float diffBSquared = diffB.LengthSquared ();
float radiusSquared = capsule.Radius * capsule.Radius;
// Startpunkt innerhalb der Eckkugeln
if (diffASquared < radiusSquared || diffBSquared < radiusSquared)
{
return 0.0f;
}
Vector3 dirBA = (capsule.CornerA - capsule.CornerB);
float distAlongAB = Vector3.Dot (diffA, dirBA) / dirBA.Length ();
// Startpunkt innerhalb des Zylinders
if (distAlongAB > 0 && distAlongAB < dirBA.Length () && (distAlongAB * distAlongAB + radiusSquared - diffA.LengthSquared () < 0))
{
return 0.0f;
}
float distAlongRayA = Vector3.Dot (ray.Direction, diffA);
float distAlongRayB = Vector3.Dot (ray.Direction, diffB);
// Richtung geht weg von der Kapsel
if (distAlongRayA < 0 && distAlongRayB < 0)
return null;
Vector3 perpendicular = Vector3.Cross (ray.Direction, dirBA);
perpendicular.Normalize ();
float minDistance = Math.Abs (Vector3.Dot (diffA, perpendicular));
// Kommt selbst der Geraden nie nahe genug.
if (minDistance > capsule.Radius)
{
return null;
}
Vector3 normDirAB = -dirBA;
normDirAB.Normalize ();
Vector3 extensionToBase = Vector3.Cross (normDirAB, perpendicular);
extensionToBase.Normalize ();
Matrix transformation = new Matrix (normDirAB.X, normDirAB.Y, normDirAB.Z, 0, perpendicular.X, perpendicular.Y, perpendicular.Z, 0, extensionToBase.X, extensionToBase.Y, extensionToBase.Z, 0, capsule.CornerA.X, capsule.CornerA.Y, capsule.CornerA.Z, 1);
transformation = Matrix.Invert (transformation);
*/
}
private void IsEqual(BoundingCylinder a, BoundingCylinder b)
{
Assert.IsTrue (a.Equals (b));
Assert.IsTrue (a == b);
}
private void IsNotEqual(BoundingCylinder a, BoundingCylinder b)
{
Assert.IsTrue (!a.Equals (b));
Assert.IsTrue (a != b);
}
public void rotateY(float angle)
{
BoundingCylinder.rotateY(angle);
}
public void RotateZ(float angle)
{
BoundingCylinder.rotateZ(angle);
}
/// <summary>
/// Adds a cylinder obstacle
/// </summary>
/// <param name="cylinder">Bounding Cylinder</param>
/// <returns>Returns the obstacle id</returns>
public int AddObstacle(BoundingCylinder cylinder)
{
return(-1);
}
public void Start()
{
string ip = ((IPEndPoint)Socket.RemoteEndPoint).Address.ToString();
Console.WriteLine("Client connected from {0}", ip);
var packet = new NetworkPacket();
Vector3 leprechaunPosition = Server.Terrain.GetHeight(Config.PlayerPositions[PlayerId]);
try
{
Send(new NetworkPacketWelcome(PlayerId, Config.PlayerColors[PlayerId], leprechaunPosition, Config.RainbowPositions[PlayerId]));
Server.ItemsManager.SendAll(this);
Server.TrapManager.AddPlayer(this);
const float goldpotRadius = Config.GoldpotCylinderRadius * Config.GoldpotScale;
const float goldpotHeight = Config.GoldpotCylinderHeight * Config.GoldpotScale;
Rainbow = new BoundingCylinder(Config.RainbowCylinderRadius, Config.RainbowCylinderHeight, Config.RainbowPositions[PlayerId]);
Goldpot = new BoundingCylinder(goldpotRadius, goldpotHeight, Config.GoldpotPosition);
var buffer = new byte[Config.BufferSize];
while (true)
{
if (Socket.Receive(buffer, 1, SocketFlags.None) == 0)
{
return;
}
packet.Type = buffer[0];
if (Socket.Receive(buffer, 1, SocketFlags.None) == 0)
{
return;
}
packet.Size = buffer[0];
int received = 0;
while (received < packet.Size)
{
int count;
if ((count = Socket.Receive(packet.Data, received, packet.Size - received, SocketFlags.None)) == 0)
{
return;
}
received += count;
}
ProcessPacket(packet);
Server.Send(packet, this);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
Console.WriteLine("Client disconnected from {0}", ip);
Server.OnClientFinish(this);
}
}
public void move(Vector3 v)
{
BoundingCylinder.move(v);
}