private void DropDrag()
{
if (SelectedChuzzles.Any())
{
//drop shining
foreach (var chuzzle in Gamefield.Level.ActiveChuzzles)
{
chuzzle.Shine = false;
chuzzle.Teleportable.Hide();
}
//move all tiles to new real coordinates
foreach (var chuzzle in SelectedChuzzles)
{
chuzzle.Real = Gamefield.Level.GetCellAt(GamefieldUtility.ToRealCoordinates(chuzzle), false);
}
foreach (var c in Gamefield.Level.Chuzzles)
{
c.MoveTo = c.Real;
}
foreach (var chuzzle in Gamefield.Level.Chuzzles)
{
chuzzle.AnimateMoveTo(chuzzle.MoveTo.Position, 0.1f);
}
CheckAnimationCompleted();
}
}
private static Cell GetLeftCell(List <Cell> activeCells, Cell targetCell, Chuzzle c)
{
if (targetCell == null)
{
targetCell = GamefieldUtility.CellAt(activeCells, activeCells.Max(x => x.x), c.Current.y);
if (targetCell.Type == CellTypes.Block)
{
targetCell = targetCell.GetLeftWithType();
}
}
else
{
//if block
targetCell = targetCell.GetLeftWithType();
if (targetCell == null)
{
targetCell = GamefieldUtility.CellAt(activeCells, activeCells.Max(x => x.x),
c.Current.y);
if (targetCell.Type == CellTypes.Block)
{
targetCell = targetCell.GetLeftWithType();
}
}
}
return(targetCell);
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.Real = chuzzle.Current = chuzzle.MoveTo;
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (isAlreadyChangedState)
{
Debug.LogWarning("Finished in CRNC state ");
}
if (!AnimatedChuzzles.Any() && !isAlreadyChangedState)
{
Gamefield.Level.UpdateActive();
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Count > 0)
{
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
}
else
{
if (!Gamefield.GameMode.IsWin && !Gamefield.GameMode.IsGameOver)
{
Gamefield.SwitchStateTo(Gamefield.FieldState);
}
else
{
Gamefield.GameMode.Check();
}
}
isAlreadyChangedState = true;
}
}
public void Show()
{
gameObject.SetActive(true);
IntVector2 targetPosition;
Chuzzle arrowChuzzle;
GamefieldUtility.Tip(gamefield.Level.ActiveChuzzles, out targetPosition, out arrowChuzzle);
fromFingerPosition = arrowChuzzle.Current.IntVector2Position;
toFingerPosition = targetPosition;
var fromPosition = GamefieldUtility.ConvertXYToPosition((int)fromFingerPosition.x, (int)fromFingerPosition.y, Chuzzle.Scale);
finger.transform.position = fromPosition;
finger.Values["position"] = GamefieldUtility.ConvertXYToPosition((int)toFingerPosition.x, (int)toFingerPosition.y, Chuzzle.Scale);
finger.Play();
Tutorial.instance.targetCell = gamefield.Level.GetCellAt(targetPosition);
Tutorial.instance.takeableChuzzle = gamefield.Level.At(fromFingerPosition.x, fromFingerPosition.y);
gamefield.TileDestroyed += OnTileDestroyed;
tutorialCloud.SetText("Drag to destroy");
tutorialCloud.SetPosition(Camera.main.WorldToScreenPoint(fromPosition + Vector3.up * 0.5f));
tutorialCloud.Show();
}
public Cell(int x, int y, CellTypes type = CellTypes.Usual)
{
this.x = x;
this.y = y;
this.Type = type;
Position = GamefieldUtility.ConvertXYToPosition(x, y, Chuzzle.Scale);
}
public bool CheckForSpecial(List <List <Chuzzle> > combinations)
{
var isNewSpecial = false;
foreach (var comb in combinations)
{
//if any tile is powerup - then don't check for new bonuses
//or any tile has counter
if (comb.Any(x => !(GamefieldUtility.IsUsual(x))))
{
continue;
}
if (comb.Count == 4)
{
isNewSpecial = CreateLine(comb);
}
else
{
if (comb.Count >= 5)
{
isNewSpecial = CreateBomb(comb);
}
}
}
return(isNewSpecial);
}
private static Cell GetTopCell(List <Cell> activeCells, Cell targetCell, Chuzzle c)
{
if (targetCell == null || targetCell.IsTemporary)
{
targetCell = GamefieldUtility.CellAt(activeCells, c.Current.x,
activeCells.Where(x => !x.IsTemporary).Min(x => x.y));
if (targetCell.Type == CellTypes.Block)
{
targetCell = targetCell.GetTopWithType();
}
}
else
{
targetCell = targetCell.GetTopWithType();
if (targetCell == null)
{
targetCell = GamefieldUtility.CellAt(activeCells, c.Current.x,
activeCells.Where(x => !x.IsTemporary).Min(x => x.y));
if (targetCell.Type == CellTypes.Block)
{
targetCell = targetCell.GetTopWithType();
}
}
}
return(targetCell);
}
public Cell GetCellAt(int x, int y, bool createIfNotFound = true)
{
var cell = GamefieldUtility.CellAt(Cells, x, y);
if (cell == null && createIfNotFound)
{
var newCell = new Cell(x, y);
AddCell(x, y, newCell);
return(newCell);
}
return(cell);
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (!CheckForSpecial(combinations))
{
Gamefield.SwitchStateTo(Gamefield.WinRemoveCombinationState);
}
}
private void RemoveColorFromPossible(Cell cell, List <GameObject> possiblePrefabs)
{
if (cell != null)
{
Chuzzle chuzzle = GamefieldUtility.GetChuzzleInCell(cell, Gamefield.Level.Chuzzles);
if (chuzzle == null)
{
return;
}
GameObject possible = possiblePrefabs.FirstOrDefault(x => x.GetComponent <Chuzzle>().Color == chuzzle.Color);
if (possible != null)
{
possiblePrefabs.Remove(possible);
}
}
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
var anyCombination = GamefieldUtility.FindOnlyOneCombination(Gamefield.Level.ActiveChuzzles);
if (anyCombination.Any())
{
StartCoroutine(RemoveCombinations());
}
else
{
Gamefield.SwitchStateTo(Gamefield.FieldState);
}
}
public void OnBomBomHided()
{
var newPowerUps = new List <Chuzzle>();
var usualChuzzles = Gamefield.Level.Chuzzles.Where(ch => !GamefieldUtility.IsPowerUp(ch)).ToList();
for (var i = 0; i < Gamefield.GameMode.Turns; i++)
{
var newPowerUp = usualChuzzles[UnityEngine.Random.Range(0, usualChuzzles.Count())];
newPowerUps.Add(newPowerUp);
usualChuzzles.Remove(newPowerUp);
if (!usualChuzzles.Any())
{
break;
}
}
Gamefield.GameMode.Turns = 0;
StartCoroutine(CreateNewPowerUps(newPowerUps.ToList()));
}
private void CheckPossibleCombinations()
{
_targetPosition = null;
_arrowChuzzle = null;
var numberOfTries = 0;
do
{
if (GamefieldUtility.Repaint(numberOfTries))
{
break;
}
_possibleCombination = GamefieldUtility.Tip(Gamefield.Level.ActiveChuzzles, out _targetPosition,
out _arrowChuzzle);
Debug.Log(string.Format("Tip. From: {0} To: {1}", _arrowChuzzle, _targetPosition));
numberOfTries++;
}while (!_possibleCombination.Any());
}
public void CheckCombinations()
{
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Any() && (!Tutorial.isActive || (Tutorial.isActive && CurrentChuzzle != null && Tutorial.instance.IsTargetCell(CurrentChuzzle.Real))))
{
foreach (var c in Gamefield.Level.Chuzzles)
{
c.MoveTo = c.Current = c.Real;
}
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
Reset();
}
else
{
if (CurrentChuzzle != null)
{
StartReturn();
}
}
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.Real = chuzzle.Current = chuzzle.MoveTo;
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (!AnimatedChuzzles.Any())
{
Gamefield.Level.UpdateActive();
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Count > 0)
{
Gamefield.SwitchStateTo(Gamefield.WinCheckSpecialState);
}
else
{
Gamefield.SwitchStateTo(Gamefield.WinRemoveCombinationState);
}
}
}
private IEnumerator RemoveCombinations()
{
var powerUpCombination = GamefieldUtility.FindOnlyOneCombinationWithCondition(Gamefield.Chuzzles,
GamefieldUtility.IsPowerUp);
//if has any powerups
if (powerUpCombination.Any())
{
//destroy step by step
PowerUpDestroyManager.Instance.Destroy(powerUpCombination);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.CreateNewChuzzlesState);
}
}
else
{
var combinations = GamefieldUtility.FindCombinations(Gamefield.Chuzzles);
//remove combinations
foreach (var combination in combinations)
{
Gamefield.InvokeCombinationDestroyed(combination);
foreach (var chuzzle in combination)
{
chuzzle.Destroy(true);
}
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.CreateNewChuzzlesState);
}
yield return(new WaitForSeconds(0.05f));
}
}
yield return(new WaitForEndOfFrame());
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
var powerUpChuzzles = Gamefield.Level.Chuzzles.Where(GamefieldUtility.IsPowerUp).ToArray();
foreach (var ch in powerUpChuzzles)
{
ch.Destroy(true);
}
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Any())
{
RemoveCombinations(combinations);
}
else if (!powerUpChuzzles.Any())
{
StartCoroutine(GameModeCheck());
}
}
private void OnTileDestroyed(Chuzzle destroyedChuzzle)
{
if (PlaceCoordinates.Count == 0 || destroyedChuzzle.IsReplacingOnDeath ||
!GamefieldUtility.IsOrdinaryDestroyable(destroyedChuzzle))
{
return;
}
IntVector2 place =
CurrentPlaceCoordinates.FirstOrDefault(
x => x.x == destroyedChuzzle.Current.x && x.y == destroyedChuzzle.Current.y);
if (place != null)
{
NGUITools.Destroy(destroyedChuzzle.Current.PlaceSprite);
CurrentPlaceCoordinates.Remove(place);
}
if (CurrentPlaceCoordinates.Count == 0)
{
IsWin = true;
}
}
public void UpdateState(IEnumerable <Chuzzle> draggableChuzzles)
{
if (_isReturning)
{
return;
}
TimeFromTip += Time.deltaTime;
if (TimeFromTip > 1)
{
if (_possibleCombination.Any() && _arrowChuzzle)
{
foreach (var chuzzle in _possibleCombination)
{
chuzzle.Shine = true;
}
GamefieldUtility.ShowArrow(_arrowChuzzle, _targetPosition, tipArrow);
}
TimeFromTip = 0;
}
#region Drag
if (CurrentChuzzle == null && (Input.GetMouseButtonDown(0) || (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began)))
{
_dragOrigin = Input.mousePosition;
// Debug.Log("Position: " + _dragOrigin);
if (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began)
{
// Debug.Log("is touch drag started");
_dragOrigin = new Vector3(Input.GetTouch(0).position.x, Input.GetTouch(0).position.y);
}
var ray = Camera.main.ScreenPointToRay(_dragOrigin);
// Debug.Log("Ray: " + ray);
Debug.DrawRay(ray.origin, ray.direction * Single.MaxValue);
var hit = Physics2D.Raycast(ray.origin, ray.direction, Single.MaxValue, Gamefield.ChuzzleMask);
if (hit.transform != null)
{
// Debug.Log("hit: " + hit.transform.gameObject);
var wasNull = CurrentChuzzle == null;
CurrentChuzzle = hit.transform.gameObject.transform.parent.GetComponent <Chuzzle>();
if (wasNull)
{
_minY = _minX = float.MinValue;
_maxX = _maxY = float.MaxValue;
}
}
return;
}
// CHECK DRAG STATE (Mouse or Touch)
if ((!Input.GetMouseButton(0) || Input.GetMouseButtonUp(0)) && 0 == Input.touchCount)
{
DropDrag();
return;
}
if (CurrentChuzzle == null)
{
return;
}
if (CurrentChuzzle && Tutorial.isActive && !Tutorial.instance.CanTakeOnlyThisChuzzle(CurrentChuzzle))
{
Reset();
return;
}
if (Input.GetMouseButton(0)) // Get Position Difference between Last and Current Touches
{
// MOUSE
_delta = Camera.main.ScreenToWorldPoint(Input.mousePosition) - Camera.main.ScreenToWorldPoint(_dragOrigin);
}
else
{
if (Input.touchCount > 0)
{
// TOUCH
_deltaTouch =
Camera.main.ScreenToWorldPoint(new Vector3(Input.GetTouch(0).position.x,
Input.GetTouch(0).position.y, 0));
_delta = _deltaTouch - Camera.main.ScreenToWorldPoint(_dragOrigin);
}
}
//Debug.Log("Delta: " + _delta);
_delta = Vector3.ClampMagnitude(_delta, 0.45f * Chuzzle.Scale.x);
if (!_axisChozen)
{
//chooze drag direction
if (Mathf.Abs(_delta.x) < 1.5 * Mathf.Abs(_delta.y) || Mathf.Abs(_delta.x) > 1.5 * Mathf.Abs(_delta.y))
{
if (Mathf.Abs(_delta.x) < Mathf.Abs(_delta.y))
{
SelectedChuzzles = draggableChuzzles.Where(x => x.Current.x == CurrentChuzzle.Current.x).ToList();
_isVerticalDrag = true;
}
else
{
SelectedChuzzles = draggableChuzzles.Where(x => x.Current.y == CurrentChuzzle.Current.y).ToList();
_isVerticalDrag = false;
}
_hasLockedChuzzles = HasLockChuzzles;
if (_hasLockedChuzzles)
{
_minX = CurrentChuzzle.Current.Position.x - Chuzzle.Scale.x * 0.4f;
_maxX = CurrentChuzzle.Current.Position.x + Chuzzle.Scale.x * 0.4f;
_minY = CurrentChuzzle.Current.Position.y - Chuzzle.Scale.y * 0.4f;
_maxY = CurrentChuzzle.Current.Position.y + Chuzzle.Scale.y * 0.4f;
}
_axisChozen = true;
//Debug.Log("Direction chozen. Vertical: " + _isVerticalDrag);
}
}
if (_axisChozen)
{
if (_isVerticalDrag)
{
CurrentDirection = _delta.y > 0 ? Direction.Top : Direction.Bottom;
_delta.z = _delta.x = 0;
}
else
{
CurrentDirection = _delta.x > 0 ? Direction.Right : Direction.Left;
_delta.y = _delta.z = 0;
}
}
// RESET START POINT
_dragOrigin = Input.mousePosition;
#endregion
}
public static bool IsPowerUp(this Chuzzle chuzzle)
{
return(GamefieldUtility.IsPowerUp(chuzzle));
}
private void MoveChuzzles(List <Cell> activeCells)
{
foreach (var c in SelectedChuzzles)
{
var copyPosition = c.transform.position;
var real = GamefieldUtility.ToRealCoordinates(c);
var targetCell = GamefieldUtility.CellAt(activeCells, real.x, real.y);
var difference = c.transform.position - GamefieldUtility.ConvertXYToPosition(real.x, real.y, Chuzzle.Scale);
var isNeedCopy = false;
if (targetCell != null && !targetCell.IsTemporary)
{
if (!_isVerticalDrag)
{
if (difference.x > 0)
{
isNeedCopy = targetCell.Right == null ||
(targetCell.Right != null && targetCell.Right.Type != CellTypes.Usual);
if (isNeedCopy)
{
var rightCell = GetRightCell(activeCells, targetCell.Right, c);
copyPosition = rightCell.Position + difference - new Vector3(Chuzzle.Scale.x, 0, 0);
}
}
else
{
isNeedCopy = targetCell.Left == null ||
(targetCell.Left != null && targetCell.Left.Type != CellTypes.Usual);
if (isNeedCopy)
{
var leftCell = GetLeftCell(activeCells, targetCell.Left, c);
copyPosition = leftCell.Position + difference + new Vector3(Chuzzle.Scale.x, 0, 0);
}
}
}
else
{
if (difference.y > 0)
{
isNeedCopy = targetCell.Top == null ||
(targetCell.Top != null &&
(targetCell.Top.Type == CellTypes.Block || targetCell.Top.IsTemporary));
if (isNeedCopy)
{
var topCell = GetTopCell(activeCells, targetCell.Top, c);
copyPosition = topCell.Position + difference - new Vector3(0, Chuzzle.Scale.y, 0);
}
}
else
{
isNeedCopy = targetCell.Bottom == null ||
(targetCell.Bottom != null && targetCell.Bottom.Type == CellTypes.Block);
if (isNeedCopy)
{
var bottomCell = GetBottomCell(activeCells, targetCell.Bottom, c);
copyPosition = bottomCell.Position + difference + new Vector3(0, Chuzzle.Scale.y, 0);
}
}
}
}
else
{
isNeedCopy = true;
}
if (targetCell == null || targetCell.Type == CellTypes.Block || targetCell.IsTemporary)
{
switch (CurrentDirection)
{
case Direction.Left:
//if border
targetCell = GetLeftCell(activeCells, targetCell, c);
break;
case Direction.Right:
targetCell = GetRightCell(activeCells, targetCell, c);
break;
case Direction.Top:
//if border
targetCell = GetTopCell(activeCells, targetCell, c);
break;
case Direction.Bottom:
targetCell = GetBottomCell(activeCells, targetCell, c);
break;
default:
throw new ArgumentOutOfRangeException("Current direction can not be shit");
}
c.transform.position = targetCell.Position + difference;
// Debug.Log("New coord: "+GamefieldUtility.ToRealCoordinates(c)+" for "+c.gameObject.name + " pos: "+c.transform.position);
}
if (difference.magnitude < (Chuzzle.Scale.x / 25))
{
isNeedCopy = false;
}
if (isNeedCopy)
{
c.Teleportable.Show();
c.Teleportable.Copy.transform.position = copyPosition;
}
else
{
c.Teleportable.Hide();
}
}
}
