public void Operator_isInside_ReturnsFalse()
{
var cube = new Cubes.Cube(new Point(0, 0, 0), 1);
var point = new Point(2, 2, 2);
var result = Operators.IsInside(cube, point);
Assert.IsFalse(result);
}
public void Operator_cubeIntersec_ReturnsBoxWithVolume()
{
var cubes = new Cubes.Cube[2]
{
new Cubes.Cube(new Point(1, 1, 1), 4),
new Cubes.Cube(new Point(-1, -1, -1), 3)
};
var result = Operators.CubeIntersec(cubes[0], cubes[1]);
Assert.GreaterOrEqual(result.Volume(), 0);
}
public void Operator_cubeIntersec_ReturnsNull()
{
var cubes = new Cubes.Cube[2]
{
new Cubes.Cube(new Point(1, 1, 1), 1),
new Cubes.Cube(new Point(-1, -1, -1), 1)
};
var result = Operators.CubeIntersec(cubes[0], cubes[1]);
Assert.IsNull(result);
}
public void I3dObject_Volume_NonNegative()
{
bool failed = false;
for (int i = 0; i < 100; i++)
{
var object1 = new Cubes.Cube(new Point(new Random().NextDouble(), new Random().NextDouble(), new Random().NextDouble()), new Random().NextDouble());
if (object1.Volume() < 0)
{
failed = true; break;
}
}
Assert.IsFalse(failed);
}
static void GenerateCubes(int edgeIndex)
{
if (edgeIndex == Cube.EDGE_COUNT)
{
Cube cube = new Cube(currentEdges);
if (isomorphicCubes.Contains(cube))
{
return;
}
for (int i = 0; i < 4; i++)
{
cube.RotateXY();
for (int j = 0; j < 4; j++)
{
cube.RotateXZ();
for (int k = 0; k < 4; k++)
{
cube.RotateYZ();
isomorphicCubes.Add(new Cube(cube));
}
}
}
cubesCount++;
//Console.WriteLine(cube);
return;
}
for (int color = 1; color <= Cube.MAX_COLOR; color++)
{
if (colorsLeftCount[color] > 0)
{
colorsLeftCount[color]--;
currentEdges[edgeIndex] = color;
GenerateCubes(edgeIndex + 1);
colorsLeftCount[color]++;
}
}
}
public void I3dObject_minDimension_maxDimension()
{
bool failed = false;
for (int i = 0; i < 100; i++)
{
var object1 = new Cubes.Cube(new Point(new Random().NextDouble(), new Random().NextDouble(), new Random().NextDouble()), new Random().NextDouble());
if (object1.MinDimension(Dimension.Axis.x) > object1.MaxDimension(Dimension.Axis.x))
{
failed = true; break;
}
if (object1.MinDimension(Dimension.Axis.y) > object1.MaxDimension(Dimension.Axis.y))
{
failed = true; break;
}
if (object1.MinDimension(Dimension.Axis.z) > object1.MaxDimension(Dimension.Axis.z))
{
failed = true; break;
}
}
Assert.IsFalse(failed);
}
/// <summary>
/// checkHookCubeCollision checks wheter the magnet collides with a cube.
/// True: the magnet collides with a cube
/// False: the manget does not collide with a cube
/// </summary>
/// <param name="cube"></param>
/// <returns></returns>
private bool checkHookCubeCollision(Cube cube)
{
BoundingSphere hookSphere = TransformBoundingSphere((BoundingSphere)theHook.Model.Tag, theHook.World);
BoundingBox cubeSphere = TransformBoundingBox((BoundingSphere)cube.Model.Tag, cube.World);
if (hookSphere.Intersects(cubeSphere))
return true;
else
return false;
}
/// <summary>
/// checkCubeCollision check wheter the cubes collide.
/// True: the cubes collide
/// False: the cubes do not collide.
/// </summary>
/// <param name="cube1"></param>
/// <param name="cube2"></param>
/// <returns></returns>
private bool checkCubeCollision(Cube cube1, Cube cube2)
{
BoundingBox cube1Sphere = TransformBoundingBox((BoundingSphere)cube1.Model.Tag, cube1.World);
BoundingBox cube2Sphere = TransformBoundingBox((BoundingSphere)cube2.Model.Tag, cube2.World);
if (cube1Sphere.Intersects(cube2Sphere))
return true;
else
return false;
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
#region Keyboard input
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
#region Keyboar logic
//Oppretter kuber i et tilfeldig sted
if (input.KeyboardState.IsKeyDown(Keys.T) && input.KeyboardState != oldState)
{
Random rnd = new Random();
//Cube tmp = new Cube(this, new Vector3(rnd.Next(-70, 70), rnd.Next(-70, 70), rnd.Next(-70, 70)), effect);
Cube tmp = new Cube(this, new Vector3(50, 50, 0), effect);
tmp.TextureSide = Content.Load<Texture2D>("Textures\\Cube-side");
tmp.TextureTop = Content.Load<Texture2D>("Textures\\Cube-topbottom");
tmp.Model = LoadModel("Models\\Cube2");
this.Components.Add(tmp);
theCubeList.Add(tmp);
}
if (input.KeyboardState.IsKeyDown(Keys.H) && input.KeyboardState != oldState)
{
showHelp = !showHelp;
}
#endregion
if (input.KeyboardState.IsKeyDown(Keys.Y) && input.KeyboardState != oldState)
{
theCubeList.Clear();
}
#endregion
#region Kubenes kollisjonsdeteksjonalgoritme
foreach (Cube c1 in theCubeList)
{
List<Cube> collideList = new List<Cube>();
float lowY = c1.World.Translation.Y;
if (theHook.Active && !c1.Hooked && !theHook.HasBlock)
{
c1.Hooked = theHook.HasBlock = checkHookCubeCollision(c1);
}
else if (!theHook.Active)
{
c1.Hooked = false;
}
foreach (Cube c2 in theCubeList)
{
if (!c1.Equals(c2))
{
if (checkCubeCollision(c1, c2))
{
Vector3 c1Pos = c1.World.Translation;
Vector3 c2Pos = c2.World.Translation;
if (c1Pos.Y < c2Pos.Y && !c1.Hooked && !c2.Hooked)
{
collideList.Add(c2);
foreach (Cube cLow in collideList)
{
if (cLow.World.Translation.Y < lowY)
{
lowY = cLow.World.Translation.Y;
}
}
if (c1.World.Translation.Y > lowY)
{
c1.Move = true;
break;
}
}
else
{
c1.Move = false;
c1.FallSpeed = 0;
break;
}
}
else
{
c1.Move = true;
}
}
}
}
#endregion
oldState = input.KeyboardState;
base.Update(gameTime);
}
public Cube(Cube cube)
: this()
{
Array.Copy(cube.edges, this.edges, EDGE_COUNT);
}
public static float volumeCollision(float l1, Cube cube1, float l2, Cube cube2)
{
float volume;
List <float> heigth;
float segment;
List <float[, ]> numCollisionAB = pointsInsideCube(cube1, cube2);
List <float[, ]> numCollisionBA = pointsInsideCube(cube2, cube1);
List <float> deltas = new List <float>();
List <float[, ]> numCollision = new List <float[, ]>();
List <float[, ]> numNotColision = new List <float[, ]>();
Cube cube = new Cube(0, 0, 0, 0);
if (numCollisionAB.Count == 0 && numCollisionBA.Count == 0) //both are outside
{
volume = 0;
}
else if (numCollisionAB.Count == 8 && numCollisionBA.Count == 8)//both are the same cube
{
volume = l1 * l1 * l1;
}
else
{
if (numCollisionAB.Count == 8) // cube1 inside cube2
{
volume = l1 * l1 * l1;
}
else if (numCollisionBA.Count == 8) // cube2 inside cube1
{
volume = l2 * l2 * l2;
}
else//partial collision 1,2 or 4 points inside 1 cube into the other IMPORTANT cubes are parallel;
{
if (numCollisionAB.Count > numCollisionBA.Count)// cube1 smaller than cube2
{
numCollision = numCollisionAB;
numNotColision = cube1.pointsCube.Where(item => !numCollision.Any(i => i == item)).ToList();
cube = cube2;
}
else if (numCollisionAB.Count == numCollisionBA.Count)//point inside each cube
{
numCollision.Add(numCollisionAB[0]);
numCollision.Add(numCollisionBA[0]);
numNotColision = cube1.pointsCube.Where(item => !numCollision.Any(i => i == item)).ToList();
cube = cube1;
}
else// cube2 smaller than cube1
{
numCollision = numCollisionBA;
numNotColision = cube2.pointsCube.Where(item => !numCollision.Any(i => i == item)).ToList();
cube = cube1;
}
deltas = Geometry.getDeltas(numCollision);
segment = (float)Math.Sqrt(deltas[0] * deltas[0] + deltas[1] * deltas[1] + deltas[2] * deltas[2]);
if (numCollisionAB.Count == 4 || numCollisionBA.Count == 4)//plane inside big cube
{
heigth = heights(cube, segment, numCollision, numNotColision);
volume = segment * segment * heigth[0];
}
else if ((numCollisionAB.Count == 2 || numCollisionBA.Count == 2) && (numCollisionAB.Count != 1 && numCollisionBA.Count != 1))//line inside big cube
{
heigth = heights(cube, segment, numCollision, numNotColision);
volume = segment * heigth[0] * heigth[1];
}
else//point inside cube
{//volume usign diagonal points
volume = (float)Math.Pow((segment / (float)Math.Sqrt(3)), 3);
}
}
}
return(volume);
}
