private void TakeSnapShot(PuzzlePivot pivot)
{
snapShot = TakeSnapShot();
if (pivot.collectableObject != null)
{
collectableHelper.TakeCollectableSnapshot();
pivot.collectableObject.SetActive(false);
}
}
public static SnapablePoint GetSnapablePointWithPieceId(PuzzlePivot puzzlePivot, string id)
{
foreach (var snapablePoint in puzzlePivot.snapablePoints)
{
if (snapablePoint.piece != null && snapablePoint.piece.id == id)
{
return(snapablePoint);
}
}
return(null);
}
public static Vector2 GetRelativePosition(PuzzlePivot puzzlePivot, int currentIndex, int otherIndex)
{
int piecesOnY = (int)puzzlePivot.numberOfPieces.y;
var currentX = Mathf.FloorToInt((float)currentIndex / piecesOnY);
var currentY = currentIndex % piecesOnY;
var otherX = Mathf.FloorToInt((float)otherIndex / piecesOnY);
var otherY = otherIndex % piecesOnY;
return(new Vector2(otherX - currentX, otherY - currentY));
}
public static SnapablePoint GetSnapablePointFromDirection(PuzzlePivot puzzlePivot, SnapablePoint currentSnapablePoint, Direction direction)
{
var index = puzzlePivot.snapablePoints.IndexOf(currentSnapablePoint);
int piecesOnY = (int)puzzlePivot.numberOfPieces.y;
if (direction == Direction.Right)
{
var newIndex = index + piecesOnY;
if (newIndex < 0 || newIndex >= puzzlePivot.snapablePoints.Count)
{
return(null);
}
return(puzzlePivot.snapablePoints[newIndex]);
}
if (direction == Direction.Left)
{
var newIndex = index - piecesOnY;
if (newIndex < 0 || newIndex >= puzzlePivot.snapablePoints.Count)
{
return(null);
}
return(puzzlePivot.snapablePoints[newIndex]);
}
if (direction == Direction.Up)
{
var newIndex = index + 1;
if (newIndex % piecesOnY == 0)
{
return(null);
}
if (newIndex < 0 || newIndex >= puzzlePivot.snapablePoints.Count)
{
return(null);
}
return(puzzlePivot.snapablePoints[newIndex]);
}
if (direction == Direction.Down)
{
var newIndex = index - 1;
if (index % piecesOnY == 0)
{
return(null);
}
if (newIndex < 0 || newIndex >= puzzlePivot.snapablePoints.Count)
{
return(null);
}
return(puzzlePivot.snapablePoints[newIndex]);
}
return(null);
}
public bool SetupNextPuzzlePivot()
{
var nextPuzzlePivot = GetNextPuzzlePivot();
if (nextPuzzlePivot != null)
{
activePuzzlePivot = nextPuzzlePivot;
HideAllPuzzlePivots();
activePuzzlePivot.pivot.SetActive(true);
SetBackgroundColor(puzzlePivots.IndexOf(activePuzzlePivot));
return(true);
}
return(false);
}
private PuzzlePivot GetNextPuzzlePivot()
{
PuzzlePivot result = null;
foreach (var puzzlePivot in puzzlePivots)
{
if (puzzlePivot == activePuzzlePivot)
{
return(result);
}
result = puzzlePivot;
}
return(result);
}
public static KeyPieceDictionary SetupKeyPieceDictionary(PuzzlePivot pivot, List <Piece> pieces)
{
var keyPiece = pieces[0];
var keyPieceDictionary = new KeyPieceDictionary(keyPiece);
var keyPieceSnapablePoint = SnapablePoint.GetSnapablePointWithPieceId(pivot, keyPiece.id);
var keyPieceId = pivot.snapablePoints.IndexOf(keyPieceSnapablePoint);
foreach (var piece in pieces)
{
var snapablePoint = SnapablePoint.GetSnapablePointWithPieceId(pivot, piece.id);
var relativePos = SnapablePoint.GetRelativePosition(pivot, keyPieceId, pivot.snapablePoints.IndexOf(snapablePoint));
keyPieceDictionary.pieceDictionary.Add(relativePos, piece.FullId);
}
return(keyPieceDictionary);
}
private IEnumerator SetupExtraPivot(PuzzlePivot puzzlePivot)
{
SetBackgroundColor(puzzlePivots.Count);
HideAllPuzzlePivots();
TakeSnapShot(puzzlePivot);
puzzlePivots.Add(puzzlePivot);
yield return(puzzlePivot.SpawnPieces(snapShot));
if (puzzlePivot.collectableObject != null)
{
collectableHelper.SetupCollectableLayerForPieces(puzzlePivot);
}
puzzlePivot.SetPiecePosition();
activePuzzlePivot = puzzlePivot;
activePuzzlePivot.SetDepthOfPieces();
}
private List <Piece> GetImportantPieces(PuzzlePivot pivot)
{
var result = new List <Piece>();
var collectablePosition = new Vector2(pivot.collectableObject.transform.position.x - pivot.collectableObject.transform.localScale.x / 2f,
pivot.collectableObject.transform.position.y - pivot.collectableObject.transform.localScale.y / 2f);
var collectableScale = new Vector2(pivot.collectableObject.transform.localScale.x, pivot.collectableObject.transform.localScale.y);
var collectableRect = new Rect(collectablePosition, collectableScale);
foreach (var snapablePoint in pivot.snapablePoints)
{
var piecePosition = new Vector2(snapablePoint.piece.transform.position.x - snapablePoint.piece.transform.localScale.x / 2f,
snapablePoint.piece.transform.position.y - snapablePoint.piece.transform.localScale.y / 2f);
var pieceScale = new Vector2(snapablePoint.piece.transform.localScale.x, snapablePoint.piece.transform.localScale.y);
var pieceRect = new Rect(piecePosition, pieceScale);
if (pieceRect.Overlaps(collectableRect))
{
result.Add(snapablePoint.piece);
}
}
return(result);
}
public void SetupCollectableLayerForPieces(PuzzlePivot pivot)
{
int piecesOnX = (int)pivot.numberOfPieces.x;
int piecesOnY = (int)pivot.numberOfPieces.y;
var scale = new Vector2(1f / piecesOnX, 1f / piecesOnY);
var shuffledPieces = pivot.pieces.OrderBy(x => UnityEngine.Random.Range(0, pivot.pieces.Count)).ToList( );
int i = 0;
foreach (var piece in shuffledPieces)
{
var x = Mathf.FloorToInt((float)i / piecesOnY);
var y = i % piecesOnY;
piece.CollectableLayerRenderer.gameObject.SetActive(true);
piece.CollectableLayerRenderer.material.SetTextureScale("_MainTex", scale);
piece.CollectableLayerRenderer.material.SetTextureOffset("_MainTex", new Vector2(x * scale.x, y * scale.y));
piece.CollectableLayerRenderer.material.SetTexture("_MainTex", snapShotCollectableLayer);
i++;
}
i = 0;
foreach (var snapablePoint in pivot.snapablePoints)
{
shuffledPieces[i].transform.localPosition = new Vector3(snapablePoint.position.x, snapablePoint.position.y, shuffledPieces[i].transform.localPosition.z);
snapablePoint.piece = shuffledPieces[i];
i++;
}
var importantPieces = GetImportantPieces(pivot);
collectableKeyPieceDictionary = KeyPieceDictionary.SetupKeyPieceDictionary(pivot, importantPieces);
foreach (var snapablePoint in pivot.snapablePoints)
{
snapablePoint.piece = null;
}
}
private PuzzlePivot SpawnExtraPivot(GameObject pivot, PuzzlePivotType type, Vector2 numberOfPieces)
{
PuzzlePivot puzzlePivot = null;
if (type == PuzzlePivotType.jigsaw)
{
puzzlePivot = new JigsawPuzzlePivot(pivot, sizeOfPicture, numberOfPieces, gameBoard, this);
}
if (type == PuzzlePivotType.sliding)
{
puzzlePivot = new SlidingPuzzlePivot(pivot, sizeOfPicture, numberOfPieces, gameBoard, this);
}
if (type == PuzzlePivotType.rotating)
{
puzzlePivot = new RotatingPuzzlePivot(pivot, sizeOfPicture, numberOfPieces, gameBoard, this);
}
if (type == PuzzlePivotType.time)
{
puzzlePivot = new TimePuzzlePivot(pivot, sizeOfPicture, numberOfPieces, gameBoard, this);
}
return(puzzlePivot);
}
public void CheckForCollectable(PuzzlePivot puzzlePivot, bool hasCollectedCollectable)
{
if (!LevelView.IsCollectableLayerOn || hasCollectedCollectable || puzzlePivot.collectableObject == null)
{
return;
}
if (puzzlePivot.collectableObject.activeSelf)
{
return;
}
if (collectableKeyPieceDictionary.IsPiecesPlacedCorrectly(puzzlePivot))
{
var collectableSnapablePoint = SnapablePoint.GetSnapablePointWithPieceId(puzzlePivot, collectableKeyPieceDictionary.keyPiece.id);
var offset = collectableKeyPieceDictionary.originalPosition - collectableSnapablePoint.piece.transform.localPosition;
offset.z = 0;
puzzlePivot.collectableObject.transform.localPosition -= offset;
puzzlePivot.collectableObject.SetActive(true);
foreach (var piece in puzzlePivot.pieces)
{
piece.CollectableLayerRenderer.gameObject.SetActive(false);
}
}
}
public TimePuzzlePivot(GameObject parent, Vector2 sizeOfPicture, Vector2 numberOfPieces, GameBoard gameboard, SubPuzzle subPuzzle) : base(parent, sizeOfPicture, numberOfPieces, gameboard, subPuzzle)
{
topPuzzlePivot = new JigsawPuzzlePivot(pivot, sizeOfPicture, numberOfPieces, gameboard, subPuzzle);
topPuzzlePivot.subPuzzle = subPuzzle;
}
public CombinedPuzzlePivot(GameObject parent, Vector2 sizeOfPicture, Vector2 numberOfPieces, GameBoard gameboard, SubPuzzle subPuzzle) : base(parent, sizeOfPicture, numberOfPieces, gameboard, subPuzzle)
{
internalPuzzlePivot = new JigsawPuzzlePivot(parent, sizeOfPicture, numberOfPieces, gameboard, subPuzzle);
internalPuzzlePivot.numberOfPieces = new Vector2(2, 2);
internalPuzzlePivot.subPuzzle = subPuzzle;
}
