internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum8 <PartType>(br.Position + br.VarintSize);
switch (type)
{
case PartType.MapPiece:
return(MapPieces.EchoAdd(new Part.MapPiece(br)));
case PartType.Object:
return(Objects.EchoAdd(new Part.Object(br)));
case PartType.Collision:
return(Collisions.EchoAdd(new Part.Collision(br)));
case PartType.Navmesh:
return(Navmeshes.EchoAdd(new Part.Navmesh(br)));
case PartType.ConnectCollision:
return(ConnectCollisions.EchoAdd(new Part.ConnectCollision(br)));
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
protected void OnCollisionStay(Collision collision)
{
if (Collisions.ContainsKey(collision.collider))
{
Collisions[collision.collider] = collision;
}
}
protected void OnCollisionExit(Collision collision)
{
if (Collisions.ContainsKey(collision.collider))
{
Collisions.Remove(collision.collider);
}
}
public Position()
{
Collision = Collisions.Flip;
My = WindowPositions.Center;
At = WindowPositions.Center;
Of = null;
}
public override void Render()
{
Vector3 eyePos = new Vector3();
eyePos.X = cameraAngle.Z * -(float)System.Math.Sin(cameraAngle.X * rads * (float)System.Math.Cos(cameraAngle.Y * rads));
eyePos.Y = cameraAngle.Z * -(float)System.Math.Sin(cameraAngle.Y * rads);
eyePos.Z = -cameraAngle.Z * (float)System.Math.Cos(cameraAngle.X * rads * (float)System.Math.Cos(cameraAngle.Y * rads));
Matrix4 lookAt = Matrix4.LookAt(eyePos, new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f));
GL.LoadMatrix(Matrix4.Transpose(lookAt).Matrix);
GL.Color3(1f, 0f, 1f);
testLine.Render();
foreach (Point point in testPoints)
{
if (Collisions.PointOnLine(point, testLine))
{
GL.Color3(1f, 0f, 0f);
}
else
{
GL.Color3(0f, 0f, 1f);
}
point.Render();
}
}
//bvh Raycast
public static bool RaycastBVH(Ray ray, BVHNode node, out float t)
{
//check if it hits model AABB even
if (!RaycastAABB(ray, node.AABB, out t))
{
return(false);
}
//loop through children and recursively raycast
if (node.Children != null)
{
foreach (BVHNode child in node.Children)
{
if (RaycastBVH(ray, child, out t))
{
return(true);
}
}
}
//if leaf node, raycast against triangles
if (node.Triangles != null)
{
foreach (Triangle triangle in node.Triangles)
{
if (Collisions.RaycastTriangle(ray, triangle, out t))
{
return(true);
}
}
}
//return false by default
return(false);
}
private void Vacuum()
{
// set suck speed based on the distance between player and blackhole( Clamped to prevent division by 0)
suckSpeed = 75 / Mathf.Clamp(Vector.Magnitude(sphere.center - playerSphere.center), 1f, float.PositiveInfinity);
// set suck rotation speed based on the distance between player and blackhole( Clamped to prevent division by 0)
suckRotationSpeed = 1000 / Mathf.Clamp(Vector.Magnitude(sphere.center - playerSphere.center), 1f, float.PositiveInfinity);
// If collide with player
if (Collisions.SphereInSphere(playerSphere, sphere))
{
// If player is at center of blackhole
if (Vector.Magnitude(sphere.center - playerSphere.center) <= 1f)
{
Player.hasDied = true;
}
playerScript.isInBlackHole = true;
// Spin the player
playerScript.Rotation += new Vector(0, 0, 1 * suckRotationSpeed * Time.deltaTime);
playerGO.transform.eulerAngles = Helper.ConvertMyVectorToUnityVector(playerScript.Rotation);
// Suck the player inside
playerGO.transform.position = Helper.ConvertMyVectorToUnityVector(Vector.MoveTowards(Helper.ConvertUnityVectorToMyVector(playerGO.transform.position),
Helper.ConvertUnityVectorToMyVector(transform.position), suckSpeed * Time.deltaTime));
}
else
{
playerScript.isInBlackHole = false;
}
}
public void SmallBoxCompletelyInsideBigBox()
{
e2.Size = new Vector2(5, 5);
e2.Get <Component_Collision_AABox>()._offsetSize = new Vector2(5, 5);
e2.MoveBy(e1.Size / 2);
Assert.IsTrue(Collisions.EntitiesCollide(e1, e2));
}
void Update()
{
scale = Helper.ConvertUnityVectorToMyVector(transform.localScale);
rotation = Helper.ConvertUnityVectorToMyVector(transform.eulerAngles);
center = Helper.ConvertUnityVectorToMyVector(transform.position);
//forwardVector = Helper.ConvertUnityVectorToMyVector(transform.forward);
transform.eulerAngles = Helper.ConvertMyVectorToUnityVector(rotation);
transform.localScale = Helper.ConvertMyVectorToUnityVector(scale);
Movement();
if (Collisions.SphereInSphere(planetSphere, collider.Sphere))
{
hasWon = true;
}
for (int i = 0; i < transform.childCount; i++)
{
if (Collisions.PointInSphere(Helper.ConvertUnityVectorToMyVector(transform.GetChild(i).position), planetSphere))
{
hasDied = true;
}
}
}
public override void Render()
{
base.Render();
DrawOrigin();
GL.Color3(1f, 1f, 1f);
test.Render();
float t;
foreach (Ray ray in rays)
{
if (Collisions.RaycastTriangle(ray, test, out t))
{
Point colPoint = new Point();
Collisions.RaycastTriangle(ray, test, out colPoint);
GL.Color3(0f, 1f, 0f);
colPoint.Render();
GL.Color3(1f, 0f, 0f);
}
else
{
GL.Color3(0f, 0f, 1f);
}
ray.Render();
}
}
override public void Update(Player player, Tile[][] tiles)
{
newLocation = location;
if (facing == "right")
{
newLocation.X += 2;
}
else if (facing == "left")
{
newLocation.X -= 2;
}
if (Collisions.CollideWithTiles(tiles, this))
{
if (facing == "right")
{
facing = "left";
}
else if (facing == "left")
{
facing = "right";
}
}
location = newLocation;
hitBox = new Rectangle((int)location.X, (int)location.Y, width, height);
base.Update(player, tiles);
}
void Start()
{
// Get the collisions component
coll = GetComponent <Collisions>();
// Get the playerController component
playerController = GetComponent <PlayerController>();
}
public override void Render()
{
base.Render();
DrawOrigin();
Point result = new Point();
foreach (Line line in lines)
{
if (Collisions.LinecastTriangle(line, triangle, out result))
{
GL.Color3(1f, 0f, 1f);
result.Render();
GL.Color3(0f, 2f, 0f);
}
else
{
GL.Color3(1f, 0f, 0f);
}
line.Render();
}
GL.Color3(0f, 0f, 1f);
triangle.Render();
}
void Start()
{
anim = GetComponent <Animator>();
player = GetComponent <PlayerController>();
coll = GetComponent <Collisions>();
sr = GetComponent <SpriteRenderer>();
}
/// <summary>
/// Adds a part to the appropriate list for its type; returns the part.
/// </summary>
public Part Add(Part part)
{
switch (part)
{
case Part.MapPiece p: MapPieces.Add(p); break;
case Part.Object p: Objects.Add(p); break;
case Part.Enemy p: Enemies.Add(p); break;
case Part.Player p: Players.Add(p); break;
case Part.Collision p: Collisions.Add(p); break;
case Part.Protoboss p: Protobosses.Add(p); break;
case Part.Navmesh p: Navmeshes.Add(p); break;
case Part.DummyObject p: DummyObjects.Add(p); break;
case Part.DummyEnemy p: DummyEnemies.Add(p); break;
case Part.ConnectCollision p: ConnectCollisions.Add(p); break;
default:
throw new ArgumentException($"Unrecognized type {part.GetType()}.", nameof(part));
}
return(part);
}
internal override Model ReadEntry(BinaryReaderEx br)
{
ModelType type = br.GetEnum32 <ModelType>(br.Position + 8);
switch (type)
{
case ModelType.MapPiece:
return(MapPieces.EchoAdd(new Model.MapPiece(br)));
case ModelType.Object:
return(Objects.EchoAdd(new Model.Object(br)));
case ModelType.Enemy:
return(Enemies.EchoAdd(new Model.Enemy(br)));
case ModelType.Item:
return(Items.EchoAdd(new Model.Item(br)));
case ModelType.Player:
return(Players.EchoAdd(new Model.Player(br)));
case ModelType.Collision:
return(Collisions.EchoAdd(new Model.Collision(br)));
case ModelType.Navmesh:
return(Navmeshes.EchoAdd(new Model.Navmesh(br)));
case ModelType.Other:
return(Others.EchoAdd(new Model.Other(br)));
default:
throw new NotImplementedException($"Unimplemented model type: {type}");
}
}
/* ------------------------------------------------ MONOBEHAVIOUR METHODS ------------------------------------------------ */
void Start()
{
rb = GetComponent <Rigidbody>();
coll = GetComponent <Collisions>();
input = GetComponent <PlayerInput>();
initialPos = rb.position;
}
public GameLogic(LevelAttempt levelAttempt)
{
this.levelAttempt = levelAttempt;
gamePhysics = new GamePhysics(levelAttempt.Level);
collisions = new Collisions(levelAttempt.Level);
}
public void Add(IMsbPart item)
{
switch (item)
{
case Part.MapPiece m:
MapPieces.Add(m);
break;
case Part.Object m:
Objects.Add(m);
break;
case Part.Collision m:
Collisions.Add(m);
break;
case Part.Navmesh m:
Navmeshes.Add(m);
break;
case Part.ConnectCollision m:
ConnectCollisions.Add(m);
break;
default:
throw new ArgumentException(
message: "Item is not recognized",
paramName: nameof(item));
}
}
public int Render(Plane[] frustum)
{
int total = 0;
//render logic
if (!Collisions.Intersects(frustum, Bounds))
{
return(0);
}
if (Contents != null)
{
foreach (OBJ content in Contents)
{
content.NonRecursiveRender(frustum);
total++;
}
}
//recurse through all children
if (Children != null)
{
foreach (OctreeNode child in Children)
{
total += child.Render(frustum);
}
}
return(total);
}
/// <summary>
/// Check for Cuboid and Sphere
/// </summary>
/// <param name="_coll1"></param>
/// <param name="_coll2"></param>
/// <returns></returns>
private MyCollider CheckForCub_Sph(MyCollider _coll1, MyCollider _coll2)
{
if (_coll1 is MyBoxCollider && _coll2 is MySphereCollider)
{
if (Collisions.CuboidInSphere((Cuboid)_coll1.Get(), (Sphere)_coll2.Get()))
{
return(_coll1);
}
else
{
return(null);
}
}
else
if (_coll1 is MySphereCollider && _coll2 is MyBoxCollider)
{
if (Collisions.CuboidInSphere((Cuboid)_coll2.Get(), (Sphere)_coll1.Get()))
{
return(_coll1);
}
else
{
return(null);
}
}
else
{
throw new System.Exception("Es müssen zwei verschiedene MyCollider in <CheckForCub_Sph> angewendet werden");
}
}
public void update(GameTime gameTime, Game1 game, ContentManager content, Camera2D cam)
{
deltaTime += (float)gameTime.ElapsedGameTime.TotalSeconds;
if (WINpos.X <= cam.Position.X - 350 && NERpos.X > cam.Position.X)
{
inAnimation = true;
WINpos = new Vector2(WINpos.X + 10, WINpos.Y);
NERpos = new Vector2(NERpos.X - 10, NERpos.Y);
}
else
{
inAnimation = false;
}
if (Input.IsPressed(Keys.Enter) && inAnimation == false)
{
CharactersHandler.Players.Clear();
Collisions.reset();
Game1.firstEntry = true;
MenuCharacterChoose.resetArrays(content);
MenuCharacterChoose.resetPlayerInserted();
CharactersHandler.JogadorActivo = 0;
CharactersHandler.initialPlayer = 0;
game.gameState = Game1.GameState.Menu;
}
}
public virtual void CheckEnemyVausTwinCollision()
{
if (!PlayArena.Vaus.IsTwin)
{
return;
}
if (!IsAlive || IsExploding)
{
return;
}
Direction d;
CollisionPoint c;
if (!Collisions.IsCollision(this, PlayArena.Vaus.Twin, out d, out c))
{
return;
}
var vtop = new Rectangle(PlayArena.Vaus.Twin.Bounds.X, PlayArena.Vaus.Twin.Bounds.Y,
PlayArena.Vaus.Twin.Bounds.Width, PlayArena.Vaus.Twin.Bounds.Height / 2);
var vbottom = new Rectangle(PlayArena.Vaus.Twin.Bounds.X,
PlayArena.Vaus.Twin.Bounds.Y + PlayArena.Vaus.Twin.Bounds.Height / 2,
PlayArena.Vaus.Twin.Bounds.Width, PlayArena.Vaus.Twin.Bounds.Height / 2);
if (Collisions.IsCollision(vtop, Bounds))
{
PlayArena.Vaus.RemovePower();
Die();
}
else if (Collisions.IsCollision(vbottom, Bounds))
{
PlayArena.Vaus.Twin.Die();
Die();
}
}
public override void RenderFrame(Graphics g, int delta)
{
UpdateGameTime(delta);
g.SmoothingMode = SmoothingMode.HighQuality;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
RenderBackground(g);
float progress = Clamp((gameTime - lastCountdownTime) / R.MENU_STARTCOUNTDOWN);
if (drawCountDown)
{
float ii = progress * 3;
DrawCentredString(g, (new string[] { "3", "2", "1!" })[(int)Clamp(ii, 0, 2)], zonePos, R.MENU_UI_FONTSIZE, Color.FromArgb((int)(255 * (1 - ii % 1)), R.SAFEAREA_SCORECOLOUR));
}
bool pDrawCountDown = drawCountDown;
drawCountDown = false;
CountdownWorker(g, progress);
for (int i = 0; i < players.Count; i++)
{
Player p = players[i];
p.Ball.UpdateElement(delta, p.Controller.GetState().Gamepad);
p.Ball.DrawElement(g);
Collisions.CollisionWorker(p);
}
if (pDrawCountDown)
{
float ii = progress * 3;
DrawCentredString(g, (new string[] { "3", "2", "1!" })[(int)Clamp(ii, 0, 2)], zonePos, R.MENU_UI_FONTSIZE, Color.FromArgb((int)(zoneAlpha * 255 * (1 - ii % 1)), R.SAFEAREA_SCORECOLOUR));
}
}
internal override Model ReadEntry(BinaryReaderEx br)
{
ModelType type = br.GetEnum32 <ModelType>(br.Position + 4);
var model = new Model(br);
if (type == ModelType.MapPiece)
{
MapPieces.Add(model);
}
else if (type == ModelType.Object)
{
Objects.Add(model);
}
else if (type == ModelType.Enemy)
{
Enemies.Add(model);
}
else if (type == ModelType.Player)
{
Players.Add(model);
}
else if (type == ModelType.Collision)
{
Collisions.Add(model);
}
else if (type == ModelType.Navmesh)
{
Navmeshes.Add(model);
}
else
{
throw new NotImplementedException($"Unimplemented model type: {type}");
}
return(model);
}
/// <summary>
/// Adds a model to the appropriate list for its type; returns the model.
/// </summary>
public Model Add(Model model)
{
switch (model)
{
case Model.MapPiece m: MapPieces.Add(m); break;
case Model.Object m: Objects.Add(m); break;
case Model.Enemy m: Enemies.Add(m); break;
case Model.Item m: Items.Add(m); break;
case Model.Player m: Players.Add(m); break;
case Model.Collision m: Collisions.Add(m); break;
case Model.Navmesh m: Navmeshes.Add(m); break;
case Model.Other m: Others.Add(m); break;
default:
throw new ArgumentException($"Unrecognized type {model.GetType()}.", nameof(model));
}
return(model);
}
internal override Part ReadEntry(BinaryReaderEx br)
{
PartType type = br.GetEnum16 <PartType>(br.Position + 8);
switch (type)
{
case PartType.MapPiece:
var mapPiece = new Part.MapPiece(br);
MapPieces.Add(mapPiece);
return(mapPiece);
case PartType.Object:
var obj = new Part.Object(br);
Objects.Add(obj);
return(obj);
case PartType.Collision:
var collision = new Part.Collision(br);
Collisions.Add(collision);
return(collision);
case PartType.Navmesh:
var navmesh = new Part.Navmesh(br);
Navmeshes.Add(navmesh);
return(navmesh);
case PartType.ConnectCollision:
var connectCollision = new Part.ConnectCollision(br);
ConnectCollisions.Add(connectCollision);
return(connectCollision);
default:
throw new NotImplementedException($"Unimplemented part type: {type}");
}
}
public override void Initialize(int width, int height)
{
GL.Enable(EnableCap.DepthTest);
GL.PointSize(4f);
Point p1 = new Point(0, 0, 0);
Point p2 = new Point(0, 0, 0);
LogError("Points equal: " + (p1.X == p2.X && p1.Y == p2.Y && p1.Z == p2.Z));
LogError("Points equal: " + (p1 == p2));
for (int i = 0; i < 3; ++i)
{
if (!Collisions.PointOnRay(testPoints[i], testRay))
{
System.Console.ForegroundColor = System.ConsoleColor.Red;
System.Console.WriteLine("Expected point: " + testPoints[i].ToString() + " to be on Ray!");
}
}
for (int i = 3; i < testPoints.Length; ++i)
{
if (Collisions.PointOnRay(testPoints[i], testRay))
{
System.Console.ForegroundColor = System.ConsoleColor.Red;
System.Console.WriteLine("Expected point: " + testPoints[i].ToString() + " to NOT be on Ray!");
}
}
}
public void Add(IMsbModel item)
{
var m = (Model)item;
switch (m.Type)
{
case ModelType.MapPiece:
MapPieces.Add(m);
break;
case ModelType.Object:
Objects.Add(m);
break;
case ModelType.Collision:
Collisions.Add(m);
break;
case ModelType.Navmesh:
Navmeshes.Add(m);
break;
default:
throw new ArgumentException(
message: "Item is not recognized",
paramName: nameof(item));
}
}
internal override Model ReadEntry(BinaryReaderEx br)
{
var model = new Model(br);
switch (model.Type)
{
case ModelType.MapPiece:
MapPieces.Add(model);
return(model);
case ModelType.Object:
Objects.Add(model);
return(model);
case ModelType.Collision:
Collisions.Add(model);
return(model);
case ModelType.Navmesh:
Navmeshes.Add(model);
return(model);
default:
throw new NotImplementedException($"Unimplemented model type: {model.Type}");
}
}
public override bool ActivateBlock(Microsoft.Xna.Framework.Vector2 direction, Collisions.ICollidable ob)
{
if(SprintFourGame.GetInstance().CurrentGameState != SprintFourGame.GameState.Winning)
SprintFourGame.GetInstance().ChangeToWinning(Block);
return true;
}
static extern void btSoftBody_Config_setCollisions(IntPtr obj, Collisions value);
