public Rectangle GetProductRectangle(PlacedProduct product, float width, float height, float size)
{
Rectangle rectangle;
if (product.Product.Size.IsEmpty)
{
// this is a product that came from the algorithm
rectangle = new Rectangle
{
Height = (int) (product.Product.Height/size*height),
Width = (int) (product.Product.Width/size*width),
X = (int) (product.Location.X/size*width),
Y = (int) (product.Location.Y/size*height)
};
}
else
{
rectangle = new Rectangle
{
Height = (int) (product.Product.Size.Height/size*height),
Width = (int) (product.Product.Size.Width/size*width),
X = (int) (product.Location.X/size*width),
Y = (int) (product.Location.Y/size*height)
};
}
return rectangle;
}
public void rotation_setAngle_90()
{
//Make
PointF point = new PointF(200, 200);
ProductModel product = new ProductModel(10, 10, 50);
PlacedProduct placedP = new PlacedProduct(product, point);
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X + product.Width / 2, point.Y - product.Length / 2); //now the top right
pointCorner[1] = new PointF(point.X + product.Width / 2, point.Y + product.Length / 2); //now the lower right
pointCorner[2] = new PointF(point.X - product.Width / 2, point.Y + product.Length / 2); //now the lower left
pointCorner[3] = new PointF(point.X - product.Width / 2, point.Y - product.Length / 2); //now the top left
//Do
placedP.SetAngle(90);
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product has changed!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product has changed!");
for (int index = 0; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
public void CountProductsAmountPlaced(PlacedProduct product)
{
// get the current product
ProductModel productMod = product.Product;
// use method overload
CountProductsAmountPlaced(productMod);
}
public void rotation_setAngle_45()
{
//Make
PointF point = new PointF(200, 200);
ProductModel product = new ProductModel(10, 10, 50);
PlacedProduct placedP = new PlacedProduct(product, point);
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X, point.Y - (float)Math.Sqrt(50)); //{200 ; 200-√50}
pointCorner[1] = new PointF(point.X + (float)Math.Sqrt(50), point.Y); //{200+√50 ; 200}
pointCorner[2] = new PointF(point.X, point.Y + (float)Math.Sqrt(50)); //{200 ; 200+√50}
pointCorner[3] = new PointF(point.X - (float)Math.Sqrt(50), point.Y); //{200-√50 ; 200}
/*
Coordinate = {(centerlocation) (direction + or -) (size/2)}
Point 0 = Top Left
{200-(10/2) ; 200-(10/2)} = {195 ; 195}
Point 1 = Top Right
{200+(10/2) ; 200-(10/2)} = {205 ; 195}
Point 2 = Lower Right
{200+(10/2) ; 200+(10/2)} = {205 ; 205}
Point 3 = Lower Left
{200-(10/2) ; 200+(10/2)} = {195 ; 205}
Do some math, and when the square turns 45 degrees, the points are the following:
[0] = {200 ; 200-√50}
[1] = {200+√50 ; 200}
[2] = {200 ; 200+√50}
[3] = {200-√50 ; 200}
*/
//Do
placedP.SetAngle(45);
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product has changed!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product has changed!");
for (int index = 0; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
public void collision_MoveCollision()
{
//Move -> Collision
//Move X+50, Y+0
//Move X+50, Y+0 - can't move all the way because collision, so only X+30
//Make
PointF point = new PointF(200, 200); //Right end = 350 (200+150)
PointF pointWall = new PointF(440, 200); //Left end = 430 (440-10)
ProductModel product = new ProductModel(100, 300, 50); //Width = 300, so it's 150 + 150
ProductModel productWall = new ProductModel(20, 20, 50); //Width = 20, so it's 10 + 10
PlacedProduct placedP = new PlacedProduct(product, point);
PlacedProduct placedWall = new PlacedProduct(productWall, pointWall);
PlacementController.placedProductList.Add(placedP);
PlacementController.placedProductList.Add(placedWall);
int move_x = 60;
int move_y = 0;
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X - (product.Width / 2) + move_x, point.Y - (product.Length / 2) + move_y); //{205 ; 195}
pointCorner[1] = new PointF(point.X + (product.Width / 2) + move_x, point.Y - (product.Length / 2) + move_y); //{215 ; 195}
pointCorner[2] = new PointF(point.X + (product.Width / 2) + move_x, point.Y + (product.Length / 2) + move_y); //{215 ; 205}
pointCorner[3] = new PointF(point.X - (product.Width / 2) + move_x, point.Y + (product.Length / 2) + move_y); //{205 ; 205}
//Do
placedP.GridSpace = 50; //Set grid (movement speed) to 50.
placedP.Move(true); //{250;200}
placedP.Move(true); //{300;200}Cant perform this.
placedP.GridSpace = 10;
placedP.Move(true); //{260;200} Now it can, because the grid was changed, and that allowed it to move 'slower'
point.X += move_x;
point.Y += move_y;
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product is different!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product is different!");
for (int index = 0; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
public void move_SingleMoveVertical()
{
//Move X+0, Y+10
//Make
PointF point = new PointF(200, 200);
ProductModel product = new ProductModel(10, 10, 50);
PlacedProduct placedP = new PlacedProduct(product, point);
int move_x = 0;
int move_y = 10;
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X - (product.Width / 2) + move_x, point.Y - (product.Length / 2) + move_y); //{195 ; 205}
pointCorner[1] = new PointF(point.X + (product.Width / 2) + move_x, point.Y - (product.Length / 2) + move_y); //{205 ; 205}
pointCorner[2] = new PointF(point.X + (product.Width / 2) + move_x, point.Y + (product.Length / 2) + move_y); //{205 ; 215}
pointCorner[3] = new PointF(point.X - (product.Width / 2) + move_x, point.Y + (product.Length / 2) + move_y); //{195 ; 215}
//Do
placedP.GridSpace = 10;
placedP.Move(false);
point.X += move_x;
point.Y += move_y;
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product is different!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product is different!");
for (int index = 0; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
/// <summary>
/// Selects the Brush where the type matches from the Dictionary kept in the Legend.
/// </summary>
/// <param name="product"></param>
/// <param name="dict"></param>
/// <returns></returns>
public SolidBrush SelectBrush(PlacedProduct product, Dictionary<string, SolidBrush> dict)
{
SolidBrush brush;
try
{
CategoryModel Currentcat = product.Product.ProductCategory;
if (Currentcat.IsSubcategoryFrom > -1 || Currentcat.IsSubcategoryFrom == null) // is a subcategory
{
// gets the main category id
int MainId = (int) Currentcat.IsSubcategoryFrom;
// linq select category with the current id
var selectedcategory2 = CategoryModel.List
.Where(c => c.CatId == MainId)
.Select(c => c)
.ToList();
CategoryModel Main = selectedcategory2[0];
// gets the value (color) from the Main productcategory
brush = new SolidBrush(Main.Colour);
}
else // is a maincategory
{
// give the color from the main category
brush = dict.Single(pair => pair.Key.Equals(product.Product.Category)).Value;
}
}
catch (InvalidOperationException e)
{
// This means that the type is not found in the dictionary, and so I will set the Brush to Black
brush = new SolidBrush(Color.Gray);
}
return brush;
}
//
public void ChangeSelected(ProductInfo sender)
{
productAdding.productInfo1.setProduct(sender.product); //Sets a new product
if(currentProduct.Product.Name != sender.product.Name) { currentProduct = null; }
//Seing as name is an identifier in the database, this can be used to compare the two: Look if the names are the same, if not, then a different product is the currentProduct. Therefore the currentProduct needs to be set to null.
}
/// <summary>
/// Issues the rotation of the image of the product.
/// </summary>
public static void placement_rotateImg(PlacedProduct targetProduct)
{
Color bkColor = Color.Transparent;
int angle = targetProduct.CurrentAngle;
Bitmap defaultMap = targetProduct.DefaultBitMap;
angle = angle % 360;
if (angle > 180)
angle -= 360;
PixelFormat pf = default(PixelFormat);
if (bkColor == Color.Transparent)
{
pf = PixelFormat.Format32bppArgb;
}
else
{
pf = defaultMap.PixelFormat;
}
float sin = (float)Math.Abs(Math.Sin(angle * Math.PI / 180.0)); // this function takes radians
float cos = (float)Math.Abs(Math.Cos(angle * Math.PI / 180.0)); // this one too
float newImgWidth = sin * defaultMap.Height + cos * defaultMap.Width;
float newImgHeight = sin * defaultMap.Width + cos * defaultMap.Height;
float originX = 0f;
float originY = 0f;
if (angle > 0)
{
if (angle <= 90)
originX = sin * defaultMap.Height;
else
{
originX = newImgWidth;
originY = newImgHeight - sin * defaultMap.Width;
}
}
else
{
if (angle >= -90)
originY = sin * defaultMap.Width;
else
{
originX = newImgWidth - sin * defaultMap.Height;
originY = newImgHeight;
}
}
Bitmap newImg = new Bitmap((int)newImgWidth, (int)newImgHeight, pf);
Graphics g = Graphics.FromImage(newImg);
g.Clear(bkColor);
g.TranslateTransform(originX, originY); // offset the origin to our calculated values
g.RotateTransform(angle); // set up rotate
g.InterpolationMode = InterpolationMode.HighQualityBilinear;
g.DrawImageUnscaled(defaultMap, 0, 0); // draw the image at 0, 0
g.Dispose();
targetProduct.RotatedMap = newImg;
}
public void GetPlacements_FromDatabase()
{
foreach (var placement in this.DataSet.placement)
{
var p1 = new PlacedProduct(GetSpecificProduct_FromDatabase(placement.product_id), new System.Drawing.PointF(placement.x_position, placement.y_position),placement.angle);
}
}
/// <summary>
/// Moves the product a certain amount to a certain direction
/// </summary>
/// <param name="X_Axis">Chooses the axis that the product moves on. True for X-axis. False for Y-axis</param>
public static void placement_Move(PlacedProduct targetProduct, bool X_Axis)
{
int x = 0;
int y = 0;
if (X_Axis) { x += targetProduct.GridSpace; }
else { y += targetProduct.GridSpace; }
Vector velocity = new Vector(x, y);
Vector playerTranslation1 = velocity;
Vector playerTranslation2 = velocity;
//Resets the speed, after the velocity has been assigned.
if (targetProduct.GridSpace < 0) { targetProduct.GridSpace *= -1; }
//Test all product polygons for a collision
foreach (PlacedProduct placedP in placedProductList)
{
//Test if the selected polygon is himself
if (placedP.Poly == targetProduct.Poly)
{
continue;
}
//Test if the polygon collides with others
PolygonCollisionController.PolygonCollisionResult r = PolygonCollisionController.PolygonCollision(targetProduct.Poly, placedP.Poly, velocity);
//If it does, alter the speed
if (r.WillIntersect)
{
//
playerTranslation1 = velocity + r.MinimumTranslationVector;
if (X_Axis) //Moving the x-axis, so set the y-axis velocity to 0
{
playerTranslation1.Y = 0;
}
else //Moving the y-axis, so set the x-axis velocity to 0
{
playerTranslation1.X = 0;
}
//If there is any movement along the Y axis while moving along the X axis, then the polygon collision want to move around the other polygon. Can't let that happen. So set all movement to 0.
if (X_Axis && r.MinimumTranslationVector.Y != 0)
{
playerTranslation1.X = 0;
playerTranslation1.Y = 0;
}
if (!X_Axis && r.MinimumTranslationVector.X != 0)
{
playerTranslation1.X = 0;
playerTranslation1.Y = 0;
}
//Round down to the closest x pixels
playerTranslation1.X = ((int)playerTranslation1.X / targetProduct.GridSpace) * targetProduct.GridSpace;
playerTranslation1.Y = ((int)playerTranslation1.Y / targetProduct.GridSpace) * targetProduct.GridSpace;
//MessageBox.Show("then " + playerTranslation1.X.ToString() + " and " + playerTranslation1.Y.ToString());
break;
}
}
//Test all product polygons for a collision
foreach (PlacedProduct placedO in staticlyPlacedObjectList)
{
//Test if the selected polygon is himself
if (placedO.Poly == targetProduct.Poly)
{
continue;
}
//Test if the polygon collides with others
PolygonCollisionController.PolygonCollisionResult r = PolygonCollisionController.PolygonCollision(targetProduct.Poly, placedO.Poly, velocity);
//If it does, alter the speed
if (r.WillIntersect)
{
//
playerTranslation2 = velocity + r.MinimumTranslationVector;
if (X_Axis) //Moving the x-axis, so set the y-axis velocity to 0
{
playerTranslation2.Y = 0;
}
else //Moving the y-axis, so set the x-axis velocity to 0
{
playerTranslation2.X = 0;
}
//If there is any movement along the Y axis while moving along the X axis, then the polygon collision want to move around the other polygon. Can't let that happen. So set all movement to 0.
if (X_Axis && r.MinimumTranslationVector.Y != 0)
{
playerTranslation2.X = 0;
playerTranslation2.Y = 0;
}
if (!X_Axis && r.MinimumTranslationVector.X != 0)
{
playerTranslation2.X = 0;
playerTranslation2.Y = 0;
}
//Round down to the closest x pixels
playerTranslation2.X = ((int)playerTranslation2.X / targetProduct.GridSpace) * targetProduct.GridSpace;
playerTranslation2.Y = ((int)playerTranslation2.Y / targetProduct.GridSpace) * targetProduct.GridSpace;
//MessageBox.Show("then " + playerTranslation2.X.ToString() + " and " + playerTranslation2.Y.ToString());
break;
}
}
//Compares the tanslations
/*
1. Makes a new vector
2. compares the two, and chooses the highest for the X and the highest for the Y (it looks for the highest number, even when negative. ie. -10 is higher than 4)
3. If one of the two is 0, then set that Axis to 0
*/
//1
Vector playerTranslation = new Vector();
//2
playerTranslation.X = Math.Abs(playerTranslation1.X) > Math.Abs(playerTranslation2.X)
? playerTranslation1.X
: playerTranslation2.X;
playerTranslation.Y = Math.Abs(playerTranslation1.Y) > Math.Abs(playerTranslation2.Y)
? playerTranslation1.Y
: playerTranslation2.Y;
//3
if (playerTranslation1.X == 0 || playerTranslation2.X == 0)
{
playerTranslation.X = 0;
}
if (playerTranslation1.Y == 0 || playerTranslation2.Y == 0)
{
playerTranslation.Y = 0;
}
//Set the polygon points
targetProduct.Poly.Offset(playerTranslation);
//Update the corner points
for (int index = 0; index < targetProduct.Poly.Points.Count; index++)
{
targetProduct.CornerPoints[index] = new PointF(targetProduct.Poly.Points[index].X, targetProduct.Poly.Points[index].Y);
}
//Update the center point
targetProduct.Location = new PointF(targetProduct.Location.X + playerTranslation.X, targetProduct.Location.Y + playerTranslation.Y);
}
/// <summary>
/// Issues the rotation of the product.
/// </summary>
/// <param name="fallbackAngle">The fallback angle to provide should the product not be able to rotate.</param>
public static void placement_rotatePoints(PlacedProduct targetProduct, int fallbackAngle)
{
PointF[] fallbackPoints = new PointF[5];
ProductModel product = targetProduct.Product;
PointF location = targetProduct.Location;
for (int index = 0; index < targetProduct.CornerPoints.Length; index++)
{
fallbackPoints[index] = targetProduct.CornerPoints[index];
}
double angle_Even = (double)targetProduct.CurrentAngle;
double angle_Uneven = targetProduct.CurrentAngle;
double radius = Math.Sqrt(Math.Pow(0.5 * product.Width, 2) + Math.Pow(0.5 * product.Length, 2));
//Tan^-1 ( (1/2H) / (1/2W) )
//This is to get the angle of the center of the rectangle relevant to the sides. (To get the angle inside the rectangle)
angle_Even += (Math.Atan((0.5 * product.Length) / (0.5 * product.Width)) * 180 / Math.PI);
angle_Uneven -= 90 - (Math.Atan((0.5 * product.Width) / (0.5 * product.Length)) * 180 / Math.PI);
//If the angle is negative, add 360 to it to get the positive version
while (angle_Uneven < 0)
{
angle_Uneven += 360;
}
while (angle_Even < 0)
{
angle_Even += 360;
}
//MessageBox.Show("Depth: " + product.depth + ". Width: " + product.width);
//MessageBox.Show("Even angle: " + angle_Even.ToString() + ". Uneven angle: " + angle_Uneven.ToString());
//Get the total angle to know what direction the item is facing. (To know where to apply the deltaX and deltaY)
int directional_Even = Convert.ToInt32(angle_Even) % 360;
int directional_Uneven = Convert.ToInt32(angle_Uneven) % 360;
//Gets a 4 possible outcome to determine what deltaX and deltaY do.
directional_Even = directional_Even / 90;
directional_Uneven = directional_Uneven / 90;
/*
0-89 = 0 (360 degrees is 0 degrees)
90-179 = 1
180-269 = 2
270-359 = 3
*/
//Gets the angle nearest to 90, so that the Cos and Sin methods work.
angle_Even = angle_Even % 90;
angle_Uneven = angle_Uneven % 90;
//MessageBox.Show("Even angle: " + angle_Even.ToString() + ". Uneven angle: " + angle_Uneven.ToString());
//Get the difference in X and Y to be applied to the centre point so the corner points can be calculated
float Cos_Even = (float)(Math.Cos(angle_Even * Math.PI / 180) * radius);
float Sin_Even = (float)(Math.Sin(angle_Even * Math.PI / 180) * radius);
float Cos_Uneven = (float)(Math.Cos(angle_Uneven * Math.PI / 180) * radius);
float Sin_Uneven = (float)(Math.Sin(angle_Uneven * Math.PI / 180) * radius);
//Determine what deltaX and deltaY do.
switch (directional_Even)
{
case 0: //Total degree is between 0 and 89
targetProduct.CornerPoints[0] = new PointF(location.X - Cos_Even, location.Y - Sin_Even);
targetProduct.CornerPoints[2] = new PointF(location.X + Cos_Even, location.Y + Sin_Even);
break;
case 1: //Total degree is between 90 and 179
targetProduct.CornerPoints[0] = new PointF(location.X + Sin_Even, location.Y - Cos_Even);
targetProduct.CornerPoints[2] = new PointF(location.X - Sin_Even, location.Y + Cos_Even);
break;
case 2: //Total degree is between 180 and 269
targetProduct.CornerPoints[0] = new PointF(location.X + Cos_Even, location.Y + Sin_Even);
targetProduct.CornerPoints[2] = new PointF(location.X - Cos_Even, location.Y - Sin_Even);
break;
case 3: //Total degree is between 270 and 359
targetProduct.CornerPoints[0] = new PointF(location.X - Sin_Even, location.Y + Cos_Even);
targetProduct.CornerPoints[2] = new PointF(location.X + Sin_Even, location.Y - Cos_Even);
break;
default:
goto case 0;
}
switch (directional_Uneven)
{
case 0: //Total degree is between 1 and 90
targetProduct.CornerPoints[1] = new PointF(location.X + Cos_Uneven, location.Y + Sin_Uneven);
targetProduct.CornerPoints[3] = new PointF(location.X - Cos_Uneven, location.Y - Sin_Uneven);
break;
case 1: //Total degree is between 91 and 180
targetProduct.CornerPoints[1] = new PointF(location.X - Sin_Uneven, location.Y + Cos_Uneven);
targetProduct.CornerPoints[3] = new PointF(location.X + Sin_Uneven, location.Y - Cos_Uneven);
break;
case 2: //Total degree is between 181 and 270
targetProduct.CornerPoints[1] = new PointF(location.X - Cos_Uneven, location.Y - Sin_Uneven);
targetProduct.CornerPoints[3] = new PointF(location.X + Cos_Uneven, location.Y + Sin_Uneven);
break;
case 3: //Total degree is between 271 and 360
targetProduct.CornerPoints[1] = new PointF(location.X + Sin_Uneven, location.Y - Cos_Uneven);
targetProduct.CornerPoints[3] = new PointF(location.X - Sin_Uneven, location.Y + Cos_Uneven);
break;
default:
goto case 0;
}
//Set the last angle to the first angle to complete the square
targetProduct.CornerPoints[4] = targetProduct.CornerPoints[0];
//Setting the new points to the polygon
targetProduct.Poly = new Polygon();
foreach (PointF point in targetProduct.CornerPoints)
{
targetProduct.Poly.Points.Add(new Vector(point.X, point.Y));
}
targetProduct.Poly.BuildEdges();
//Testing if turning caused a collision
foreach (Polygon placedPoly in targetProduct.PolyList)
{
//Test if the selected polygon is himself
if (placedPoly == targetProduct.Poly)
{
continue;
}
//Test if the polygon collides with others
PolygonCollisionController.PolygonCollisionResult r = PolygonCollisionController.PolygonCollision(targetProduct.Poly, placedPoly, new Vector(0, 0));
//If it does, cancel the rotation
if (r.WillIntersect)
{
//Issue the fallback
targetProduct.CurrentAngle = fallbackAngle;
//Issue the fallback
for (int index = 0; index < targetProduct.CornerPoints.Length; index++)
{
targetProduct.CornerPoints[index] = fallbackPoints[index];
}
//Restate the polygon
targetProduct.Poly = new Polygon();
foreach (PointF point in targetProduct.CornerPoints)
{
targetProduct.Poly.Points.Add(new Vector(point.X, point.Y));
}
targetProduct.Poly.BuildEdges();
//MessageBox.Show("The rotation has caused a collision.");
}
}
}
public void DeleteProduct(PlacedProduct product)
{
if (product == null)
return;
placedProducts.Remove(product);
view.Get(ProductGrid.PropertyEnum.Panel).Invalidate();
((ProductGrid) view).productList.fixInformation();
}
public void PanelMouseDown(object sender, MouseEventArgs e)
{
PlacedProduct product = utility.GetProductFromField(e.Location, placedProducts, tileWidth, tileHeight,
tileSize);
if (product != null && !(product.StaticProductBoolean && space.Final))
{
selectedProduct = product;
draggingProduct = true;
selectedProduct.OriginalLocation = selectedProduct.Location;
}
else
{
selectedProduct = null;
draggingProduct = false;
}
view.Get(ProductGrid.PropertyEnum.Panel).Invalidate();
}
private void PaintProduct(PlacedProduct product, Graphics g)
{
Rectangle rectangle = utility.GetProductRectangle(product, tileWidth, tileHeight, tileSize);
SolidBrush brush = utility.SelectBrush(product, legendDictionary);
int angle = product.CurrentAngle;
using (Matrix m = new Matrix())
{
m.RotateAt(angle, new PointF(rectangle.Left + rectangle.Width/2, rectangle.Top + rectangle.Height/2));
g.Transform = m;
if (product == selectedProduct)
{
Rectangle selectionRectangle = new Rectangle(rectangle.X, rectangle.Y, rectangle.Width,
rectangle.Height);
Pen pen = new Pen(Color.Red, 4);
g.DrawRectangle(pen, selectionRectangle);
}
g.FillRectangle(brush, rectangle);
g.ResetTransform();
}
}
public void MoveProduct(ICollisionHandler<PlacedProduct> handler, PlacedProduct selectedProduct,
List<PlacedProduct> placedProducts, int boundWidth, int boundHeight,
float realWidth, float realHeight, float x, float y, bool real)
{
float selectedWidth = selectedProduct.Product.Size.Width,
selectedHeight = selectedProduct.Product.Size.Height;
float newX = (real) ? x : x/(float) boundWidth*realWidth
- selectedWidth/2,
newY = (real) ? y : y/(float) boundHeight*realHeight
- selectedHeight/2;
if (newX <= 0)
newX = 0;
if (newX + selectedWidth/2 >= realWidth - selectedWidth/2)
newX = realWidth - selectedWidth;
if (newY <= 0)
newY = 0;
if (newY + selectedHeight/2 >= realHeight - selectedHeight/2)
newY = realHeight - selectedHeight;
PointF newLocation = new PointF(newX, newY);
selectedProduct.Location = !handler.Collision(selectedProduct, placedProducts)
? newLocation
: selectedProduct.OriginalLocation;
}
public void rotation_addAngle_45()
{
//Make
PointF point = new PointF(200, 200);
ProductModel product = new ProductModel(10, 10, 50);
PlacedProduct placedP = new PlacedProduct(product, point);
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X, point.Y - (float)Math.Sqrt(50)); //{200 ; 200-√50}
pointCorner[1] = new PointF(point.X + (float)Math.Sqrt(50), point.Y); //{200+√50 ; 200}
pointCorner[2] = new PointF(point.X, point.Y + (float)Math.Sqrt(50)); //{200 ; 200+√50}
pointCorner[3] = new PointF(point.X - (float)Math.Sqrt(50), point.Y); //{200-√50 ; 200}
//Do
placedP.AddAngle(25);
placedP.AddAngle(20);
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product has changed!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product has changed!");
for (int index = 0; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
public void MoveProduct(PlacedProduct selectedProduct, List<PlacedProduct> placedProducts, Vector deltaVector, int panelWidth, int panelHeight)
{
//A variable to keep track of collision
bool collision = false;
//The new location that the product is going towards
Point newLocationPoint = new Point(
(int)(selectedProduct.Location.X + deltaVector.X),
(int)(selectedProduct.Location.Y + deltaVector.Y) );
//Checkes the borders
foreach (Polygon wall in selectedProduct.PolyBorder(panelWidth, panelHeight))
{
PolygonCollisionController.PolygonCollisionResult result =
PolygonCollisionController.PolygonCollision(selectedProduct.Poly, wall, deltaVector);
if (result.WillIntersect)
{
collision = true;
break;
}
}
//Loops through each item and determines if it collides with any of them
foreach (PlacedProduct collisionTarget in placedProducts)
{
if (collision)
{ break; }
if (selectedProduct.Product.Collidable == false) //If the selected product is not collidable. For example an 'Energy Socket'. Break out the loop and place it.
{ break; }
if (collisionTarget.Product.Collidable == false) //If the target is not collidable. For example an 'Energy Socket'. Skip this loop and go to the next target.
{ continue; }
PolygonCollisionController.PolygonCollisionResult result =
PolygonCollisionController.PolygonCollision(selectedProduct.Poly, collisionTarget.Poly, deltaVector);
if (result.WillIntersect)
{
collision = true;
break;
}
}
//Failsafe check at the end
if (!collision)
{ /*selectedProduct.MoveTo(newLocationPoint); */}
else
{
MessageBox.Show("Fail");
}
MessageBox.Show(newLocationPoint.ToString());
}
//
public void placeProducts()
{
foreach (var placedProduct in dbc.DataSet.placement)
{
if (placedProduct.space_number == productAdding.space.Room)
{
// get placed productID product
foreach (ProductModel product in ProductModel.List)
{
if (product.ProductId == placedProduct.product_id)
{
Point point = new Point(placedProduct.x_position, placedProduct.y_position);
PlacedProduct p1 = new PlacedProduct(product, point,0);
placedProductList.Add(p1);
}
}
}
}
}
public void event_PanelMouseDown(object sender, MouseEventArgs e)
{
foreach (PlacedProduct PlacedP in PlacementController.placedProductList)
{
//Get the mouse location
var MouseLocation = new Point(e.X, e.Y);
Polygon P = new Polygon();
P.Points.Add(new Vector(MouseLocation.X, MouseLocation.Y));
P.BuildEdges();
//And compare it to all possible polygons, so that when one collides, you know which one the user has clicked on.
PolygonCollisionController.PolygonCollisionResult r = PolygonCollisionController.PolygonCollision(P, PlacedP.Poly, new Vector(0, 0));
if (r.WillIntersect)
{
//Do DragDrop
clickLocation = MouseLocation;
productAdding.DoDragDrop(PlacedP, DragDropEffects.Copy);
//Set as current product
productAdding.productInfo1.setProduct(PlacedP.Product);
currentProduct = PlacedP;
break;
}
}
}
private void placement_NewProduct(object sender, DragEventArgs e)
{
ProductModel model = (ProductModel)e.Data.GetData(typeof(ProductModel));
//Get the correct location
Point newLocation = new Point(e.X, e.Y);
newLocation = motherFrame.PointToClient(newLocation);
newLocation.X -= productAdding.productPanel.Left;
newLocation.Y -= productAdding.productPanel.Top;
newLocation.Y -= motherFrame.menuStrip1.Height;
newLocation.X /= MovementSpeed; newLocation.X *= MovementSpeed; //Round down to the movement speed.
newLocation.Y /= MovementSpeed; newLocation.Y *= MovementSpeed; //Round down to the movement speed.
PlacedProduct product = new PlacedProduct(model, newLocation);
//Collision Loop
foreach (Polygon placedP in product.PolyList)
{
PolygonCollisionController.PolygonCollisionResult r = PolygonCollisionController.PolygonCollision(product.Poly, placedP, new Vector(0, 0));
if (r.WillIntersect)
{
//At the collision, quit the method
DoRepaint();
return;
}
}
//The adding of the product
placedProductList.Add(product);
//Set as current product
currentProduct = product;
productAdding.productList1.fixInformation();
//Redraw
DoRepaint();
}
public void collision_RotateCollision()
{
//Rotate -> Collision
//Rotate 15
//Rotate 15
//Rotate 15
//Rotate 15 -can't do this because collision
//Make
PointF point = new PointF(400, 200);
PointF pointWall = new PointF(400, 50);
ProductModel product = new ProductModel(100, 300, 50);
ProductModel productWall = new ProductModel(100, 50, 50);
PlacedProduct placedP = new PlacedProduct(product, point);
PlacedProduct placedWall = new PlacedProduct(productWall, pointWall);
PlacementController.placedProductList.Add(placedP);
PlacementController.placedProductList.Add(placedWall);
double radius = Math.Sqrt(Math.Pow(product.Width/2, 2) + Math.Pow(product.Length/2, 2));
double initialAngle = (Math.Atan((0.5 * product.Length) / (0.5 * product.Width)) * 180 / Math.PI);
double angle_Even = 45 + initialAngle;
double angle_Uneven = 45 - initialAngle;
float Cos_Even = (float)(Math.Cos(angle_Even * Math.PI / 180) * radius);
float Sin_Even = (float)(Math.Sin(angle_Even * Math.PI / 180) * radius);
float Cos_Uneven = (float)(Math.Cos(angle_Uneven * Math.PI / 180) * radius);
float Sin_Uneven = (float)(Math.Sin(angle_Uneven * Math.PI / 180) * radius);
PointF[] pointCorner = new PointF[4];
pointCorner[0] = new PointF(point.X - Cos_Even, point.Y - Sin_Even); //{205 ; 195}
pointCorner[1] = new PointF(point.X + Cos_Uneven, point.Y + Sin_Uneven); //{215 ; 195}
pointCorner[2] = new PointF(point.X + Cos_Even, point.Y + Sin_Even); //{215 ; 205}
pointCorner[3] = new PointF(point.X - Cos_Uneven, point.Y - Sin_Uneven); //{205 ; 205}
//Do
placedP.AddAngle(15); //after this it's 15
placedP.AddAngle(15); //after this it's 30
placedP.AddAngle(15); //after this it's 45
placedP.AddAngle(15); //after this it's 60 -Can't perform this because of the collision.
placedP.AddAngle(15); //after this it's 75 -Can't perform this.
placedP.AddAngle(15); //after this it's 90 -Can't perform this.
//Look
Assert.AreEqual(point.X, placedP.Location.X, 0.1, "The horizontal location of the product is different!");
Assert.AreEqual(point.Y, placedP.Location.Y, 0.1, "The vertical location of the product is different!");
for (int index = 1; index < pointCorner.Length; index++)
{
Assert.AreEqual(pointCorner[index].ToString(), placedP.CornerPoints[index].ToString(), true, "Corner #" + index + " is in the wrong spot!");
}
}
public void AddNewProduct(ProductModel model, float x, float y, float width, float height, bool realDimensions,
int angle)
{
float viewWidth = view.Get(ProductGrid.PropertyEnum.Panel).Width,
viewHeight = view.Get(ProductGrid.PropertyEnum.Panel).Height,
newX = realDimensions ? x : x/viewWidth*meterWidth,
newY = realDimensions ? y : y/viewHeight*meterHeight;
PointF center = (realDimensions) ? new PointF(x, y) : new PointF(newX-width/2, newY-height/2);
int currentangle = angle;
SizeF size = new SizeF(width, height);
model.Size = size;
PlacedProduct newProduct = new PlacedProduct(model, center, currentangle);
// Do not add product to field if it has collision
if (!collisionHandler.Collision(newProduct, placedProducts))
{
placedProducts.Add(newProduct);
((ProductGrid) view).productList.fixInformation();
}
}
