public void OnEndDrag(PointerEventData eventData)
{
transform.position = new Vector3(transform.position.x, transform.position.y, originalPosition.z);
foreach (var puzzle in gameManager.puzzleElement)
{
currentCell = puzzle.GetComponent <PuzzleCell>();
if (Vector3.Distance(currentCell.originalPosition, transform.position) < 0.5f)
{
if (currentCell.cellVacant)
{
transform.position = currentCell.originalPosition;
currentCell.cellVacant = false;
returnCell = puzzle.GetComponent <PuzzleCell>();
break;
}
else
{
transform.position = startDragPos;
if (returnCell.originalPosition == transform.position)
{
returnCell.cellVacant = false;
break;
}
}
}
}
}
CellController _clickedCellController; // выделеная яечкйка
void Start()
{
_puzzle = PuzzleGame.Instance.GetNewGame(1);
for (int x = 0; x < 9; x++)
{
for (int y = 0; y < 9; y++)
{
PuzzleCell cell = _puzzle.GetCell(x, y);
cell.OnCellOpen += OnCellOpened;
var cellButton = GameObject.Find($"{x}_{y}");
CellController controller = cellButton.GetComponent <CellController>();
controller.Cell = cell;
controller.X = x; //колонка
controller.Y = y; //строка
controller.CellName = cellButton.name;
controller.CellClicked += OnCellClicked;
_cells[x, y] = controller;
controller.DrawCell();
}
}
//Find keypad buttons
for (int i = 1; i < 10; i++)
{
var keyPadButton = GameObject.Find($"Num{i}").GetComponent <Button>();
int number = i;
keyPadButton.onClick.AddListener(() => OnKeyPadButtonClicked(number));
}
}
public void OnItmClick(PuzzleCellBlock objBlock)
{
if (currentBlock != null)
{
Destroy(currentBlock.gameObject);
}
GameObject obj = Instantiate(objBlock.gameObject, Vector3.zero, Quaternion.identity) as GameObject;
obj.transform.SetParent(transform);
obj.transform.localPosition = Vector3.zero;
obj.transform.localScale = Vector3.one;
PuzzleCellBlock pzCellBlock = obj.GetComponent <PuzzleCellBlock> ();
foreach (Transform child in obj.transform)
{
PuzzleCell puzzleCell = child.gameObject.GetComponent <PuzzleCell> ();
PuzzleCell.CellType cellType = objBlock.cells.Find(k => k.transform.name == child.name).type;
pzCellBlock.cells.Add(new PuzzleCellBlock.PuzzleCellBlockType(cellType, child.GetComponent <RectTransform> ()));
}
CanvasGroup canvasGroup = obj.AddComponent <CanvasGroup> ();
canvasGroup.interactable = false;
canvasGroup.blocksRaycasts = false;
currentBlock = obj.GetComponent <RectTransform> ();
}
private void MarkCells(Map <PuzzleCell> map, List <V> points, PuzzleCell type)
{
var toAdd = points.ToList();
if (toAdd.Any() && type == PuzzleCell.Inside)
{
map[toAdd[0]] = type;
toAdd.RemoveAt(0);
}
while (toAdd.Any())
{
var pathBuilder = new PathBuilder(map, type);
var best = 0;
for (int i = 1; i < toAdd.Count; i++)
{
if (pathBuilder.Distance(toAdd[i]) < pathBuilder.Distance(toAdd[best]))
{
best = i;
}
}
var to = toAdd[best];
var path = pathBuilder.GetPath(to);
foreach (var x in path)
{
map[x] = type;
}
toAdd.RemoveAt(best);
}
}
public void SwapCellValue(PuzzleCell cell)
{
if (m_CurrentCell == null)
{
m_CurrentCell = cell;
}
else
{
// if user clicked on a cell twice, doesn't need to proceed
if (m_CurrentCell == cell)
{
m_CurrentCell = null;
return;
}
string temp = m_CurrentCell.m_CellText.text;
m_CurrentCell.m_CellText.text = cell.m_CellText.text;
cell.m_CellText.text = temp;
Utilities.Swap(ref m_CurrentCell.m_CellNumber, ref cell.m_CellNumber);
m_CurrentCell = null;
UpdatePuzzle();
}
}
private void Start()
{
int childCount = transform.childCount;
int index = 0;
for (int i = 0; i < Utilities.s_PuzzleDimension; i++)
{
for (int j = 0; j < Utilities.s_PuzzleDimension; j++)
{
// filling m_Puzzle cells information
transform.GetChild(index).gameObject.AddComponent <PuzzleCell>();
PuzzleCell cell = transform.GetChild(index).gameObject.GetComponent <PuzzleCell>();
cell.m_Row = i;
cell.m_Column = j;
if (index < Utilities.Pow(Utilities.s_PuzzleDimension, 2) - 1)
{
cell.m_CellNumber = index + 1;
cell.m_CellText.text = (index + 1).ToString();
}
else
{
cell.m_CellNumber = 0;
cell.m_CellText.text = "";
}
index++;
}
}
UpdatePuzzle();
}
public void StartConfig(string config)
{
switch (config)
{
case "Trial": //use the trial configuration
{
_puzzleLogic.Config_Trial(); //Call the trial configuration
short cellNumber = 1;
foreach (Button b in this.Children)
{
PuzzleCell location = _puzzleLogic.FindCell(cellNumber++);
b.SetValue(Grid.ColumnProperty, location.Col);
b.SetValue(Grid.RowProperty, location.Row);
}
} break;
case "ConfigA": //use the trial configuration
{
_puzzleLogic.Config_A(); //Call the trial configuration
} break;
case "ConfigB": //use the trial configuration
{
_puzzleLogic.Config_B(); //Call the trial configuration
} break;
}
}
void Awake()
{
originalPosition = transform.position;
gameManager = Camera.main.GetComponent <GameManager>();
currentCell = this;
returnCell = this;
}
public void StepBack(int move)
{
int qty = myCells.Length;
if (onGoal && positionHistory[move] != this.transform.position)
{
onGoal = false;
this.gameObject.SetActive(true);
}
if (horizontal && !onGoal)
{
firstCell = cellHistory[move];
for (int i = 0; i < qty; i++)
{
if (i == 0)
{
myCells[i] = firstCell;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
myCells[i].occupied = true;
}
else
{
myCells[i] = firstCell.CheckRightAmmount(i);
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
myCells[i].occupied = true;
}
if (i == (qty - 1))
{
lastCell = myCells[i];
}
}
}
else if (vertical && !onGoal)
{
firstCell = cellHistory[move];
for (int i = 0; i < qty; i++)
{
if (i == 0)
{
myCells[i] = firstCell;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
myCells[i].occupied = true;
}
else
{
myCells[i] = firstCell.CheckUpAmmount(i);
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
myCells[i].occupied = true;
}
if (i == (qty - 1))
{
lastCell = myCells[i];
}
}
}
nextPos = iniPos = currentPos = positionHistory[move];
this.transform.position = positionHistory[move];
movingToGoal = false;
}
// m_Puzzle will be set here
public void UpdatePuzzle()
{
for (int i = 0; i < transform.childCount; i++)
{
PuzzleCell cell = transform.GetChild(i).gameObject.GetComponent <PuzzleCell>();
m_Puzzle[cell.m_Row, cell.m_Column] = cell.m_CellNumber;
}
}
public void SetUpItem()
{
this.gameObject.SetActive(true);
for (int i = 0; i < startCells.Length; i++)
{
myCells[i] = startCells[i];
}
if (horizontal)
{
float maxX = -1000;
float minX = 1000;
foreach (PuzzleCell cell in myCells)
{
if (cell.gameObject.transform.position.x > maxX)
{
lastCell = cell;
maxX = cell.gameObject.transform.position.x;
}
if (cell.gameObject.transform.position.x < minX)
{
firstCell = cell;
minX = cell.gameObject.transform.position.x;
}
}
}
else if (vertical)
{
float maxY = -1000;
float minY = 1000;
foreach (PuzzleCell cell in myCells)
{
if (cell.gameObject.transform.position.y > maxY)
{
lastCell = cell;
maxY = cell.gameObject.transform.position.y;
}
if (cell.gameObject.transform.position.y < minY)
{
firstCell = cell;
minY = cell.gameObject.transform.position.y;
}
}
}
this.transform.position = startPos;
active = true;
onGoal = false;
movingToGoal = false;
foreach (PuzzleCell cell in myCells)
{
cell.occupied = true;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
}
maxX = iniMaxX = 4 - (myCells.Length * 0.5f);
minX = iniMinX = (myCells.Length * 0.5f) - 4;
maxY = iniMaxY = 3 - (myCells.Length * 0.5f);
minY = iniMinY = (myCells.Length * 0.5f) - 3;
}
public void ResetItem()
{
currentCell = initialCell;
currentCell.gameObject.GetComponent <HatShopCell>().myItem = this;
this.transform.position = initialCell.transform.position;
moving = false;
timer = 0;
verify = false;
CheckGoal();
}
public void MixUpPuzzle()
{
_puzzleLogic.MixUpPuzzle();
short cellNumber = 1;
foreach (KinectTileButton b in this.Children)
{
PuzzleCell location = _puzzleLogic.FindCell(cellNumber++);
b.SetValue(Grid.ColumnProperty, location.Col);
b.SetValue(Grid.RowProperty, location.Row);
}
}
public void MixUpPuzzle()
{ //*** SCRAMBLE THE PUZZLE ***
_puzzleLogic.MixUpPuzzle(); //Call MixUpPuzzle to shuffle and move the puzzles
short cellNumber = 1;
foreach (Button b in this.Children)
{
PuzzleCell location = _puzzleLogic.FindCell(cellNumber++);
b.SetValue(Grid.ColumnProperty, location.Col);
b.SetValue(Grid.RowProperty, location.Row);
}
}
void Update()
{
if (Input.GetMouseButtonDown(0) && isStart)
{
if (setColor)
{
if (currentItem != null)
{
// blockText = currentItem.letter.text;
currentItem.SetColor(currentColor, colors[currentColor]);
}
if (currentBlock != null && downItem != null)
{
if (downItem.blockIndex != -1)
{
currentBlock.SetText(downItem.letter.text);
currentBlock.SetColor(downItem.blockIndex, colors[downItem.blockIndex]);
downItem = null;
}
}
}
else
{
if (currentItem != null)
{
currentItem.SetText(letter);
}
}
}
if (Input.GetMouseButtonDown(1))
{
if (setColor)
{
if (currentBlock != null)
{
currentBlock.ClearColor();
}
if (currentItem != null)
{
currentItem.ClearColor();
}
}
else
{
if (currentItem != null)
{
currentItem.SetText("");
}
}
}
}
void parseLevelFile()
{
StreamReader reader = File.OpenText(Application.dataPath + "/Data/1.txt");
JSONObject j = new JSONObject(reader.ReadToEnd());
JSONObject target = j.GetField("game");
foreach (JSONObject jsonObj in target.list)
{
GameObject obj = Instantiate(cellPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj.transform.SetParent(targetContainer);
obj.transform.localScale = Vector3.one;
RectTransform reTrans = obj.GetComponent <RectTransform> ();
reTrans.anchoredPosition = new Vector2(jsonObj.GetField("x").f, jsonObj.GetField("y").f);
reTrans.eulerAngles = new Vector3(0f, 0f, jsonObj.GetField("rot").f);
PuzzleCell pc = obj.GetComponent <PuzzleCell> ();
pc.SetType((PuzzleCell.CellType)Enum.Parse(typeof(PuzzleCell.CellType), jsonObj.GetField("type").str));
cells.Add(pc);
}
JSONObject objects = j.GetField("objects");
foreach (JSONObject jsonObj in objects.list)
{
GameObject obj = Instantiate(cellBlockPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj.transform.SetParent(cellBlockContainer);
obj.transform.localScale = Vector3.one;
obj.transform.localPosition = Vector3.zero;
JSONObject tmp = jsonObj.GetField("obj");
int i = 0;
foreach (JSONObject jsonObjFigure in tmp.list)
{
GameObject obj1 = Instantiate(cellPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj1.transform.SetParent(obj.transform);
obj1.transform.localScale = Vector3.one;
obj1.name = i.ToString();
RectTransform rcTrans = obj1.GetComponent <RectTransform> ();
rcTrans.anchoredPosition = new Vector2(jsonObjFigure.GetField("x").f, jsonObjFigure.GetField("y").f);
rcTrans.eulerAngles = new Vector3(0f, 0f, jsonObjFigure.GetField("rot").f);
PuzzleCell pc = obj1.GetComponent <PuzzleCell> ();
pc.img.color = cellColor;
PuzzleCell.CellType t = (PuzzleCell.CellType)Enum.Parse(typeof(PuzzleCell.CellType), jsonObjFigure.GetField("type").str);
pc.SetType(t);
obj.GetComponent <PuzzleCellBlock> ().cells.Add(new PuzzleCellBlock.PuzzleCellBlockType(t, obj1.GetComponent <RectTransform> ()));
pc.enabled = false;
i++;
}
}
}
// Assumed to be a valid move.
private void MovePiece(KinectTileButton b, int row, int col)
{
PuzzleCell newPosition = _puzzleLogic.MovePiece(row, col);
b.SetValue(Grid.ColumnProperty, newPosition.Col);
b.SetValue(Grid.RowProperty, newPosition.Row);
if (_puzzleLogic.CheckForWin())
{
if (PuzzleWon != null)
{
PuzzleWon(this, EventArgs.Empty);
}
}
}
//克隆方格
private PuzzleCell CloneCell(int i, int j, int index)
{
PuzzleCell cell = Instantiate(wordCell, wordGroup);
cell.name = "word" + i.ToString() + j.ToString();
cell.GetComponent <RectTransform> ().anchoredPosition = new Vector2(cellOri.x + (min + 2) * j, cellOri.y - (min + 2) * i);
cell.pos.x = i;
cell.pos.y = j;
cell.SetText("");
cell.ClearColor();
cell.SetSize(min);
cell.transform.SetSiblingIndex(index);
cell.gameObject.SetActive(true);
return(cell);
}
/// <summary>
/// Moves the piece
/// </summary>
/// <param name="row"></param>
/// <param name="col"></param>
/// <returns>The cell of the newly opened position</returns>
public PuzzleCell MovePiece(int row, int col)
{
Debug.Assert(GetMoveStatus(row, col) != MoveStatus.BadMove);
var cell = new PuzzleCell(_emptyRow, _emptyCol, EmptyCellId);
var origCell = _cells[row, col];
_cells[_emptyRow, _emptyCol] = origCell;
_cells[row, col] = EmptyCellId;
_emptyCol = col;
_emptyRow = row;
return cell;
}
private void CalculateWord()
{
int index = 0;
for (int i = 0; i < row; i++)
{
List <string> letters = new List <string> ();
List <string> hintInfo = new List <string> ();
List <int> loadColor = new List <int> ();
for (int j = 0; j < col; j++)
{
List <CellInfo> list = new List <CellInfo> ();
CellInfo info = new CellInfo();
PuzzleCell cell = wordGroup.GetChild(index).GetComponent <PuzzleCell> ();
letters.Add(cell.letter.text);
hintInfo.Add(hintGroup.GetChild(index).GetComponent <InputField>().text);
//loadData相关
loadColor.Add(cell.blockIndex);
//end
if (cell.blockIndex != -1 && !string.IsNullOrEmpty(cell.letter.text))
{
info.pos = cell.pos;
info.letter = cell.letter.text;
if (wordPosDic.ContainsKey(cell.blockIndex))
{
list = wordPosDic[cell.blockIndex];
list.Add(info);
wordPosDic[cell.blockIndex] = list;
}
else
{
list.Add(info);
wordPosDic.Add(cell.blockIndex, list);
}
}
index++;
}
data.wordInfo.Add(letters);
data.hintInfo.Add(hintInfo);
loadData.wordInfo.Add(letters);
loadData.hintInfo.Add(hintInfo);
loadData.wordColorIndex.Add(loadColor);
}
}
public void OnTargetClick()
{
if (currentBlock == null)
{
return;
}
PuzzleCellBlock block = currentBlock.GetComponent <PuzzleCellBlock> ();
List <PuzzleCell> cellsOnTarget = new List <PuzzleCell> ();
foreach (PuzzleCellBlock.PuzzleCellBlockType bCell in block.cells)
{
float dist = Mathf.Infinity;
PuzzleCell findedCell = null;
foreach (PuzzleCell puzzleCell in cells)
{
if (cellsOnTarget.Contains(puzzleCell))
{
continue;
}
float val = Vector2.Distance(bCell.transform.position, puzzleCell.rectTransform.position);
if (val < dist)
{
dist = val;
findedCell = puzzleCell;
}
}
if (findedCell != null && findedCell.typeCell == bCell.type && findedCell.IsActive &&
allowInsert(findedCell.rectTransform.eulerAngles.z, bCell.transform.eulerAngles.z, reverseTypes [findedCell.typeCell]))
{
cellsOnTarget.Add(findedCell);
}
else
{
Debug.Log("Inappropriate block");
return;
}
}
for (int i = 0; i < cellsOnTarget.Count; i++)
{
cellsOnTarget [i].GetComponent <Image> ().color = cellColor;
cellsOnTarget [i].IsActive = false;
}
Destroy(currentBlock.gameObject);
}
void Update()
{
if (moving)
{
myLevel.movingItem = true;
timer += Time.deltaTime / moveDur;
this.transform.position = Vector3.Lerp(currentCell.transform.position, nextCell.transform.position, timer);
if (timer >= 1)
{
timer = 0f;
currentCell = nextCell;
moving = false;
currentCell.gameObject.GetComponent <HatShopCell>().myItem = this;
verify = true;
CheckGoal();
}
}
}
private void Awake()
{
instance = this;
levelText.text = string.Format(levelText.text, "Puzzle");
cellOri = wordCell.GetComponent <RectTransform> ().anchoredPosition;
min = wordCell.GetComponent <RectTransform> ().sizeDelta.x;
blockOri = block.GetComponent <RectTransform> ().anchoredPosition;
InitColor();
SetColor();
saveBtn.onClick.AddListener(() => {
Save();
modifierWord.gameObject.SetActive(false);
startSetBlock.gameObject.SetActive(false);
});
modifierWord.onClick.AddListener(() => {
currentBlock = null;
currentItem = null;
downItem = null;
//blockText = "";
blockGroup.gameObject.SetActive(false);
wordGroup.gameObject.SetActive(true);
opGroup.SetActive(true);
letterGroup.SetActive(true);
colorGroup.SetActive(false);
modifierWord.gameObject.SetActive(false);
startSetBlock.gameObject.SetActive(true);
saveBtn.gameObject.SetActive(false);
setColor = false;
});
startSetBlock.onClick.AddListener(() => {
modifierWord.gameObject.SetActive(true);
blockGroup.gameObject.SetActive(true);
SetHintCell();
SetBlockGrid();
setColor = true;
opGroup.SetActive(false);
letterGroup.SetActive(false);
colorGroup.SetActive(true);
currentItem = null;
letter = "";
startSetBlock.gameObject.SetActive(false);
saveBtn.gameObject.SetActive(true);
});
}
public PathBuilder(Map <PuzzleCell> map, PuzzleCell type)
{
this.map = map;
var queue = new LinkedList <V>();
for (int x = -1; x <= map.SizeX; x++)
{
for (int y = -1; y <= map.SizeY; y++)
{
var v = new V(x, y);
if (type == PuzzleCell.Inside && v.Inside(map) && map[v] == type ||
type == PuzzleCell.Outside && (!v.Inside(map) || map[v] == type))
{
queue.AddLast(v);
}
}
}
distance = new Map <int>(map.SizeX, map.SizeY);
parent = new Map <V>(map.SizeX, map.SizeY);
while (queue.Any())
{
var v = queue.First();
queue.RemoveFirst();
for (var direction = 0; direction < 4; direction++)
{
var u = v.Shift(direction);
if (!u.Inside(map) || parent[u] != null || map[u] != PuzzleCell.Unknown)
{
continue;
}
parent[u] = v;
distance[u] = (v.Inside(map) ? distance[v] : 0) + 1;
queue.AddLast(u);
}
}
}
//设置单词格子
private void SetWordGrid()
{
Calculate();
int index = 0;
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
if (i == 0 && j == 0)
{
wordCell.ClearColor();
wordCell.pos.x = i;
wordCell.pos.y = j;
wordCell.gameObject.SetActive(true);
wordCell.SetSize(min);
if (loadData.wordInfo.Count != 0 && loadData.wordColorIndex[i][j] != -1)
{
wordCell.SetText(loadData.wordInfo[i][j]);
wordCell.SetColor(loadData.wordColorIndex[i][j], colors[loadData.wordColorIndex[i][j]]);
}
}
else
{
PuzzleCell cell = CloneCell(i, j, index);
if (loadData.wordInfo.Count != 0 && loadData.wordColorIndex[i][j] != -1)
{
cell.SetText(loadData.wordInfo[i][j]);
cell.SetColor(loadData.wordColorIndex[i][j], colors[loadData.wordColorIndex[i][j]]);
}
}
index++;
}
}
isStart = true;
}
private void MovePiece(GazeAgumentedButton b, int row, int col)
{ //*** MOVE THE TILE, ASSUMING THE MOVE IS VALID***
//Identify the cell to move
PuzzleCell newPosition = _puzzleLogic.MovePiece(row, col);
try
{
//change the position of the tile in the grid
b.SetValue(Grid.ColumnProperty, newPosition.Col);
b.SetValue(Grid.RowProperty, newPosition.Row);
//increment moves by 1
_moves++;
//Once the piece has been moved, then allow the next piece to be moved
_isProcessingButton = false;
//this.IsEnabled = true;//enable the grid
}
catch (Exception ex)
{
MessageBox.Show("Movement error !!!", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public bool CheckOnClimax(PuzzleCell cell)
{
int count = 0;
foreach (PuzzleCell.PlantType p in cell.plantsToGrow)
{
Debug.Log("Iterou");
if (cell.progressToWin.Contains(p))
{
Debug.Log("Count++");
count++;
}
}
if (count >= cell.plantsToGrow.Count)
{
Debug.Log("Alcançou");
return(true);
}
else
{
return(false);
}
}
public void MoveVertical(float curPos, float prevPos)
{
if (lastCell.CheckUp().goalCell)
{
maxY = iniMaxY + cellDistance;
}
else
{
maxY = iniMaxY;
}
if (firstCell.CheckDown().goalCell)
{
minY = iniMinY - cellDistance;
}
else
{
minY = iniMinY;
}
if (!selected)
{
iniPos = this.gameObject.transform.position;
selected = true;
nextPos = iniPos;
}
float Diff = Mathf.Abs(curPos - prevPos);
if (Diff > maxDiff)
{
Diff = maxDiff;
}
if (curPos > prevPos)
{
//moving UP
nextPos.y += Diff;
pushingPos.y += Diff;
if (nextPos.y > iniPos.y)
{
//Is moving UP from the starting point
if (!directionController)
{
directionController = true;
SetPushedBaguette();
pushing = false;
if (movingToGoal)
{
movingToGoal = false;
}
}
if (!lastCell.edgeUp)
{
//no board edge up
if (!lastCell.cellUp.occupied)
{
//no baguette in the next up cell
canMove = true;
if (lastCell.cellUp.goalCell)
{
//code for checking goal
if (lastCell.cellUp.gameObject.GetComponent <BakeryGoalCell>().myColor.ToString() == myColor.ToString())
{
canMove = true;
movingToGoal = true;
}
else
{
canMove = false;
}
}
}
else
{
if (!baguetteToPush)
{
baguetteToPush = lastCell.cellUp.gameObject.GetComponent <BakeryCellConn>().mybaguette;
BTPcurrentPos = baguetteToPush.transform.position;
float adjustedY = nextPos.y + ((myCells.Length * 0.5f) + 0.5f);
baguetteToPush.transform.position = new Vector3(baguetteToPush.transform.position.x, adjustedY, baguetteToPush.transform.position.z);
pushingPos = baguetteToPush.transform.position;
}
if (baguetteToPush.CheckAllUp())
{
//can push UP
pushing = true;
canMove = true;
}
else
{
// cant push UP
SetPushedBaguette();
baguetteToPush = null;
canMove = false;
maxY = iniPos.y;
this.gameObject.transform.position = iniPos;
}
}
}
else
{
canMove = false;
maxY = iniPos.y;
this.gameObject.transform.position = iniPos;
}
}
else if (nextPos.y > this.gameObject.transform.position.y)
{
//Is moving UP towards the starting point
canMove = true;
}
if (Mathf.Abs(nextPos.y - iniPos.y) >= minDistance && canMove)
{
List <PuzzleCell> tempCells = new List <PuzzleCell>();
if (baguetteToPush)
{
foreach (PuzzleCell cell in baguetteToPush.myCells)
{
tempCells.Add(cell.CheckUpAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
baguetteToPush.myCells[i] = tempCells[i];
baguetteToPush.myCells[i].occupied = true;
baguetteToPush.myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = baguetteToPush;
}
baguetteToPush.firstCell = baguetteToPush.firstCell.CheckUpAmmount(1);
baguetteToPush.lastCell = baguetteToPush.lastCell.CheckUpAmmount(1);
tempCells.Clear();
BTPcurrentPos.y += cellDistance;
baguetteToPush.iniPos = BTPcurrentPos;
baguetteToPush.currentPos = BTPcurrentPos;
}
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
tempCells.Add(cell.CheckUpAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
myCells[i] = tempCells[i];
myCells[i].occupied = true;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
}
//update edge cells
firstCell = firstCell.CheckUpAmmount(1);
lastCell = lastCell.CheckUpAmmount(1);
tempCells.Clear();
currentPos.y += cellDistance;
iniPos = currentPos;
if (movingToGoal)
{
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
onGoal = true;
this.gameObject.SetActive(false);
canMove = false;
}
}
}
}
else
{
//moving DOWN
nextPos.y -= Diff;
pushingPos.y -= Diff;
if (nextPos.y < iniPos.y)
{
//Is moving DOWN from the starting point
if (directionController)
{
directionController = false;
SetPushedBaguette();
pushing = false;
if (movingToGoal)
{
movingToGoal = false;
}
}
if (!firstCell.edgeDown)
{
if (!firstCell.cellDown.occupied)
{
//no baguette in the next down cell
canMove = true;
if (firstCell.cellDown.goalCell)
{
//code for checking goal
if (firstCell.cellDown.gameObject.GetComponent <BakeryGoalCell>().myColor.ToString() == myColor.ToString())
{
canMove = true;
movingToGoal = true;
}
else
{
canMove = false;
}
}
}
else
{
if (!baguetteToPush)
{
baguetteToPush = firstCell.cellDown.gameObject.GetComponent <BakeryCellConn>().mybaguette;
//baguetteToPush.transform.position = new Vector3(baguetteToPush.transform.position.x,(baguetteToPush.transform.position.y - (this.transform.position.y - iniPos.y)),baguetteToPush.transform.position.z);
BTPcurrentPos = baguetteToPush.transform.position;
float adjustedY = nextPos.y - ((myCells.Length * 0.5f) + 0.5f);
baguetteToPush.transform.position = new Vector3(baguetteToPush.transform.position.x, adjustedY, baguetteToPush.transform.position.z);
pushingPos = baguetteToPush.transform.position;
//pushingPos.y += (this.transform.position.y - iniPos.y);
}
if (baguetteToPush.CheckAllDown())
{
//can push down
pushing = true;
canMove = true;
}
else
{
// cant push down
SetPushedBaguette();
baguetteToPush = null;
minY = iniPos.y;
canMove = false;
this.gameObject.transform.position = iniPos;
}
}
}
else
{
canMove = false;
minY = iniPos.y;
this.gameObject.transform.position = iniPos;
}
}
else if (nextPos.y < this.gameObject.transform.position.y)
{
//Is moving DOWN towards the starting point
canMove = true;
}
if (Mathf.Abs(nextPos.y - iniPos.y) >= minDistance && canMove)
{
List <PuzzleCell> tempCells = new List <PuzzleCell>();
if (baguetteToPush)
{
foreach (PuzzleCell cell in baguetteToPush.myCells)
{
tempCells.Add(cell.CheckDownAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
baguetteToPush.myCells[i] = tempCells[i];
baguetteToPush.myCells[i].occupied = true;
baguetteToPush.myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = baguetteToPush;
}
baguetteToPush.firstCell = baguetteToPush.firstCell.CheckDownAmmount(1);
baguetteToPush.lastCell = baguetteToPush.lastCell.CheckDownAmmount(1);
tempCells.Clear();
BTPcurrentPos.y -= cellDistance;
baguetteToPush.iniPos = BTPcurrentPos;
baguetteToPush.currentPos = BTPcurrentPos;
}
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
tempCells.Add(cell.CheckDownAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
myCells[i] = tempCells[i];
myCells[i].occupied = true;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
}
//update edge cells
firstCell = firstCell.CheckDownAmmount(1);
lastCell = lastCell.CheckDownAmmount(1);
tempCells.Clear();
currentPos.y -= cellDistance;
iniPos = currentPos;
if (movingToGoal)
{
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
onGoal = true;
this.gameObject.SetActive(false);
canMove = false;
}
}
}
}
if (canMove)
{
if (nextPos.y > maxY)
{
nextPos.y = maxY;
}
if (nextPos.y < minY)
{
nextPos.y = minY;
}
this.gameObject.transform.position = nextPos;
if (baguetteToPush)
{
baguetteToPush.gameObject.transform.position = pushingPos;
}
}
}
public void MoveHorizontal(float curPos, float prevPos)
{
if (lastCell.CheckRight().goalCell)
{
maxX = iniMaxX + cellDistance;
}
else
{
maxX = iniMaxX;
}
if (firstCell.CheckLeft().goalCell)
{
minX = iniMinX - cellDistance;
}
else
{
minX = iniMinX;
}
if (!selected)
{
iniPos = this.gameObject.transform.position;
selected = true;
nextPos = iniPos;
}
float Diff = Mathf.Abs(curPos - prevPos);
if (Diff > maxDiff)
{
Diff = maxDiff;
}
if (curPos > prevPos)
{
//moving right
nextPos.x += Diff;
pushingPos.x += Diff;
if (nextPos.x > iniPos.x)
{
//Is moving right from the starting point
if (!directionController)
{
directionController = true;
SetPushedBaguette();
pushing = false;
if (movingToGoal)
{
movingToGoal = false;
}
}
if (!lastCell.edgeRight)
{
//no board edge right
if (!lastCell.cellRight.occupied)
{
//no baguette in the next right cell
canMove = true;
if (lastCell.cellRight.goalCell)
{
//code for checking goal
if (lastCell.cellRight.gameObject.GetComponent <BakeryGoalCell>().myColor.ToString() == myColor.ToString())
{
canMove = true;
movingToGoal = true;
}
else
{
canMove = false;
}
}
}
else
{
if (!baguetteToPush)
{
baguetteToPush = lastCell.cellRight.gameObject.GetComponent <BakeryCellConn>().mybaguette;
BTPcurrentPos = baguetteToPush.transform.position;
float adjustedX = nextPos.x + ((myCells.Length * 0.5f) + 0.5f);
baguetteToPush.transform.position = new Vector3(adjustedX, baguetteToPush.transform.position.y, baguetteToPush.transform.position.z);
pushingPos = baguetteToPush.transform.position;
}
if (baguetteToPush.CheckAllRight())
{
//can push right
pushing = true;
canMove = true;
}
else
{
// cant push right
SetPushedBaguette();
baguetteToPush = null;
maxX = iniPos.x;
canMove = false;
this.gameObject.transform.position = iniPos;
}
}
}
else
{
maxX = iniPos.x;
canMove = false;
this.gameObject.transform.position = iniPos;
}
}
else if (nextPos.x > this.gameObject.transform.position.x)
{
//Is moving right towards the starting point
canMove = true;
}
if (Mathf.Abs(nextPos.x - iniPos.x) >= minDistance && canMove)
{
List <PuzzleCell> tempCells = new List <PuzzleCell>();
if (baguetteToPush)
{
foreach (PuzzleCell cell in baguetteToPush.myCells)
{
tempCells.Add(cell.CheckRightAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
baguetteToPush.myCells[i] = tempCells[i];
baguetteToPush.myCells[i].occupied = true;
baguetteToPush.myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = baguetteToPush;
}
baguetteToPush.firstCell = baguetteToPush.firstCell.CheckRightAmmount(1);
baguetteToPush.lastCell = baguetteToPush.lastCell.CheckRightAmmount(1);
tempCells.Clear();
BTPcurrentPos.x += cellDistance;
baguetteToPush.iniPos = BTPcurrentPos;
baguetteToPush.currentPos = BTPcurrentPos;
}
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
tempCells.Add(cell.CheckRightAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
myCells[i] = tempCells[i];
myCells[i].occupied = true;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
}
//update edge cells
firstCell = firstCell.CheckRightAmmount(1);
lastCell = lastCell.CheckRightAmmount(1);
tempCells.Clear();
currentPos.x += cellDistance;
iniPos = currentPos;
if (movingToGoal)
{
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
onGoal = true;
this.gameObject.SetActive(false);
canMove = false;
}
}
}
}
else
{
//moving left
nextPos.x -= Diff;
pushingPos.x -= Diff;
if (nextPos.x < iniPos.x)
{
//Is moving left from the starting point
if (directionController)
{
directionController = false;
SetPushedBaguette();
pushing = false;
if (movingToGoal)
{
movingToGoal = false;
}
}
if (!firstCell.edgeLeft)
{
//no board edge up
if (!firstCell.cellLeft.occupied)
{
//no baguette in the next up cell
canMove = true;
if (firstCell.cellLeft.goalCell)
{
//code for checking goal
if (firstCell.cellLeft.gameObject.GetComponent <BakeryGoalCell>().myColor.ToString() == myColor.ToString())
{
canMove = true;
movingToGoal = true;
}
else
{
canMove = false;
}
}
}
else
{
// next left cell is occupied
if (!baguetteToPush)
{
baguetteToPush = firstCell.cellLeft.gameObject.GetComponent <BakeryCellConn>().mybaguette;
BTPcurrentPos = baguetteToPush.transform.position;
float adjustedX = nextPos.x - ((myCells.Length * 0.5f) + 0.5f);
baguetteToPush.transform.position = new Vector3(adjustedX, baguetteToPush.transform.position.y, baguetteToPush.transform.position.z);
pushingPos = baguetteToPush.transform.position;
}
if (baguetteToPush.CheckAllLeft())
{
//can push left
pushing = true;
canMove = true;
}
else
{
// cant push left
SetPushedBaguette();
baguetteToPush = null;
minX = iniPos.x;
canMove = false;
this.gameObject.transform.position = iniPos;
}
}
}
else
{
minX = iniPos.x;
canMove = false;
this.gameObject.transform.position = iniPos;
}
}
else if (nextPos.x < this.gameObject.transform.position.x)
{
//Is moving left towards the starting point
canMove = true;
}
if (Mathf.Abs(nextPos.x - iniPos.x) >= minDistance && canMove)
{
List <PuzzleCell> tempCells = new List <PuzzleCell>();
if (baguetteToPush)
{
foreach (PuzzleCell cell in baguetteToPush.myCells)
{
tempCells.Add(cell.CheckLeftAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
baguetteToPush.myCells[i] = tempCells[i];
baguetteToPush.myCells[i].occupied = true;
baguetteToPush.myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = baguetteToPush;
}
baguetteToPush.firstCell = baguetteToPush.firstCell.CheckLeftAmmount(1);
baguetteToPush.lastCell = baguetteToPush.lastCell.CheckLeftAmmount(1);
tempCells.Clear();
BTPcurrentPos.x -= cellDistance;
baguetteToPush.iniPos = BTPcurrentPos;
baguetteToPush.currentPos = BTPcurrentPos;
}
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
tempCells.Add(cell.CheckLeftAmmount(1));
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
}
for (int i = 0; i < tempCells.Count; i++)
{
//occupie (hmmm pie I want pie, give me pie X if you are reading this, I know is written occupy but whatever) new baguette cells and assign baguette
myCells[i] = tempCells[i];
myCells[i].occupied = true;
myCells[i].gameObject.GetComponent <BakeryCellConn>().mybaguette = this;
}
//update edge cells
firstCell = firstCell.CheckLeftAmmount(1);
lastCell = lastCell.CheckLeftAmmount(1);
tempCells.Clear();
currentPos.x -= cellDistance;
iniPos = currentPos;
if (movingToGoal)
{
foreach (PuzzleCell cell in myCells)
{
//free current baguette cells and get new cells
cell.occupied = false;
cell.gameObject.GetComponent <BakeryCellConn>().mybaguette = null;
onGoal = true;
this.gameObject.SetActive(false);
canMove = false;
}
}
}
}
if (canMove)
{
if (nextPos.x > maxX)
{
nextPos.x = maxX;
}
if (nextPos.x < minX)
{
nextPos.x = minX;
}
this.gameObject.transform.position = nextPos;
if (baguetteToPush)
{
baguetteToPush.gameObject.transform.position = pushingPos;
}
}
}
void parseLevelMass()
{
float xPos = 0f;
float yPos = 0f;
float offset = cellPrefab.GetComponent <RectTransform>().rect.width;
for (int i = 0; i < ySize; i++)
{
for (int j = 0; j < xSize; j++)
{
xPos += offset / 4f;
PuzzleCell.CellType cellType = levelMass[i, j].type;
if (cellType == PuzzleCell.CellType.none)
{
continue;
}
float rot = levelMass[i, j].angle;
GameObject obj = Instantiate(cellPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj.transform.SetParent(targetContainer);
obj.transform.localScale = Vector3.one;
RectTransform reTrans = obj.GetComponent <RectTransform> ();
reTrans.anchoredPosition = new Vector2(xPos, yPos);
reTrans.eulerAngles = new Vector3(0f, 0f, rot);
PuzzleCell pc = obj.GetComponent <PuzzleCell> ();
pc.SetType(cellType);
cells.Add(pc);
}
xPos = 0f;
yPos -= offset / 4f;
}
targetContainer.anchoredPosition = new Vector2(targetContainer.anchoredPosition.x - (xSize * offset / 8f), targetContainer.anchoredPosition.y + (ySize * offset / 8f));
for (int i = 0; i < levelMassItems.Count; i++)
{
GameObject obj = Instantiate(cellBlockPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj.transform.SetParent(cellBlockContainer);
obj.transform.localScale = Vector3.one;
obj.transform.localPosition = Vector3.zero;
xPos = -((offset / 4f) * 2f);
yPos = offset / 4f;
for (int k = 0; k < 3; k++)
{
for (int d = 0; d < 3; d++)
{
xPos += offset / 4f;
if (levelMassItems[i][k, d].type == PuzzleCell.CellType.none)
{
continue;
}
GameObject obj1 = Instantiate(cellPrefab, Vector3.zero, Quaternion.identity) as GameObject;
obj1.transform.SetParent(obj.transform);
obj1.transform.localScale = Vector3.one;
obj1.name = k.ToString() + d.ToString();
RectTransform rcTrans = obj1.GetComponent <RectTransform> ();
rcTrans.anchoredPosition = new Vector2(xPos, yPos);
rcTrans.eulerAngles = new Vector3(0f, 0f, levelMassItems[i][k, d].angle);
PuzzleCell pc = obj1.GetComponent <PuzzleCell> ();
pc.img.color = cellColor;
pc.SetType(levelMassItems[i][k, d].type);
obj.GetComponent <PuzzleCellBlock> ().cells.Add(new PuzzleCellBlock.PuzzleCellBlockType(levelMassItems[i][k, d].type, obj1.GetComponent <RectTransform> ()));
pc.enabled = false;
}
xPos = -((offset / 4f) * 2f);
yPos -= offset / 4f;
}
}
}
