private void OnCombinationDestroyed(List<Chuzzle> destroyedChuzzles)
{
//TODO find chuzzle (it's special type)
if (TargetChuzzle == null)
{
TargetChuzzle = Gamefield.Level.ActiveChuzzles.FirstOrDefault(x => x.Counter > 0);
if (TargetChuzzle == null)
{
Debug.Log("No target chuzzle");
return;
}
}
// Debug.Log("destroy");
if (destroyedChuzzles.Contains(TargetChuzzle))
{
Amount -= destroyedChuzzles.Count-1;
if (Amount < 0)
{
Amount = 0;
}
TargetChuzzle.GetComponentInChildren<tk2dTextMesh>().text = Amount.ToString(CultureInfo.InvariantCulture);
}
if (Amount <= 0)
{
IsWin = true;
}
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
CreateNew();
}
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);
}
private void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
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);
}
//TODO check for if start chuzzle contains in tilesToKill
public static void ApplyPowerUp(this Gamefield gamefield, List<Chuzzle> tilesToKill, Chuzzle chuzzle)
{
if (chuzzle.PowerType == PowerType.Usual)
{
Debug.LogError("Try apply power up for non power type chuzzle: "+chuzzle.ToString());
return;
}
if (chuzzle.PowerType == PowerType.HorizontalLine)
{
var horizontalChuzzles = gamefield.Level.ActiveChuzzles.Where(x => x.Current.y == chuzzle.Current.y && x.PowerType == PowerType.Usual);
tilesToKill.AddUniqRange(horizontalChuzzles);
}
if (chuzzle.PowerType == PowerType.VerticalLine)
{
var vertical = gamefield.Level.ActiveChuzzles.Where(x => x.Current.x == chuzzle.Current.x && x.PowerType == PowerType.Usual);
tilesToKill.AddUniqRange(vertical);
}
if (chuzzle.PowerType == PowerType.Bomb)
{
var square = gamefield.Level.ActiveChuzzles.Where(x => (x.Current.x == chuzzle.Current.x - 1 || x.Current.x == chuzzle.Current.x + 1 || x.Current.x == chuzzle.Current.x) && (x.Current.y == chuzzle.Current.y - 1 || x.Current.y == chuzzle.Current.y || x.Current.y == chuzzle.Current.y + 1) && x.PowerType == PowerType.Usual);
tilesToKill.AddUniqRange(square);
}
}
public void OnChuzzleDeath(Chuzzle chuzzle)
{
chuzzle.Died -= OnChuzzleDeath;
//remove chuzzle from game logic
Gamefield.RemoveChuzzle(chuzzle);
}
public void InvokeTileDestroyed(Chuzzle destroyedChuzzle)
{
if (TileDestroyed != null)
{
TileDestroyed(destroyedChuzzle);
}
}
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;
}
}
private void OnAnimationStarted(Chuzzle chuzzle)
{
if (!AnimatedChuzzles.Contains(chuzzle))
{
AnimatedChuzzles.Add(chuzzle);
chuzzle.AnimationFinished += OnAnimationFinished;
}
}
public Chuzzle CreateBomb(Cell cell)
{
int colorsNumber = NumberOfColors == -1 ? ChuzzlePrefabs.Length : NumberOfColors;
GameObject prefab = BombChuzzlePrefabs[Random.Range(0, colorsNumber)];
Chuzzle ch = CreateChuzzle(cell, prefab);
return(ch);
}
public override void OnEnter()
{
isAlreadyChangedState = false;
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
CreateNew();
}
public static int CompareByY(Chuzzle first, Chuzzle second)
{
if (first.Current.y == second.Current.y)
{
return(0);
}
return(first.Current.y > second.Current.y ? 1 : -1);
}
public void ReplaceWithOtherColor(Chuzzle toReplace)
{
ChuzzleColor exceptColor = toReplace.Color;
List <ChuzzleColor> possibleColors = ((ChuzzleColor[])Enum.GetValues(typeof(ChuzzleColor))).ToList();
possibleColors.Remove(exceptColor);
ReplaceWithColor(toReplace, possibleColors[Random.Range(0, possibleColors.Count)]);
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.WinCreateNewChuzzlesState);
}
}
public static int CompareByX(Chuzzle first, Chuzzle second)
{
if (first.Current.x == second.Current.x)
{
return(0);
}
return(first.Current.x > second.Current.x ? 1 : -1);
}
public Chuzzle CreateTwoTimeChuzzle(Cell cell, bool isUniq)
{
int colorsNumber = NumberOfColors == -1 ? ChuzzlePrefabs.Length : NumberOfColors;
GameObject prefab = isUniq
? GetUniqRandomPrefabForCell(cell, new List <GameObject>(ChuzzleTwoTimesPrefabs))
: ChuzzleTwoTimesPrefabs[Random.Range(0, colorsNumber)];
Chuzzle c = CreateChuzzle(cell, prefab);
return(c);
}
private void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
chuzzle.Destroy(true, false);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.WinCreateNewChuzzlesState);
}
}
public void Reset()
{
foreach (var selectedChuzzle in SelectedChuzzles)
{
selectedChuzzle.Teleportable.Hide();
}
SelectedChuzzles.Clear();
CurrentChuzzle = null;
_axisChozen = false;
_isVerticalDrag = false;
_isReturning = false;
}
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);
}
}
/// <summary>
/// Remove chuzzle from game logic and add new tiles in column
/// </summary>
/// <param name="chuzzle">Chuzzle to remove</param>
/// <param name="invokeEvent">Need to invoke event or not</param>
public void RemoveChuzzle(Chuzzle chuzzle, bool invokeEvent = true)
{
Level.Chuzzles.Remove(chuzzle);
if (Level.ActiveChuzzles.Contains(chuzzle))
{
Level.ActiveChuzzles.Remove(chuzzle);
}
NewTilesInColumns[chuzzle.Current.x]++;
if (invokeEvent)
{
InvokeTileDestroyed(chuzzle);
}
}
public static bool BetweenYCheck(Chuzzle chuzzle, List<Chuzzle> allChuzzles)
{
var firstChuzzle = chuzzle;
var secondChuzzle =
allChuzzles.FirstOrDefault(
ch =>
ch.Current.x == firstChuzzle.Current.x && ch.Current.y == firstChuzzle.Current.y + 2 &&
ch.Type == firstChuzzle.Type);
if (secondChuzzle == null)
return false;
return allChuzzles.Any(x => x.Current.y == firstChuzzle.Current.y + 1 && x.Type == firstChuzzle.Type);
}
public void Explode(Chuzzle chuzzle)
{
var ps = GetExplosion();
iTween.ScaleTo(chuzzle.gameObject,
iTween.Hash(
"x", 0,
"y", 0,
"z", 0,
"time", ps.particleSystem.duration));
ps.transform.position = EffectsCamera.ScreenToWorldPoint(Camera.main.WorldToScreenPoint(chuzzle.transform.position));
ps.Init(chuzzle.Color);
}
public void Explode(Chuzzle chuzzle)
{
var ps = GetExplosion();
iTween.ScaleTo(chuzzle.gameObject,
iTween.Hash(
"x", 0,
"y", 0,
"z", 0,
"time", ps.GetComponent<ParticleSystem>().duration));
ps.transform.position = EffectsCamera.ScreenToWorldPoint(Camera.main.WorldToScreenPoint(chuzzle.transform.position));
ps.Init(chuzzle.Color);
}
private void OnAnimationStarted(Chuzzle chuzzle)
{
if (isAlreadyChangedState)
{
Debug.LogWarning("Already changed state create new chuzzle");
return;
}
if (!AnimatedChuzzles.Contains(chuzzle))
{
AnimatedChuzzles.Add(chuzzle);
chuzzle.AnimationFinished += OnAnimationFinished;
}
}
public static bool IsSameColor(Chuzzle a, Chuzzle b)
{
if (a == null || b == null)
{
Debug.LogError(String.Format("A or b is NULL. a: {0} b: {1}", a, b));
return(false);
}
if (a is InvaderChuzzle || b is InvaderChuzzle)
{
return(false);
}
return(a.Color == b.Color);
}
public static bool BetweenYCheck(Chuzzle chuzzle, List <Chuzzle> allChuzzles)
{
var firstChuzzle = chuzzle;
var secondChuzzle = allChuzzles.FirstOrDefault(ch =>
ch.Current.x == firstChuzzle.Current.x &&
ch.Current.y == firstChuzzle.Current.y + 2 &&
IsSameColor(ch, firstChuzzle));
if (secondChuzzle == null || allChuzzles.Any(x => x.Current.y == firstChuzzle.Current.y + 1 && IsLock(x)))
{
return(false);
}
return(allChuzzles.Any(x => x.Current.y == firstChuzzle.Current.y + 1 && IsSameColor(x, firstChuzzle)));
}
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;
if (!Tutorial.isActive)
{
CheckPossibleCombinations();
}
if (!Gamefield.InvaderWasDestroyed)
{
InvaderChuzzle.Populate(Gamefield);
}
Gamefield.InvaderWasDestroyed = false;
}
// вертикальная и горизонтальная проверка для второго случая
public static bool AnotherVerticalCheck(Chuzzle chuzzle, List<Chuzzle> allChuzzles)
{
var firstChuzzle = chuzzle;
var secondChuzzle =
allChuzzles.FirstOrDefault(
ch =>
ch.Current.x == firstChuzzle.Current.x && ch.Current.y == firstChuzzle.Current.y + 1 &&
ch.Type == firstChuzzle.Type);
if (secondChuzzle == null) return false;
return
allChuzzles.Where(
ch =>
Math.Abs(ch.Current.x - firstChuzzle.Current.x) == 1 || ch.Current.y == firstChuzzle.Current.y - 1 ||
ch.Current.y == firstChuzzle.Current.y + 2).Any(ch => ch.Type == firstChuzzle.Type);
}
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);
}
}
/// <summary>
/// Remove chuzzle from game logic and add new tiles in column
/// </summary>
/// <param name="chuzzle">Chuzzle to remove</param>
/// <param name="invokeEvent">Need to invoke event or not</param>
public void RemoveChuzzle(Chuzzle chuzzle, bool invokeEvent = true)
{
Level.Chuzzles.Remove(chuzzle);
Level.ActiveChuzzles.Remove(chuzzle);
if (chuzzle.NeedCreateNew)
{
if (chuzzle is TwoTimeChuzzle)
{
Debug.LogError("Error: Two time chuzzle creation!!");
}
NewTilesInColumns[chuzzle.Current.x]++;
}
if (invokeEvent)
{
InvokeTileDestroyed(chuzzle);
}
}
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 static bool AnotherVerticalCheck(Chuzzle chuzzle, List <Chuzzle> allChuzzles)
{
var firstChuzzle = chuzzle;
var secondChuzzle =
allChuzzles.FirstOrDefault(
ch =>
ch.Current.x == firstChuzzle.Current.x && ch.Current.y == firstChuzzle.Current.y + 1 &&
IsSameColor(ch, firstChuzzle));
if (secondChuzzle == null)
{
return(false);
}
return
(allChuzzles.Where(
ch =>
Math.Abs(ch.Current.x - firstChuzzle.Current.x) == 1 || ch.Current.y == firstChuzzle.Current.y - 1 ||
ch.Current.y == firstChuzzle.Current.y + 2).Any(ch => IsSameColor(ch, firstChuzzle)));
}
private void OnTileDestroyed(Chuzzle destroyedChuzzle)
{
if (PlaceCoordinates.Count == 0)
{
return;
}
var place =
CurrentPlaceCoordinates.FirstOrDefault(
x => x.x == destroyedChuzzle.Current.x && x.y == destroyedChuzzle.Current.y);
if (place != null)
{
NGUITools.ClearChildren(destroyedChuzzle.Current.GameObject);
CurrentPlaceCoordinates.Remove(place);
}
if (CurrentPlaceCoordinates.Count == 0)
{
IsWin = true;
}
}
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);
}
}
}
public Chuzzle CreateCounterChuzzle(Cell cell, bool isUniq)
{
int colorsNumber = NumberOfColors == -1 ? ChuzzlePrefabs.Length : NumberOfColors;
GameObject prefab = isUniq
? GetUniqRandomPrefabForCell(cell, new List <GameObject>(ChuzzleCounterPrefabs))
: ChuzzleCounterPrefabs[Random.Range(0, colorsNumber)];
Chuzzle c = CreateChuzzle(cell, prefab);
var chuzzle = c as CounterChuzzle;
if (chuzzle == null)
{
Debug.LogError("Incorrect prefabs for counters");
}
else
{
((TargetChuzzleGameMode)Gamefield.GameMode).UpdateCounter();
}
cell.CreationType = CreationType.Usual;
return(c);
}
private void OnDied(Chuzzle deadChuzzle)
{
Chuzzle = null;
}
public static Chuzzle GetTopFor(Chuzzle c, IEnumerable<Chuzzle> chuzzles)
{
return chuzzles.FirstOrDefault(x => x.Real == c.Real.Top);
}
public void Reset()
{
SelectedChuzzles.Clear();
CurrentChuzzle = null;
_directionChozen = false;
_isVerticalDrag = false;
}
public static List<Chuzzle> RecursiveFind(Chuzzle chuzzle, List<Chuzzle> combination, IEnumerable<Chuzzle> chuzzles)
{
if (chuzzle == null || combination.Contains(chuzzle) || chuzzle.IsCheckedForSearch)
{
return new List<Chuzzle>();
}
combination.Add(chuzzle);
chuzzle.IsCheckedForSearch = true;
var left = GetLeftFor(chuzzle, chuzzles);
if (left != null && left.Type == chuzzle.Type)
{
var answer = RecursiveFind(left, combination, chuzzles);
foreach (var a in answer)
{
if (combination.Contains(a) == false)
{
combination.Add(a);
}
}
}
var right = GetRightFor(chuzzle, chuzzles);
if (right != null && chuzzle.Type == right.Type)
{
var answer = RecursiveFind(right, combination, chuzzles);
foreach (var a in answer)
{
if (combination.Contains(a) == false)
{
combination.Add(a);
}
}
}
var top = GetTopFor(chuzzle, chuzzles);
if (top != null && chuzzle.Type == top.Type)
{
var answer = RecursiveFind(top, combination, chuzzles);
foreach (var a in answer)
{
if (combination.Contains(a) == false)
{
combination.Add(a);
}
}
}
var bottom = GetBottomFor(chuzzle, chuzzles);
if (bottom != null && chuzzle.Type == bottom.Type)
{
var answer = RecursiveFind(bottom, combination, chuzzles);
foreach (var a in answer)
{
if (combination.Contains(a) == false)
{
combination.Add(a);
}
}
}
return combination;
}
private void InvokeTileDestroyed(Chuzzle destroyedChuzzle)
{
if (TileDestroyed != null)
{
TileDestroyed(destroyedChuzzle);
}
}
// Update is called once per frame
public void Update(IEnumerable<Chuzzle> draggableChuzzles)
{
Gamefield.TimeFromTip += Time.deltaTime;
if (Gamefield.TimeFromTip > 1 && !Gamefield.Level.ActiveChuzzles.Any(x=>x.Shine))
{
IntVector2 targetPosition = null;
Chuzzle arrowChuzzle = null;
var possibleCombination = GamefieldUtility.Tip(Gamefield.Level.ActiveChuzzles,out targetPosition, out arrowChuzzle);
if (possibleCombination.Any())
{
foreach (var chuzzle in possibleCombination)
{
chuzzle.Shine = true;
}
GamefieldUtility.ShowArrow(arrowChuzzle, targetPosition, Gamefield.DownArrow);
}
else
{
RepaintRandom();
return;
}
Gamefield.TimeFromTip = 0;
}
#region Drag
if (Input.GetMouseButtonDown(0) || (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began))
{
_dragOrigin = Input.mousePosition;
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);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Single.MaxValue, Gamefield.ChuzzleMask))
{
CurrentChuzzle = hit.transform.gameObject.GetComponent<Chuzzle>();
}
return;
}
// CHECK DRAG STATE (Mouse or Touch)
if ((!Input.GetMouseButton(0) || Input.GetMouseButtonUp(0)) && 0 == Input.touchCount)
{
DropDrag();
return;
}
if (CurrentChuzzle == null)
{
return;
}
if (Input.GetMouseButton(0)) // Get Position Difference between Last and Current Touches
{
// MOUSE
_delta = Input.mousePosition - _dragOrigin;
// Debug.Log("Drag delta");
}
else
{
if (Input.touchCount > 0)
{
// TOUCH
_deltaTouch = new Vector3(Input.GetTouch(0).position.x, Input.GetTouch(0).position.y, 0);
_delta = _deltaTouch - _dragOrigin;
// Debug.Log("Drag delta TOUCH");
}
}
_delta = Vector3.ClampMagnitude(_delta, CurrentChuzzle.Scale.x);
if (!_directionChozen)
{
//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))
{
//TODO: choose row
SelectedChuzzles = draggableChuzzles.Where(x => x.Current.x == CurrentChuzzle.Current.x).ToList();
_isVerticalDrag = true;
}
else
{
//TODO: choose column
SelectedChuzzles = draggableChuzzles.Where(x => x.Current.y == CurrentChuzzle.Current.y).ToList();
_isVerticalDrag = false;
}
_directionChozen = true;
//Debug.Log("Direction chozen. Vertical: " + _isVerticalDrag);
}
}
if (_directionChozen)
{
if (_isVerticalDrag)
{
CurrentDirection = _delta.y > 0 ? Direction.ToTop : Direction.ToBottom;
}
else
{
CurrentDirection = _delta.x > 0 ? Direction.ToLeft : Direction.ToRight;
}
}
// RESET START POINT
_dragOrigin = Input.mousePosition;
#endregion
}
public static void ShowArrow(Chuzzle from, IntVector2 to, GameObject downArrowPrefab)
{
var down = Object.Instantiate(downArrowPrefab) as GameObject;
ScaleSprite(down.GetComponent<tk2dSprite>(), from.Scale);
if (from.Current.x == to.x)
{
//vertical
if (from.Current.y >= to.y)
{
//to down
//do nothing
}
else
{
//to up
//mirror vertical
down.GetComponent<tk2dSprite>().FlipY = true;
}
}
else
{
//horizontal
if (from.Current.x < to.x)
{
//to right
down.transform.rotation = Quaternion.Euler(0, 0, 90);
}
else
{
//to left
//to right
down.transform.rotation = Quaternion.Euler(0, 0, -90);
}
}
down.transform.parent = from.transform;
down.transform.localPosition = from.Scale/2f;
from.Arrow = down;
}
/// <summary>
/// Находит любую возможную комбинацию
/// </summary>
/// <param name="chuzzles">Список элементов в котором надо найти комбинацию</param>
/// <returns>Список элементов которые составляют эту комбинацию</returns>
public static List<Chuzzle> Tip(List<Chuzzle> chuzzles, out IntVector2 isHorizontalMove, out Chuzzle chuzzleToMove)
{
var bottom =
chuzzles.FirstOrDefault(
x => BetweenYCheck(x, chuzzles));
if (bottom != null && bottom.Current.Top != null && bottom.Current.Top.Type != CellTypes.Block)
{
var top = chuzzles.First(ch => ch.Current == bottom.Current.Top.Top);
var bottomPart = RecursiveFind(bottom, new List<Chuzzle>(), chuzzles);
var middlePart = GetHorizontalLineChuzzles(bottom.Current.y + 1, bottom.Type, chuzzles);
var topPart = RecursiveFind(top, new List<Chuzzle>(), chuzzles);
var posibleCombination = new List<Chuzzle>();
posibleCombination.AddRange(bottomPart);
posibleCombination.AddRange(middlePart);
posibleCombination.AddRange(topPart);
Debug.Log("Combination 1");
isHorizontalMove = new IntVector2(bottom.Current.x, bottom.Current.y + 1);
chuzzleToMove = middlePart.First();
return posibleCombination;
}
var left = chuzzles.FirstOrDefault(x => BetweenXCheck(x, chuzzles));
if (left != null && left.Current.Left != null && left.Current.Left.Type != CellTypes.Block)
{
var right = chuzzles.First(ch => ch.Current == left.Current.Right.Right);
var leftPart = RecursiveFind(left, new List<Chuzzle>(), chuzzles);
var middlePart = GetVerticalLineChuzzles(left.Current.x + 1, left.Type, chuzzles);
var rightPart = RecursiveFind(right, new List<Chuzzle>(), chuzzles);
var posibleCombination = new List<Chuzzle>();
posibleCombination.AddRange(leftPart);
posibleCombination.AddRange(middlePart);
posibleCombination.AddRange(rightPart);
Debug.Log("Combination 2");
isHorizontalMove = new IntVector2(left.Current.x + 1, left.Current.y);
chuzzleToMove = middlePart.First();
return posibleCombination;
}
var combinations = FindCombinations(chuzzles, 2);
foreach (var combination in combinations)
{
var first = combination[0];
var second = combination[1];
//vertical combination
if (first.Current.x == second.Current.x)
{
//try left
if ((first.Current.Left != null && first.Current.Left.Type != CellTypes.Block) ||
(second.Current.Left != null && second.Current.Left.Type != CellTypes.Block))
{
var leftPart = GetVerticalLineChuzzles(first.Current.x - 1, first.Type, chuzzles).ToList();
if (leftPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(leftPart);
Debug.Log("Combination 3");
isHorizontalMove = new IntVector2(first.Current.x - 1, first.Current.y);
chuzzleToMove = leftPart.First();
return possibleCombination;
}
}
//try right
if ((first.Current.Right != null && first.Current.Right.Type != CellTypes.Block) ||
(second.Current.Right != null && second.Current.Right.Type != CellTypes.Block))
{
var rightPart = GetVerticalLineChuzzles(first.Current.x + 1, first.Type, chuzzles).ToList();
if (rightPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(rightPart);
Debug.Log("Combination 4");
isHorizontalMove = new IntVector2(first.Current.x + 1, first.Current.y);
chuzzleToMove = rightPart.First();
return possibleCombination;
}
}
//try top
if (second.Current.Top != null && second.Current.Top.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == second.Current.Top))
{
var topPart = GetHorizontalLineChuzzles(second.Current.Top.y, second.Type, chuzzles).ToList();
if (topPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(topPart);
Debug.Log("Combination 5");
isHorizontalMove = new IntVector2(second.Current.x, second.Current.Top.y);
chuzzleToMove = topPart.First();
return possibleCombination;
}
}
//try bottom
if (first.Current.Bottom != null && first.Current.Bottom.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == first.Current.Bottom))
{
var bottomPart = GetHorizontalLineChuzzles(first.Current.Bottom.y, first.Type, chuzzles).ToList();
if (bottomPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(bottomPart);
Debug.Log("Combination 6");
isHorizontalMove = new IntVector2(second.Current.x, second.Current.Bottom.y);
chuzzleToMove = bottomPart.First();
return possibleCombination;
}
}
}
else
{
//horizontal combinations
//try left
if (first.Current.Left != null && first.Current.Left.Type != CellTypes.Block)
{
var leftPart = GetVerticalLineChuzzles(first.Current.x - 1, first.Type, chuzzles).ToList();
if (leftPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(leftPart);
Debug.Log("Combination 7");
isHorizontalMove = new IntVector2(first.Current.x - 1, first.Current.y);
chuzzleToMove = leftPart.First();
return possibleCombination;
}
}
//try right
if (second.Current.Right != null && second.Current.Right.Type != CellTypes.Block)
{
var rightPart = GetVerticalLineChuzzles(second.Current.x + 1, second.Type, chuzzles).ToList();
if (rightPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(rightPart);
Debug.Log("Combination 8");
isHorizontalMove = new IntVector2(second.Current.x + 1, second.Current.y);
chuzzleToMove = rightPart.First();
return possibleCombination;
}
}
//try top
if (
(first.Current.Top != null && first.Current.Top.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == first.Current.Top)) ||
(second.Current.Top != null && second.Current.Top.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == second.Current.Top))
)
{
var topPart = GetHorizontalLineChuzzles(second.Current.y + 1, second.Type, chuzzles).ToList();
if (topPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(topPart);
Debug.Log("Combination 9");
isHorizontalMove = new IntVector2(second.Current.x, second.Current.y + 1);
chuzzleToMove = topPart.First();
return possibleCombination;
}
}
//try bottom
if (
(first.Current.Bottom != null && first.Current.Bottom.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == first.Current.Bottom)) ||
(second.Current.Bottom != null && second.Current.Bottom.Type != CellTypes.Block &&
chuzzles.Any(x => x.Current == second.Current.Bottom))
)
{
var bottomPart = GetHorizontalLineChuzzles(first.Current.y - 1, first.Type, chuzzles).ToList();
if (bottomPart.Any())
{
var possibleCombination = new List<Chuzzle>();
possibleCombination.AddRange(combination);
possibleCombination.AddRange(bottomPart);
Debug.Log("Combination 10");
isHorizontalMove = new IntVector2(first.Current.x, first.Current.y - 1);
chuzzleToMove = bottomPart.First();
return possibleCombination;
}
}
}
}
Debug.Log("Combination NOOOOOOOOOO 11");
isHorizontalMove = new IntVector2();
chuzzleToMove = null;
return new List<Chuzzle>();
}
public static IntVector2 ToRealCoordinates(Chuzzle chuzzle)
{
return new IntVector2(Mathf.RoundToInt(chuzzle.transform.localPosition.x/chuzzle.Scale.x),
Mathf.RoundToInt(chuzzle.transform.localPosition.y/chuzzle.Scale.y));
}
public void CalculateRealCoordinatesFor(Chuzzle chuzzle)
{
chuzzle.Real = Gamefield.Level.GetCellAt(Mathf.RoundToInt(chuzzle.transform.localPosition.x / chuzzle.Scale.x),
Mathf.RoundToInt(chuzzle.transform.localPosition.y / chuzzle.Scale.y), false);
}
