public void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped)
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) // 그렇지 않았을 떄
{
if (wasFlipped)
{
FlipPieces(piece.index, flippedPiece.index, false);
}
}
else // match 를 만들었을 때
{
foreach (Point pnt in connected) // 연결됫을 때 노드피스들 지워주기
{
//점수 더해주는 부분
scoreMng.Score += 10;
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip); // 업데이트 이후 플립 삭제
update.Remove(piece);
}
}
// Update is called once per frame
void FixedUpdate()
{
GUIManager.instance.FillBar.fillAmount = Mathf.Lerp(GUIManager.instance.FillBar.fillAmount, GUIManager.instance.filledBar / GUIManager.instance.maxFill, fillSpeed);
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) // if we flipped to make this update
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) // if we didn't make a match
{
if (wasFlipped) // if we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); // Flip back
}
}
else // if we made a match
{
foreach (Point pnt in connected) // Remove the node pieces connected
{
//movedPiece = true;
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip); // remove the flip after update
update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < model.update.Count; i++)
{
NodePiece piece = model.update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
model.fills[x] = Mathf.Clamp(model.fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) //If we flipped to make this update
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) //If we didn't make a match
{
if (wasFlipped) //If we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); //Flip back
}
}
else //If we made a match
{
foreach (Point pnt in connected) //Remove the node pieces connected
{
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
model.dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
model.flipped.Remove(flip); //Remove the flip after update
model.update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = GetFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped)
{
flippedPiece = flip.GetOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0)
{
if (wasFlipped)
{
FlipPieces(piece.index, flippedPiece.index, false);
}
}
else
{
foreach (Point pnt in connected)
{
KillPiece(pnt);
Node node = GetNodeAtPoint(pnt);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip);
update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.updatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) // ha felcseréltük akkor hyvjuk meg az update-t
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) // Ha nincs matchünk
{
if (wasFlipped) // Ha felcseréltük
{
FlipPieces(piece.index, flippedPiece.index, false); //Visszacserélés
}
}
else // Ha match van
{
foreach (Point pnt in connected) //Összekapcsoltakat kivesszük
{
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (piece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip);
update.Remove(piece);
}
}
// Update is called once per frame
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < piecesToUpdate.Count; i++)
{
NodePiece piece = piecesToUpdate[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
foreach (NodePiece piece in finishedUpdating)
{
FlippedPieces flipDuo = getFlipped(piece);
bool wasFlipped = (flipDuo != null);
int x = piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Coord> connected = isConnected(piece.index, true);
if (wasFlipped) // If we flipped to make this update
{
NodePiece flippedPiece = flipDuo.getOtherPiece(piece);
AddConnectedGems(ref connected, isConnected(flippedPiece.index, true));
if (connected.Count == 0) // If we didn't make a match...
{
FlipPieces(piece.index, flippedPiece.index, false); // ...flip back
}
}
if (connected.Count > 0) // if we did make a match
{
scoreSystem.IncrementScore(connected.Count);
foreach (Coord coord in connected) // Remove the node pieces connected
{
KillPiece(coord);
Node node = getNodeAtCoord(coord);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
piecesToFlip.Remove(flipDuo); // Remove the flip after done
piecesToUpdate.Remove(piece);
}
}
void removeFlipped(NodePiece p)
{
FlippedPieces flip = null;
for (int i = 0; i < flipped.Count; i++)
{
if (flipped[i].getOtherPiece(p) != null)
{
flip = flipped[i];
}
}
}
private void RemoveFlipped(GamePiece p)
{
FlippedPieces flip = null;
for (int i = 0; i < flipped.Count; i++)
{
if (flipped[i].GetOtherGamePiece(p) != null)
{
flip = flipped[i];
break;
}
}
}
FlippedPieces getFlipped(NodePiece p)
{
FlippedPieces flip = null;
for (int i = 0; i < flipped.Count; i++)
{
if (flipped[i].getOtherPiece(p) != null)
{
flip = flipped[i];
break;
}
}
return(flip);
}
//Ha a megadott piece flipelve lett nem null értékkel, visszaadjuk a párját
FlippedPieces GetFlipped(Piece p)
{
FlippedPieces flip = null;
for (int i = 0; i < flippedPieceList.Count; i++)
{
if (flippedPieceList[i].GetOtherPiece(p) != null)
{
flip = flippedPieceList[i];
break;
}
}
return(flip);
}
FlippedPieces getFlipped(NodePiece ref_piece)
{
FlippedPieces flip_duo = null;
for (int i = 0; i < piecesToFlip.Count; i++)
{
if (piecesToFlip[i].getOtherPiece(ref_piece) != null)
{
flip_duo = piecesToFlip[i];
break;
}
}
return(flip_duo);
}
private FlippedPieces GetFlipped(NodePiece p)
{
FlippedPieces flip = null;
for (int i = 0; i < _flipped.Count; i++)
{
if (_flipped[i].GetOtherPiece(p) != null)
{
flip = _flipped[i];
break;
}
}
return(flip);
}
void Update()
{
List <GamePiece> finishedUpdating = new List <GamePiece>();
for (int i = 0; i < update.Count; i++)
{
GamePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
GamePiece piece = finishedUpdating[i];
FlippedPieces flip = GetFlipped(piece);
GamePiece flippedPiece = null;
int x = piece.Index.X;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = IsConnected(piece.Index, true);
bool wasFlipped = (flip != null);
if (wasFlipped)
{
flippedPiece = flip.GetOtherGamePiece(piece);
AddPoints(ref connected, IsConnected(flippedPiece.Index, true));
}
if (connected.Count == 0) //If we didtn't make match
{
if (wasFlipped)
{
FlipPieces(piece.Index, flippedPiece.Index, false);
}
}
else //If made a match
{
//Remove pieces connected
foreach (var point in connected)
{
KillPieceAtPoint(point);
Node node = GetNodeAtPoint(point);
GamePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip);
update.Remove(piece);
}
}
void Update()
{
if (timer)
{
totalTime += Time.deltaTime;
score.text = ((int)targetTime).ToString();
targetTime -= Time.deltaTime;
if (targetTime <= 0.0f)
{
timerEnded();
}
}
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) //If we flipped to make this update
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) //If we didn't make a match
{
if (wasFlipped) //If we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); //Flip back
}
}
else //If we made a match
{
foreach (Point pnt in connected) //Remove the node pieces connected
{
if (timer)
{
targetTime += .5f;
}
else
{
scoreCount += 1;
score.text = scoreCount.ToString();
}
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip); //Remove the flip after update
update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) //
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) //¸ø¸ÂŸÀ»¶§
{
if (wasFlipped) //
{
FlipPieces(piece.index, flippedPiece.index, false); //¸ø¸ÂÃá ¸ð¾çÀº ´Ù½Ã ¿ø·¡ÀÚ¸®·Î
}
}
else //¸ÂŸÀ»¶§
{
foreach (Point pnt in connected) //¸ÂÃá ¸ð¾çÀº »èÁ¦(²ô±â)
{
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece); ///////////////////////////////////////////
}
node.SetPiece(null);
////////// Á¡¼öºÎ¿© : (±âº») 3¸ÅÄ¡ = 5Á¡, 4¸ÅÄ¡ = 10Á¡, 5¸ÅÄ¡ = 20Á¡, 6¸ÅÄ¡ÀÌ»ó = 40Á¡
if (connected.Count == 3)
{
GameObject.Find("scoreUI").GetComponent <ScoreUI>().score += 5;
}
else if (connected.Count == 4)
{
GameObject.Find("scoreUI").GetComponent <ScoreUI>().score += 10;
}
else if (connected.Count == 5)
{
GameObject.Find("scoreUI").GetComponent <ScoreUI>().score += 20;
}
else if (connected.Count > 6)
{
GameObject.Find("scoreUI").GetComponent <ScoreUI>().score += 40;
}
/////////////////////////////////
}
ApplyGravityToBoard();
}
flipped.Remove(flip); //
update.Remove(piece);
}
}
void Update()
{
if (gameFinished == false)
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
timerText.text = "Time: " + timeRemaining.ToString();
if (score >= targetScore)
{
gameFinished = true;
CancelInvoke(nameof(UpdateMatch3Game));
resultsPanel.SetActive(true);
audioSource.clip = audioClips[1];
audioSource.Play();
Debug.Log("Game Complete - You Win!");
}
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (piece.UpdatePiece() == false)
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = GetFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = IsConnected(piece.index, true);
bool wasFlipped = (flip != null);
// If flipped make this update
if (wasFlipped)
{
flippedPiece = flip.GetOtherPiece(piece);
AddPoints(ref connected, IsConnected(flippedPiece.index, true));
}
// If match wasn't made
if (connected.Count == 0)
{
// If flipped
if (wasFlipped)
{
FlipPieces(piece.index, flippedPiece.index, false); // Flip pieces back
}
}
else // If match is made
{
// Remove the node pieces that are connected
foreach (Point p in connected)
{
KillPiece(p);
Node node = GetNodeAtPoint(p);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
audioSource.clip = audioClips[0];
audioSource.Play();
ApplyGravityToBoard();
}
// Remove the flip after update
flipped.Remove(flip);
update.Remove(piece);
}
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped && flipBackAfterWrongMove) // czy bez braku matcha ma zawracac na stare miejsce czy nie
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) // jezeli nie ma spasowania
{
if (wasFlipped && flipBackAfterWrongMove)
{
FlipPieces(piece.index, flippedPiece.index, false);
}
}
else
{ // jezeli jest spasowanie
bool counter = true;
foreach (Point pnt in connected) // Remove the node pieces connected
{
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (counter == true)
{
PieceToSpawn = nodePiece;
counter = false;
}
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
//Debug.Log("usuwanie z match3");
Spawnitem(PieceToSpawn);
ApplyGravityToBoard();
counter = true;
}
//Debug.Log("piece value"+PieceToSpawn.value);
flipped.Remove(flip);
update.Remove(piece);
}
}
private void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < _update.Count; i++)
{
NodePiece piece = _update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = GetFlipped(piece);
NodePiece flippedPiece = null;
int x = piece.index.x;
_fills[x] = Mathf.Clamp(_fills[x] - 1, 0, Width);
List <Point> connected = IsConnected(piece.index, true);
bool wasFlipped = flip != null;
if (wasFlipped)
{
flippedPiece = flip.GetOtherPiece(piece);
AddPoints(ref connected, IsConnected(flippedPiece.index, true));
}
if (connected.Count == 0)
{
if (wasFlipped)
{
FlipPieces(piece.index, flippedPiece.index, false);
}
}
else
{
foreach (Point p in connected)
{
KillPiece(p);
Node node = GetNodeAtPoint(p);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
_dead.Add(nodePiece);
_score += 10;
highScore -= 10;
scoreText.text = _score.ToString();
levelScoreText.text = "Ты набрал " + _score + " очков!";
if (highScore <= 0)
{
gameOverPanel.SetActive(true);
}
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
_flipped.Remove(flip);
_update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped)
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0)
{
if (wasFlipped)
{
FlipPieces(piece.index, flippedPiece.index, false);
}
}
else
{
if (connected.Count != 0 && connected.Count != 4)
{
List <Point> killlist = new List <Point>();
List <Point> bonuslist = new List <Point>();
foreach (Point p in connected)
{
killlist.Add(p);
Node node = GetNodeAtPoint(p);
NodePiece nodePiece = node.GetPiece();
if (nodePiece.isBonus())
{
Bonus.AddBonusPoints(height, width, nodePiece.BonusValue(), p, killlist, bonuslist);
}
}
foreach (Point p in killlist)
{
KillPiece(p);
Node node = GetNodeAtPoint(p);
NodePiece nodePiece = node.GetPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
}
if (connected.Count == 4)
{
Node bnode = GetNodeAtPoint(connected[0]);
NodePiece bpiece = bnode.GetPiece();
bnode.SetPiece(bpiece);
bpiece.InitializeBonus(Random.Range(1, 4), bonuses);
for (int j = 1; j < connected.Count; j++)
{
KillPiece(connected[j]);
Node node = GetNodeAtPoint(connected[j]);
NodePiece nodePiece = node.GetPiece();
node.SetPiece(nodePiece);
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
}
ApplyGravityToBoard();
}
flipped.Remove(flip);
update.Remove(piece);
}
}
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) //If we flipped to make this update
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) //If we didn't made a match
{
if (wasFlipped) //if we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); //flip back
}
}
else //If we made a match
{
foreach (Point pnt in connected)//Remove the node pieces connected
{
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
if (connected.Count <= 3)
{
Cash.CopperCoins += (getValueAtPoint(pnt)); // We add the value of our nodes as money to our cash counter.
Points.PointsAmount += (getValueAtPoint(pnt)); // We add the value of our nodes as points to our xp counter.
Debug.Log("connected 3");
}
if (connected.Count == 4)
{
Cash.CopperCoins += (getValueAtPoint(pnt) + 6); // We add the value of our nodes as money to our cash counter.
Points.PointsAmount += (getValueAtPoint(pnt) * 2); // We add the value of our nodes as points to our xp counter.
Debug.Log("Congratulations you connected 4");
}
if (connected.Count >= 5)
{
Cash.CopperCoins += (getValueAtPoint(pnt) + 20); // We add the value of our nodes as money to our cash counter.
Points.PointsAmount += (getValueAtPoint(pnt) * 3); // We add the value of our nodes as points to our xp counter.
Debug.Log("WOW AAAAAMAZING JOB You connected more than 5");
}
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip);//remove the flip after update
update.Remove(piece);
}
}
// update is called once per frame
private void Update()
{
List <NodePieces> finishedUpdating = new List <NodePieces>();
for (int i = 0; i < update.Count; i++)
{
NodePieces piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePieces piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePieces flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped)
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true));
}
if (connected.Count == 0) //If we didn't make a match
{
if (wasFlipped) // If we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); //Flip back
}
}
else //Being called if we made a match
{
combo.combo_count += 1;
foreach (Point pnt in connected) //Remove the node pieces when connected
{
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePieces nodePiece = node.getPiece();
if (node.value == 3)
{
enemy.TakeDamage(5);
}
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
deadPieces.Add(nodePiece);
}
node.SetPiece(null);
}
BoardGravity();
}
flipped.Remove(flip); //remove the flip after update
update.Remove(piece);
}
}
// UPDATE once per frame
void Update()
{
List <NodePiece> finishedUpdating = new List <NodePiece>();
for (int i = 0; i < update.Count; i++)
{
NodePiece piece = update[i];
if (!piece.UpdatePiece())
{
finishedUpdating.Add(piece);
}
}
for (int i = 0; i < finishedUpdating.Count; i++)
{
NodePiece piece = finishedUpdating[i];
FlippedPieces flip = getFlipped(piece);
NodePiece flippedPiece = null;
int x = (int)piece.index.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> connected = isConnected(piece.index, true);
bool wasFlipped = (flip != null);
if (wasFlipped) // if we flipped, make this update
{
flippedPiece = flip.getOtherPiece(piece);
AddPoints(ref connected, isConnected(flippedPiece.index, true)); // TODO figure out Ref
}
// The ref keyword in C# is used for passing or returning references of values to or from Methods.
// Basically, it means that any change made to a value that is passed by reference will reflect
// this change since you are modifying the value at the address and not just the value.
// Basically, it changes the value outside of the method and not only within it. (Not for global variables)
if (connected.Count == 0) // if no match
{
if (wasFlipped) // If we flipped
{
FlipPieces(piece.index, flippedPiece.index, false); // flip back
}
}
else // If we made a match
{
foreach (Point pnt in connected) // remove nodes connected
{
KillPiece(pnt);
Node node = getNodeAtPoint(pnt);
NodePiece nodePiece = node.getPiece();
if (nodePiece != null)
{
nodePiece.gameObject.SetActive(false);
dead.Add(nodePiece);
}
node.SetPiece(null);
}
ApplyGravityToBoard();
}
flipped.Remove(flip); // Remove the flip after update
update.Remove(piece);
}
}
//*******Aktív fázis*******
//Változások kezelése
void Update()
{
if (battleManager.GetBattleState() == BattleState.PlayerTurn)
{
//Mozgások szerint a pozíciók frissítése
List <Piece> finishedUpdatingList = new List <Piece>();
for (int i = 0; i < updatePieceList.Count; i++)
{
Piece piece = updatePieceList[i];
if (!piece.UpdatePiece())
{
finishedUpdatingList.Add(piece);
}
}
for (int i = 0; i < finishedUpdatingList.Count; i++)
{
Piece piece = finishedUpdatingList[i];
FlippedPieces flip = GetFlipped(piece);
Piece flippedPiece = null;
//Simább piece esés
int x = (int)piece.positionInGrid.x;
fills[x] = Mathf.Clamp(fills[x] - 1, 0, width);
List <Point> listOfConnectedPoints = IsConnected(piece.positionInGrid, true);
bool wasFlipped = (flip != null);
//Ha volt flip az update előtt megnézzük, hogy lett-e match
if (wasFlipped)
{
flippedPiece = flip.GetOtherPiece(piece);
IncludePoints(ref listOfConnectedPoints, IsConnected(flippedPiece.positionInGrid, true));
}
//Ha nem lett match
if (listOfConnectedPoints.Count == 0)
{
if (wasFlipped) //Visszacsinaljuk a flippet
{
FlipPieces(piece.positionInGrid, flippedPiece.positionInGrid, false);
}
}
//Ha match lett
else
{
//Eltávolítja a listában szereplő pontokat
foreach (Point pointInConnection in listOfConnectedPoints)
{
GridCell cell = GetCellAtPoint(pointInConnection);
Piece tempPiece = cell.GetPieceFromCell();
if (tempPiece != null)
{
tempPiece.gameObject.SetActive(false);
usedPieceList.Add(tempPiece);
//Növeljük az adott típus counterét
ScoreController.IncreasePoints(tempPiece.typeValue - 1);
battleManager.Attack(tempPiece.typeValue - 1);
}
//Kinullázzuk az adott cellához tartozó piece-t
cell.AddPieceToCell(null);
//Lyuk keletkezett, szóval hívjuk a gravitációt
ApplyGravityToColumn(cell.positionOfCell.x);
}
battleManager.ChangeTurn();
}
//Eltakarítjuk a pontokat mikor már végeztünk velük
flippedPieceList.Remove(flip);
updatePieceList.Remove(piece);
}
}
else if (battleManager.GetBattleState() == BattleState.EnemyTurn)
{
int random = UnityEngine.Random.Range(1, 3);
for (int i = 0; i < random; i++)
{
battleManager.Attack();
}
battleManager.ChangeTurn();
}
}
