/// <summary> /// Returns true if it gets even one valid point on the specified face, else returns false /// </summary> /// <param name="inX"></param> /// <param name="inY"></param> /// <param name="inZ"></param> /// <param name="inFace"></param> /// <returns></returns> public bool IsFaceWithValidPt(int inX, int inY, int inZ, CubeFaceType inFace) { if (!(inX > 0 && inX < _moldFileInfo.X && inY > 0 && inY < _moldFileInfo.Y && inZ > 0 && inZ < _moldFileInfo.Z)) { throw new Exception("cube indexes should be one less than total points"); } if (!(inFace == CubeFaceType.MaxX || inFace == CubeFaceType.MaxY || inFace == CubeFaceType.MaxZ)) { throw new Exception("Face is not a right value."); } if (inFace == CubeFaceType.MaxX) { //frontTopRight - frontBottomRight - backTopRight - backBottomRight return(IsValidPoint(inX + 1, inY, inZ) || IsValidPoint(inX + 1, inY + 1, inZ) || IsValidPoint(inX + 1, inY, inZ + 1) || IsValidPoint(inX + 1, inY + 1, inZ + 1)); } if (inFace == CubeFaceType.MaxY) { //frontTopRight - frontTopLeft - backTopRight - backTopLeft return(IsValidPoint(inX, inY + 1, inZ) || IsValidPoint(inX + 1, inY + 1, inZ) || IsValidPoint(inX, inY + 1, inZ + 1) || IsValidPoint(inX + 1, inY + 1, inZ + 1)); } if (inFace != CubeFaceType.MaxZ) { throw new Exception("Cube face type is not one of the expected values."); } //frontTopRight - frontBottomRight - frontBottomLeft - frontTopLeft return(IsValidPoint(inX, inY + 1, inZ + 1) || IsValidPoint(inX, inY, inZ + 1) || IsValidPoint(inX + 1, inY, inZ + 1) || IsValidPoint(inX + 1, inY + 1, inZ + 1)); }
private void SetFacePosition(VisualCube c, VisualCubeFace fToTurn, CubeFaceType desiredType) { if (fToTurn.FaceType != desiredType) { c.TurnCube(fToTurn, desiredType); } }
/// <summary> /// Gets the correpondent face. /// </summary> /// <param name="color">The position of the face</param> /// <returns>Returns the face position.</returns> /// <exception cref="IndexOutOfRangeException"></exception> public CubeFace this[CubeFaceType type] { get { foreach (KeyValuePair<CubeFace, CubeFaceType> entry in CubeMap) { if (entry.Value.Equals(type)) return entry.Key; } throw new IndexOutOfRangeException(); } }
void SetFaceTexture(CubeFaceType faceType, Vector2[] uvs) { if (faceType == CubeFaceType.Front) { Vector2[] newUVS = GetUVS(frontPoint.x, frontPoint.y); uvs[0] = newUVS[0]; uvs[1] = newUVS[1]; uvs[2] = newUVS[2]; uvs[3] = newUVS[3]; } else if (faceType == CubeFaceType.Back) { Vector2[] newUVS = GetUVS(backPoint.x, backPoint.y); uvs[10] = newUVS[0]; uvs[11] = newUVS[1]; uvs[6] = newUVS[2]; uvs[7] = newUVS[3]; } else if (faceType == CubeFaceType.Top) { Vector2[] newUVS = GetUVS(topPoint.x, topPoint.y); uvs[8] = newUVS[0]; uvs[9] = newUVS[1]; uvs[4] = newUVS[2]; uvs[5] = newUVS[3]; } else if (faceType == CubeFaceType.Bottom) { Vector2[] newUVS = GetUVS(bottomPoint.x, bottomPoint.y); uvs[12] = newUVS[0]; uvs[14] = newUVS[1]; uvs[15] = newUVS[2]; uvs[13] = newUVS[3]; } else if (faceType == CubeFaceType.Left) { Vector2[] newUVS = GetUVS(leftPoint.x, leftPoint.y); uvs[16] = newUVS[0]; uvs[18] = newUVS[1]; uvs[19] = newUVS[2]; uvs[17] = newUVS[3]; } else if (faceType == CubeFaceType.Right) { Vector2[] newUVS = GetUVS(rightPoint.x, rightPoint.y); uvs[20] = newUVS[0]; uvs[22] = newUVS[1]; uvs[23] = newUVS[2]; uvs[21] = newUVS[3]; } }
private void CheckInput() { if(MainCamera == null || Target == null) return; if(Input.GetKey(KeyCode.D)) { m_inputState = InputState.Deletion; } else if(Status == GameStatus.Editor && Input.GetKey(KeyCode.A)) { m_inputState = InputState.Addition; } else if(Input.GetKey(KeyCode.W)) { m_inputState = InputState.Mark; } else m_inputState = InputState.None; if(m_clickable && Input.GetMouseButtonDown(0)) { //从摄像机发出到点击坐标的射线 Ray ray = MainCamera.ScreenPointToRay(Input.mousePosition); RaycastHit hitInfo; if(Physics.Raycast(ray, out hitInfo, 100f, 1<<8)) { //划出射线,只有在scene视图中才能看到 Debug.DrawLine(ray.origin, hitInfo.point); ModelCube target = hitInfo.collider.gameObject.GetComponent<ModelCube>(); if(target != null) { Vector3 point = target.transform.InverseTransformPoint(hitInfo.point); switch(m_inputState) { case InputState.Mark: //cube.Mark(); break; case InputState.Deletion: Target.DeleteCube(target); break; case InputState.Addition: CubeFaceType face = ClickFace(point); Target.AddCube(target, face); break; }//end switch }//end null }//end ray }//end buttondown }
private GeometryModel3D PrepareCubeFace(CubeFaceType face, Brush brush, double aspect) { // Create the mesh var mesh = ((MeshGeometry3D)_viewport.Resources["CubeFace"]).Clone(); switch (face) { case CubeFaceType.Left: mesh.Positions[0] = new Point3D(-aspect / 2, 0.5, -aspect); mesh.Positions[1] = new Point3D(-aspect / 2, 0.5, 0); mesh.Positions[2] = new Point3D(-aspect / 2, -0.5, 0); mesh.Positions[3] = new Point3D(-aspect / 2, -0.5, -aspect); break; case CubeFaceType.Right: mesh.Positions[0] = new Point3D(aspect / 2, 0.5, 0); mesh.Positions[1] = new Point3D(aspect / 2, 0.5, -aspect); mesh.Positions[2] = new Point3D(aspect / 2, -0.5, -aspect); mesh.Positions[3] = new Point3D(aspect / 2, -0.5, 0); break; case CubeFaceType.Top: mesh.Positions[0] = new Point3D(-aspect / 2, 0.5, -1); mesh.Positions[1] = new Point3D(aspect / 2, 0.5, -1); mesh.Positions[2] = new Point3D(aspect / 2, 0.5, 0); mesh.Positions[3] = new Point3D(-aspect / 2, 0.5, 0); break; case CubeFaceType.Bottom: mesh.Positions[0] = new Point3D(-aspect / 2, -0.5, 0); mesh.Positions[1] = new Point3D(aspect / 2, -0.5, 0); mesh.Positions[2] = new Point3D(aspect / 2, -0.5, -1); mesh.Positions[3] = new Point3D(-aspect / 2, -0.5, -1); break; case CubeFaceType.Front: mesh.Positions[0] = new Point3D(-aspect / 2, 0.5, 0); mesh.Positions[1] = new Point3D(aspect / 2, 0.5, 0); mesh.Positions[2] = new Point3D(aspect / 2, -0.5, 0); mesh.Positions[3] = new Point3D(-aspect / 2, -0.5, 0); break; } // Apply material var material = new DiffuseMaterial(brush); // Create the model var model = new GeometryModel3D(mesh, material); return(model); }
protected void SetFaceTexture(CubeFaceType faceType, Vector2[] uvs) { if (faceType == CubeFaceType.Front) { Vector2[] newUVS = GetUVS(FrontPoint.x, FrontPoint.y); uvs[0] = newUVS[0]; uvs[1] = newUVS[1]; uvs[2] = newUVS[2]; uvs[3] = newUVS[3]; } else if (faceType == CubeFaceType.Back) { Vector2[] newUVS = GetUVS(BackPoint.x, BackPoint.y); uvs[7] = newUVS[0]; uvs[6] = newUVS[1]; uvs[11] = newUVS[2]; uvs[10] = newUVS[3]; } else if (faceType == CubeFaceType.Top) { Vector2[] newUVS = GetUVS(TopPoint.x, TopPoint.y); uvs[8] = newUVS[0]; uvs[9] = newUVS[1]; uvs[4] = newUVS[2]; uvs[5] = newUVS[3]; } else if (faceType == CubeFaceType.Bottom) { Vector2[] newUVS = GetUVS(BottomPoint.x, BottomPoint.y); uvs[15] = newUVS[1]; uvs[12] = newUVS[0]; uvs[13] = newUVS[2]; uvs[14] = newUVS[3]; } else if (faceType == CubeFaceType.Left) { Vector2[] newUVS = GetUVS(LeftPoint.x, LeftPoint.y); uvs[19] = newUVS[1]; uvs[16] = newUVS[0]; uvs[17] = newUVS[2]; uvs[18] = newUVS[3]; } else if (faceType == CubeFaceType.Right) { Vector2[] newUVS = GetUVS(RightPoint.x, RightPoint.y); uvs[23] = newUVS[1]; uvs[20] = newUVS[0]; uvs[21] = newUVS[2]; uvs[22] = newUVS[3]; } }
public Face( Cube cube, CubeFaceType type, Vector3 normal, Vector3 up, Direction rotation ) : base(cube.Game) { Cube = cube; Type = type; Normal = Vector3.Normalize( normal ); UpVec = Vector3.Normalize( up ); RightVec = Vector3.Cross( Normal, UpVec ); Rotation = -rotation.Angle; BackgroundColor = Color.Gray; SetUpVertices(); SetUpWorld(); }
/// <summary> /// Change the position of the blocks from U or D face. DOES NOT CHECK if the value of coordinate is 0. /// </summary> /// <param name="faceType">The facetype wich the blockmatrix belong</param> /// <param name="blockMatrix">The block matrix to change positions</param> /// <param name="coord">The coordinate of the movement</param> private void ChangeUDBlockPosition(CubeFaceType faceType, List<VisualCubeBlock> blockMatrix, Coordinate coord) { switch (coord.Axis) { case CoordinateAxis.X: if (coord.Value == 90) RotateBlockMatrix(blockMatrix, true); else if (coord.Value == -90) RotateBlockMatrix(blockMatrix, false); else { RotateBlockMatrix(blockMatrix, false); RotateBlockMatrix(blockMatrix, false); } break; case CoordinateAxis.Y: if (faceType == CubeFaceType.U && coord.Value == -90) { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } else if (faceType == CubeFaceType.D && coord.Value == +90) { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } break; case CoordinateAxis.Z: if (coord.Value != 180) RotateBlockMatrix(blockMatrix, IsClockWise(faceType, coord)); else { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } break; default: break; } }
/// <summary> /// Change the block matrix positions of the F and the B faces.DOES NOT CHECK if the value of coordinate is 0. /// </summary> /// <param name="faceType">The facetype wich the blockmatrix belong</param> /// <param name="blockMatrix">The block matrix to change positions</param> /// <param name="coord">The coordinate of the movement</param> private void ChangeFBBlockPosition(CubeFaceType faceType, List<VisualCubeBlock> blockMatrix, Coordinate coord) { switch (coord.Axis) { case CoordinateAxis.X: if (coord.Value == 90) RotateBlockMatrix(blockMatrix, (faceType == CubeFaceType.F)); else if (coord.Value == -90) RotateBlockMatrix(blockMatrix, (faceType != CubeFaceType.F)); else { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } break; case CoordinateAxis.Y: if (faceType == CubeFaceType.B) { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } else if (coord.Value == 180) { RotateBlockMatrix(blockMatrix, true); RotateBlockMatrix(blockMatrix, true); } break; case CoordinateAxis.Z: //No changes break; } }
/// <summary> /// Change the position of the blocks from L or R face. DOES NOT CHECK if the value of coordinate is 0. /// </summary> /// <param name="faceType">The facetype wich the blockmatrix belong</param> /// <param name="blockMatrix">The block matrix to change positions</param> /// <param name="coord">The coordinate of the movement</param> private void ChangeLRBlockPosition(CubeFaceType faceType, List<VisualCubeBlock> blockMatrix, Coordinate coord) { switch (coord.Axis) { case CoordinateAxis.X: if (coord.Value == 90) RotateBlockMatrix(blockMatrix, true); else if (coord.Value == -90) RotateBlockMatrix(blockMatrix, false); else { RotateBlockMatrix(blockMatrix, false); RotateBlockMatrix(blockMatrix, false); } break; case CoordinateAxis.Y: if (coord.Value != 180) RotateBlockMatrix(blockMatrix, IsClockWise(faceType, coord)); else { RotateBlockMatrix(blockMatrix, false); RotateBlockMatrix(blockMatrix, false); } break; case CoordinateAxis.Z: //It is not affected break; } }
/// <summary> /// Turns the especific face /// </summary> /// <param name="faceType">The type of the face</param> /// <param name="coord">The coordinate of the face</param> public void TurnFace(CubeFaceType faceType, Coordinate coord) { switch (faceType) { case CubeFaceType.U: case CubeFaceType.D: TurnUDFace(faceType, coord); break; case CubeFaceType.L: case CubeFaceType.R: TurnLFace(faceType, coord); break; case CubeFaceType.F: case CubeFaceType.B: TurnFBFace(faceType, coord); break; } }
/// <summary> /// Changes the position of all cubeblocks. CHECKS if the coordinate value is 0. /// </summary> /// <param name="faceType">Type of the face</param> /// <param name="blockMatrix">The blockmatrix of the face</param> /// <param name="coord">The coordinate of the movement</param> private void ChangeBlocksPosition(CubeFaceType faceType, List<VisualCubeBlock> blockMatrix, Coordinate coord) { if (coord.Value != 0) { switch (faceType) { case CubeFaceType.U: case CubeFaceType.D: ChangeUDBlockPosition(faceType, blockMatrix, coord); break; case CubeFaceType.L: case CubeFaceType.R: ChangeLRBlockPosition(faceType, blockMatrix, coord); break; case CubeFaceType.F: case CubeFaceType.B: ChangeFBBlockPosition(faceType, blockMatrix, coord); break; } } }
/// <summary> /// Gets the correpondent face. /// </summary> /// <param name="type">Type of the face</param> /// <returns>Returns the face.</returns> /// <exception cref="IndexOutOfRangeException"></exception> public VisualCubeFace this[CubeFaceType type] { get { VisualCubeFace face = null; foreach (VisualCubeFace item in _faces) { if (item.FaceType == type) { face = item; break; } } if (face != null) return face; else throw new IndexOutOfRangeException(); } }
/// <summary> /// Turns, if it is necessary, the cube to the face become the desired type. /// </summary> /// <param name="f">Face to turn</param> /// <param name="desiredType">Desired type for the face</param> public void TurnCube(VisualCubeFace f, CubeFaceType desiredType) { if (f.FaceType != desiredType) { Coordinate coord = GetVariationMovement(f.FaceType, desiredType); TurnCube(coord); } }
public World this[CubeFaceType faceType] { get { switch ( faceType ) { case CubeFaceType.Front: return StringToWorld( FrontFace ); case CubeFaceType.Back: return StringToWorld( BackFace ); case CubeFaceType.Top: return StringToWorld( TopFace ); case CubeFaceType.Bottom: return StringToWorld( BottomFace ); case CubeFaceType.Left: return StringToWorld( LeftFace ); case CubeFaceType.Right: return StringToWorld( RightFace ); default: throw new ArgumentException(); } } set { switch ( faceType ) { case CubeFaceType.Front: FrontFace = WorldToString( value ); break; case CubeFaceType.Back: BackFace = WorldToString( value ); break; case CubeFaceType.Top: TopFace = WorldToString( value ); break; case CubeFaceType.Bottom: BottomFace = WorldToString( value ); break; case CubeFaceType.Left: LeftFace = WorldToString( value ); break; case CubeFaceType.Right: RightFace = WorldToString( value ); break; default: throw new ArgumentException(); } } }
public static Point GetPoint(CubeFaceType face, CubeFaceletType square) { return positions[face.GetHashCode(), square.GetHashCode()]; }
/// <summary> /// Turn the face based on coordinates /// </summary> /// <param name="face">The face to be turned</param> /// <param name="coord">The coordinates</param> /// <returns>Return the new face, after the turn.</returns> private CubeFaceType RotateFace(CubeFaceType face, Coordinate coord) { CubeFaceType newFace = CubeFaceType.U; switch (face) { case CubeFaceType.U: newFace = RotateUFace(coord); break; case CubeFaceType.D: newFace = RotateDFace(coord); break; case CubeFaceType.L: newFace = RotateLFace(coord); break; case CubeFaceType.R: newFace = RotateRFace(coord); break; case CubeFaceType.F: newFace = RotateFFace(coord); break; case CubeFaceType.B: newFace = RotateBFace(coord); break; } return newFace; }
/// <summary> /// Get the coordinates of the movement based on the face origins /// </summary> /// <param name="fOriging">FaceType origins of the movement</param> /// <param name="fDestiny">FaceType destiny</param> /// <returns>Returns the coordinate for the new movement</returns> private Coordinate GetVariationMovement(CubeFaceType fOriging, CubeFaceType fDestiny) { int fOr = fOriging.GetHashCode(); int fDes = fDestiny.GetHashCode(); return default_moves[fOr, fDes]; }
private GeometryModel3D PrepareCubeFace(CubeFaceType face, Brush brush, double aspect) { // Create the mesh MeshGeometry3D mesh = (_viewport.Resources["CubeFace"] as MeshGeometry3D).Clone(); switch (face) { case CubeFaceType.Left: mesh.Positions[0] = new Point3D(-aspect/2, 0.5, -aspect); mesh.Positions[1] = new Point3D(-aspect/2, 0.5, 0); mesh.Positions[2] = new Point3D(-aspect/2, -0.5, 0); mesh.Positions[3] = new Point3D(-aspect/2, -0.5, -aspect); break; case CubeFaceType.Right: mesh.Positions[0] = new Point3D(aspect/2, 0.5, 0); mesh.Positions[1] = new Point3D(aspect/2, 0.5, -aspect); mesh.Positions[2] = new Point3D(aspect/2, -0.5, -aspect); mesh.Positions[3] = new Point3D(aspect/2, -0.5, 0); break; case CubeFaceType.Top: mesh.Positions[0] = new Point3D(-aspect/2, 0.5, -1); mesh.Positions[1] = new Point3D(aspect/2, 0.5, -1); mesh.Positions[2] = new Point3D(aspect/2, 0.5, 0); mesh.Positions[3] = new Point3D(-aspect/2, 0.5, 0); break; case CubeFaceType.Bottom: mesh.Positions[0] = new Point3D(-aspect/2, -0.5, 0); mesh.Positions[1] = new Point3D(aspect/2, -0.5, 0); mesh.Positions[2] = new Point3D(aspect/2, -0.5, -1); mesh.Positions[3] = new Point3D(-aspect/2, -0.5, -1); break; case CubeFaceType.Front: mesh.Positions[0] = new Point3D(-aspect/2, 0.5, 0); mesh.Positions[1] = new Point3D(aspect/2, 0.5, 0); mesh.Positions[2] = new Point3D(aspect/2, -0.5, 0); mesh.Positions[3] = new Point3D(-aspect/2, -0.5, 0); break; } // Apply material DiffuseMaterial material = new DiffuseMaterial(brush); // Create the model GeometryModel3D model = new GeometryModel3D(mesh, material); return model; }
/// <summary> /// Adds the rotation movement. /// </summary> /// <param name="positionFace">Position of the face to be turned</param> /// <param name="movements">List of movements to be concatenated of the new movement</param> private void BringFaceToSomeClaw(CubeFaceType positionFace, CubeFaceType nextPositionFace, List<Movement> movements) { // se face não está diretamente ligada a uma das garras, leva a face para a garra if (!positionFace.Equals(Claw_L) && !positionFace.Equals(Claw_F)) { RotateCubeMovement mov = new RotateCubeMovement(); switch (positionFace) { case CubeFaceType.U: if (nextPositionFace.Equals(CubeFaceType.F)) { mov.Axis = CoordinateAxis.X; mov.Type = TurnType.HalfTurnLeft; } else { mov.Axis = CoordinateAxis.Y; mov.Type = TurnType.HalfTurnRight; } break; case CubeFaceType.B: mov.Axis = CoordinateAxis.Y; mov.Type = TurnType.FullTurn; break; case CubeFaceType.R: mov.Axis = CoordinateAxis.X; mov.Type = TurnType.FullTurn; break; case CubeFaceType.D: if (nextPositionFace.Equals(CubeFaceType.F)) { mov.Axis = CoordinateAxis.X; mov.Type = TurnType.HalfTurnRight; } else { mov.Axis = CoordinateAxis.Y; mov.Type = TurnType.HalfTurnLeft; } break; } // turns the representation of the cube (very important) Cube.TurnCube(mov); // adds the new movement to the list of movements movements.Add(mov); } }
private static int[] SortFacelets(CubeFaceType face) { int[] faceUL = { (int)CubeFaceletType.UpLeft, (int)CubeFaceletType.UpMid,(int)CubeFaceletType.UpRight, (int)CubeFaceletType.MidLeft,(int)CubeFaceletType.Center, (int)CubeFaceletType.MidRight, (int)CubeFaceletType.DownLeft, (int)CubeFaceletType.DownMid,(int)CubeFaceletType.DownRight }; int[] faceUR = { (int)CubeFaceletType.UpRight, (int)CubeFaceletType.MidRight,(int)CubeFaceletType.DownRight, (int)CubeFaceletType.UpMid,(int)CubeFaceletType.Center, (int)CubeFaceletType.DownMid, (int)CubeFaceletType.UpLeft, (int)CubeFaceletType.MidLeft,(int)CubeFaceletType.DownLeft }; int[] faceDL = { (int)CubeFaceletType.DownLeft, (int)CubeFaceletType.MidLeft,(int)CubeFaceletType.UpLeft, (int)CubeFaceletType.DownMid,(int)CubeFaceletType.Center, (int)CubeFaceletType.UpMid, (int)CubeFaceletType.DownRight, (int)CubeFaceletType.MidRight,(int)CubeFaceletType.UpRight }; int[] faceDR = { (int)CubeFaceletType.DownRight,(int)CubeFaceletType.DownMid,(int)CubeFaceletType.DownLeft, (int)CubeFaceletType.MidRight,(int)CubeFaceletType.Center,(int)CubeFaceletType.MidLeft, (int)CubeFaceletType.UpRight,(int)CubeFaceletType.UpMid,(int)CubeFaceletType.UpLeft }; switch (face) { case CubeFaceType.U: return faceUR; case CubeFaceType.B: return faceDL; case CubeFaceType.D: return faceUR; case CubeFaceType.F: return faceUR; case CubeFaceType.R: return faceDR; case CubeFaceType.L: return faceDR; default: return faceUR; } }
/// <summary> /// Indicates if the movement is clockwise or counter-clockwise to the face. /// </summary> /// <param name="faceType">Type of the face</param> /// <param name="coord">Coordinate of the movement</param> /// <returns>Returns true if the movement is clockwise. Otherwise, false</returns> private bool IsClockWise(CubeFaceType faceType, Coordinate coord) { bool _isClockwise = false; switch (faceType) { case CubeFaceType.U: if (coord.Axis == CoordinateAxis.Z) { if (coord.Value == 90) _isClockwise = true; else if (coord.Value == -90) _isClockwise = false; } break; case CubeFaceType.D: if (coord.Axis == CoordinateAxis.Z) { if (coord.Value == -90) _isClockwise = true; else if (coord.Value == +90) _isClockwise = false; } break; case CubeFaceType.L: if (coord.Axis == CoordinateAxis.Y) { if (coord.Value == 90) _isClockwise = true; else if (coord.Value == -90) _isClockwise = false; } break; case CubeFaceType.R: if (coord.Axis == CoordinateAxis.Y) { if (coord.Value == -90) _isClockwise = true; else if (coord.Value == +90) _isClockwise = false; } break; case CubeFaceType.F: if (coord.Axis == CoordinateAxis.X) { if (coord.Value == 90) _isClockwise = true; else if (coord.Value == -90) _isClockwise = false; } break; case CubeFaceType.B: if (coord.Axis == CoordinateAxis.X) { if (coord.Value == -90) _isClockwise = true; else if (coord.Value == +90) _isClockwise = false; } break; } return _isClockwise; }
public bool AddCube(ModelCube target, CubeFaceType face) { if (!m_editable) { return(false); } ModelCube prefab = Resources.Load <ModelCube>("Prefabs/ModelCube"); if (prefab == null) { return(false); } int current = 1; Vector3 offset = Vector3.right; switch (face) { case CubeFaceType.Top: offset = Vector3.up; current = m_info.Heigth; break; case CubeFaceType.Bottom: offset = Vector3.down; current = m_info.Heigth; break; case CubeFaceType.Front: offset = Vector3.forward; current = m_info.Depth; break; case CubeFaceType.Back: offset = Vector3.back; current = m_info.Depth; break; case CubeFaceType.Right: offset = Vector3.right; current = m_info.Width; break; case CubeFaceType.Left: offset = Vector3.left; current = m_info.Width; break; } if (current >= GameConst.CubeMax) { return(false); } CubeModelData data = new CubeModelData(); data.Pos = target.ModelData.Pos + offset; m_info.Cubes.Add(data); ModelCube cube = GameObject.Instantiate <ModelCube>(prefab); cube.transform.parent = transform; cube.transform.localPosition = data.Pos; cube.ModelData = data; m_cubes.Add(cube); UpdateWHD(cube); return(true); }
/// <summary> /// Turns the L or R face /// </summary> /// <param name="faceType">The type of the face</param> /// <param name="coord">Coordinate of the movement</param> private void TurnLFace(CubeFaceType faceType, Coordinate coord) { if (coord.Value != 0) { if (coord.Axis != CoordinateAxis.Y) { //If not Y, it is impossible to turn only the L/R face. So, it turns the whole cube TurnCube(coord); } else { //Changes the position of the blocks in the face ChangeLRBlockPosition(faceType, this[faceType].GetBlocks(), coord); List<VisualCubeBlock> next_Blocks = new List<VisualCubeBlock>(); List<VisualCubeBlock> block_toChange = new List<VisualCubeBlock>(); List<VisualCubeBlock> search_blocks = new List<VisualCubeBlock>(); CubeFaceType[] face_order = new CubeFaceType[] { CubeFaceType.F, CubeFaceType.D, CubeFaceType.B, CubeFaceType.U }; bool clockwise = IsClockWise(CubeFaceType.L, coord); int index; int post_index = 0; int incremento = (coord.Value != 180) ? 1 : 2; int limit = (coord.Value != 180) ? 4 : 2; for (int i = 0; i < limit; i++) { //Determine the current index and the next index index = i; post_index = index + incremento; if (!clockwise && coord.Value != 180) { index = 3 - index; post_index = index - 1; } //Ajust last post_index if (post_index == -1) post_index = 3; else if (post_index == 4) post_index = 0; //Gets the current face and the next face VisualCubeFace currentFace = this[face_order[index]]; VisualCubeFace nextFace = this[face_order[post_index]]; //Save the next blocks if (faceType == CubeFaceType.L) { search_blocks = (face_order[post_index] == CubeFaceType.B) ? nextFace.GetRightBlocks() : nextFace.GetLeftBlocks(); } else { search_blocks = (face_order[post_index] != CubeFaceType.B) ? nextFace.GetRightBlocks() : nextFace.GetLeftBlocks(); } next_Blocks.Clear(); foreach (VisualCubeBlock item in search_blocks) { next_Blocks.Add(item.Clone()); } //load the current blocks, if necessary if (block_toChange.Count == 0) { if (faceType == CubeFaceType.L) { search_blocks = (face_order[index] == CubeFaceType.B) ? currentFace.GetRightBlocks() : currentFace.GetLeftBlocks(); } else { search_blocks = (face_order[index] != CubeFaceType.B) ? currentFace.GetRightBlocks() : currentFace.GetLeftBlocks(); } foreach (VisualCubeBlock item in search_blocks) { VisualCubeBlock toChange = item.Clone(); block_toChange.Add(toChange); } } //Changes the position of the blocks turned ChangeBlocksPosition(face_order[index], block_toChange, coord); //Adds to the face foreach (VisualCubeBlock item in block_toChange) { nextFace.AddBlock(item.Clone(), false); } //Redo the cycle, copying the temp_blocks to block_toChange; block_toChange.Clear(); if (coord.Value != 180) { foreach (VisualCubeBlock item in next_Blocks) { block_toChange.Add(item.Clone()); } } else { ChangeBlocksPosition(face_order[post_index], next_Blocks, coord); foreach (VisualCubeBlock item in next_Blocks) { currentFace.AddBlock(item.Clone(), false); } } } if (coord.Value != 180) ChangeBlocksPosition(face_order[post_index], block_toChange, coord); } } }
protected override Cube.Face NewFace( CubeFaceType type, Vector3 normal, Vector3 up, Direction rotation ) { return new Face( this, type, normal, up, rotation ); }
public Face( EditableCube cube, CubeFaceType type, Vector3 normal, Vector3 up, Direction orientation ) : base(cube, type, normal, up, orientation) { }
public RotateFaceMovement(CubeFaceColor color, CubeFaceType type) { Face = color; PositionFace = type; }