/// $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
/// Neighbouring Boards codes
/// $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
// function to help convert the enum to the appropriate board reference
public Board boardEnumToReference(BoardDirection bd)
{
switch (bd)
{
case BoardDirection.Top:
return(top);
case BoardDirection.Bottom:
return(bottom);
case BoardDirection.Left:
return(left);
case BoardDirection.Right:
return(right);
case BoardDirection.TopLeft:
return(topLeft);
case BoardDirection.TopRight:
return(topRight);
case BoardDirection.BottomLeft:
return(bottomLeft);
case BoardDirection.BottomRight:
return(bottomRight);
default:
return(null);
}
}
public void PushTile(Tile tile, BoardDirection inDirection)
{
if (!this.IsValidTile(tile))
{
return;
}
var lastTile = this.PeekLastTile();
// First tile
if (lastTile == null)
{
this.AddTile(tile);
return;
}
var nextSection = Board.Instance.Pathfind(lastTile, tile, inDirection);
foreach (var nextTile in nextSection)
{
if (this.IsValidTile(nextTile))
{
this.AddTile(nextTile);
}
}
}
public static bool IsAgainst(HexagonEdget edget, BoardDirection direction, bool isUpper)
{
if (isUpper)
{
if (direction == BoardDirection.Right || direction == BoardDirection.BottomRight)
{
return(edget == HexagonEdget.UpperLeft);
}
if (direction == BoardDirection.Left || direction == BoardDirection.BottomLeft)
{
return(edget == HexagonEdget.UpperRight);
}
if (direction == BoardDirection.TopLeft || direction == BoardDirection.TopRight)
{
return(edget == HexagonEdget.UpperDown);
}
}
else
{
if (direction == BoardDirection.Right || direction == BoardDirection.TopRight)
{
return(edget == HexagonEdget.DownLeft);
}
if (direction == BoardDirection.Left || direction == BoardDirection.TopLeft)
{
return(edget == HexagonEdget.DownRight);
}
if (direction == BoardDirection.BottomLeft || direction == BoardDirection.BottomRight)
{
return(edget == HexagonEdget.DownUp);
}
}
return(true);
}
//--------------------------------------------------------------------------------------------------------
private void StartNewGame()
{
foreach (Block block in blocks)
{
Destroy(block.gameObject);
}
// reset the sim
blocks.Clear();
swipeDir = BoardDirection.Null;
CurrentWildChance = 0f;
CurrentDoubleChance = 0f;
CurrentTripleChance = 0f;
CurrentHungryNekoInterval = -1;
MovesSinceLastHungryNeko = 0;
turnCount = 1;
Score = 0;
isGameOver = false;
ForceWildCardNextTurn = false;
GlobalFood = new List <Block>();
foreach (HungryNeko neko in HungryNekos)
{
neko.Reset();
}
foreach (Hex hex in hexes)
{
hex.Occupant = null;
}
// reset high score
HighScore = PlayerPrefs.GetInt(playerPrefHighScoreKey);
NewHighScoreIndicator.SetActive(false);
if (HighScore > 0)
{
CurrentHighScoreIndicator.SetActive(true);
CurrentHighScoreLabel.text = "High Score: " + HighScore;
}
else
{
CurrentHighScoreIndicator.SetActive(false);
}
// reset other things
ClearTutorials();
UnlockProgressBar.Reset();
ScoreMultPanel.ResetLevel();
UnlockProgressBar.LevelLabel.text = (UnlockProgressBar.CurrentUnlock + 1).ToString();
// record number of games started on this device
int gamesStarted = PlayerPrefs.GetInt(playerPrefsGameCountKey) + 1;
PlayerPrefs.SetInt(playerPrefsGameCountKey, gamesStarted);
PlayerPrefs.Save();
Debug.Log("Starting game " + gamesStarted + " on this device.");
// start the game
CreateBlocks();
SaveGameState();
allowInput = true;
}
public virtual void Init(Hexagon hexagon, BoardDirection direction, int count, float time, float speed, Color32 color)
{
Vector3 phyDirection = Board.Instance.GetPhysicDirection(direction);
Vector3 positionA = Vector3.zero;
Vector3 positionB = Vector3.zero;
switch (direction)
{
case BoardDirection.BottomLeft:
case BoardDirection.BottomRight:
positionA = hexagon.left;
positionB = hexagon.right;
break;
case BoardDirection.Left:
case BoardDirection.TopLeft:
positionA = hexagon.left;
positionB = hexagon.top;
break;
case BoardDirection.Right:
case BoardDirection.TopRight:
positionA = hexagon.right;
positionB = hexagon.top;
break;
}
for (int i = 0; i < count; i++)
{
GameObject particleObj = EntityPool.Instance.Use("Particle") as GameObject;
Particle particle = particleObj.GetComponent <Particle>();
particle.transform.localPosition = positionA + (positionB - positionA).magnitude * UnityEngine.Random.Range(0f, 1f) * (positionB - positionA).normalized;
particle.Animate(GetRandomDirectionFrom(phyDirection, 20f), time, speed + UnityEngine.Random.Range(-.5f, .5f), color);
}
}
public void Move(BoardDirection direction, PictureBox GameBox)
{
switch (direction)
{
case BoardDirection.Left:
if (xPos - speedX > BricksBreaker.BorderWidth)
{
xPos -= speedX;
}
else
{
xPos = BricksBreaker.BorderWidth;
}
break;
case BoardDirection.Right:
if (xPos + boardWidth + BricksBreaker.BorderWidth + speedX < GameBox.Width)
{
xPos += speedX;
}
else
{
xPos = GameBox.Width - boardWidth - BricksBreaker.BorderWidth;
}
break;
}
}
public void OnHitClock(BoardDirection direction)
{
if (Hexagon.IsAgainst(triggerEdget, direction, piece.isUpper))
{
triggered = true;
}
}
//--------------------------------------------------------------------------------------------------------
public void SlideTo(HungryNeko neko, BoardDirection direction)
{
swipeDestHex = null;
swipeDestNeko = neko;
swipeDestPos = neko.transform.position;
swipeDirection = direction;
}
//--------------------------------------------------------------------------------------------------------
public void SlideTo(Hex destHex, BoardDirection direction)
{
swipeDestHex = destHex;
swipeDestNeko = null;
swipeDestPos = destHex.transform.position;
swipeDirection = direction;
}
public static BoardDirection Default()
{
var dir = new BoardDirection();
dir.SetDefault();
return(dir);
}
private void FigureOutDirection()
{
Board board;
if (Board.Instance != null)
{
board = Board.Instance;
}
else
{
GameObject boardObj = GameObject.Find("Board");
board = boardObj.GetComponent <Board> ();
}
if (board == null)
{
return;
}
board.FixReference();
BoardDirection[] directions = new BoardDirection[6] {
BoardDirection.BottomLeft,
BoardDirection.BottomRight,
BoardDirection.Left,
BoardDirection.Right,
BoardDirection.TopRight,
BoardDirection.TopLeft
};
int d = 0;
while (d < directions.Length)
{
foreach (var i in children)
{
List <Piece> pieces = board.GetDirectionPieces(i, directions[d]);
if (pieces.Count > 0)
{
List <Piece> others = GetPieceWithout(i, children);
bool valide = true;
foreach (var j in others)
{
if (!pieces.Contains(j))
{
valide = false;
break;
}
}
if (valide)
{
Piece.sortingDirection = directions[d];
return;
}
}
}
d++;
}
}
} //End public bool findFourInARow(BoardVals valToConsider)
/// <summary>
/// Determines the direction when going from tile1 to tile 2
/// </summary>
/// <param name="tile1"></param>
/// <param name="tile2"></param>
/// <returns></returns>
private BoardDirection determineDirectionT1ToT2(Point tile1, Point tile2)
{
//Declare variables
BoardDirection returnVal = BoardDirection.NUll;
if (isValidSpace(tile1) && isValidSpace(tile2))
{
if (tile1.X > tile2.X)
{
if (tile1.Y > tile2.Y)
{
returnVal = BoardDirection.UpLeft;
} //End if (tile1.Y > tile2.Y)
else if (tile1.Y < tile2.Y)
{
returnVal = BoardDirection.DownLeft;
} //End else if (tile1.Y < tile2.Y)
else
{
returnVal = BoardDirection.Left;
} //End else
} //End if (tile1.X > tile2.X)
else if (tile1.X < tile2.X)
{
if (tile1.Y > tile2.Y)
{
returnVal = BoardDirection.UpRight;
} //End if (tile1.Y > tile2.Y)
else if (tile1.Y < tile2.Y)
{
returnVal = BoardDirection.DownRight;
} //End else if (tile1.Y < tile2.Y)
else
{
returnVal = BoardDirection.Right;
} //End else
} //End else if (tile1.X < tile2.X)
else
{
if (tile1.Y > tile2.Y)
{
returnVal = BoardDirection.Up;
} //End if (tile1.Y > tile2.Y)
else if (tile1.Y < tile2.Y)
{
returnVal = BoardDirection.Down;
} //End else if (tile1.Y < tile2.Y)
else
{
returnVal = BoardDirection.NUll;
} //End else
} //End else
} //End if (isValidSpace(tile1) && isValidSpace(tile2))
return(returnVal);
} //End private BoardDirection determineDirectionT1ToT2(Point tile1, Point tile2)
public override void OnInspectorGUI()
{
Level level = this.target as Level;
EditorGUILayout.BeginHorizontal();
step = level.step;
EditorGUILayout.PropertyField(serializedObject.FindProperty("step"), true);
serializedObject.ApplyModifiedProperties();
EditorGUILayout.EndHorizontal();
if (this.step != level.step)
{
Debug.Log("Change Step Count");
this.step = level.step;
int[] newPieceIndex = new int[step];
BoardDirection[] newDirection = new BoardDirection[step];
for (int i = 0; i < level.pieceIndex.Length; i++)
{
if (i < newPieceIndex.Length)
{
newPieceIndex[i] = level.pieceIndex[i];
}
}
for (int i = 0; i < level.moveDirection.Length; i++)
{
if (i < newDirection.Length)
{
newDirection[i] = level.moveDirection[i];
}
}
level.pieceIndex = newPieceIndex;
level.moveDirection = newDirection;
}
//level.step = step;
for (int i = 0; i < step; i++)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Piece:", EditorStyles.label, GUILayout.Width(60));
if (i < level.pieceIndex.Length)
{
level.pieceIndex[i] = EditorGUILayout.IntField(level.pieceIndex[i], GUILayout.Width(60));
}
if (i < level.moveDirection.Length)
{
level.moveDirection[i] = (BoardDirection)EditorGUILayout.EnumPopup("Direction:", level.moveDirection[i]);
}
EditorGUILayout.EndHorizontal();
}
EditorUtility.SetDirty(level);
serializedObject.ApplyModifiedProperties();
}
public void OnHitPiece(BoardDirection direction, float time)
{
if (clock != null)
{
clock.OnHitClock(direction);
if (clock.triggered)
{
delayCall = new DelayCall();
delayCall.Init(time, OnClock);
}
}
}
// neighbouring function to get all boards in this specific direction
public List <Board> getAllBoardInDirection(BoardDirection bd)
{
List <Board> list = new List <Board>();
Board chain = boardEnumToReference(bd);
while (chain != null)
{ // recursively add the boards in the specified direction
list.Add(chain);
chain = chain.boardEnumToReference(bd);
}
return(list); // returns the list of boards in the direction
}
/// <remarks>More complex, intended for testing non-adjacent tiles.</remarks>
public void Set(Tile from, Tile to, BoardDirection fromDirection)
{
if (from == null || to == null)
{
return;
}
var fromC = from.Coordinates;
var toC = to.Coordinates;
var isGoingBackwardsX = false;
var xDir = Mathf.Sign(toC.x - fromC.x);
var facingX = !Mathf.Approximately(fromDirection.Value.x, 0f);
if (!Mathf.Approximately(xDir, 0f) && facingX)
{
isGoingBackwardsX = !Mathf.Approximately(Mathf.Sign(xDir), Mathf.Sign(fromDirection.Value.x));
}
var isGoingBackwardsY = false;
var yDir = Mathf.Sign(toC.y - fromC.y);
var facingY = !Mathf.Approximately(fromDirection.Value.y, 0f);
if (!Mathf.Approximately(yDir, 0f) && facingY)
{
isGoingBackwardsY = !Mathf.Approximately(Mathf.Sign(yDir), Mathf.Sign(fromDirection.Value.y));
}
if (facingX)
{
if (isGoingBackwardsX)
{
this.SetValue(0, Mathf.RoundToInt(yDir));
}
else
{
this.SetValue(Mathf.RoundToInt(xDir), 0);
}
}
else if (facingY)
{
if (isGoingBackwardsY)
{
this.SetValue(Mathf.RoundToInt(xDir), 0);
}
else
{
this.SetValue(0, Mathf.RoundToInt(yDir));
}
}
}
// neighbouring function to get a board in this specific direction and distance
public Board getBoardFromDirection(BoardDirection bd, int distance)
{
Board target = boardEnumToReference(bd); // initial
for (int x = 1; x < distance; x++)
{ // recursively find the board in the specified direction
if (target == null)
{
break; // no board here... do not continue...
}
target = target.boardEnumToReference(bd);
}
return(target);
}
//----------------------------------------------------------------------------------------------
public static List <Tile> GetAllTilesInDirection(Tile source, BoardDirection dir, int range)
{
List <Tile> result = new List <Tile>();
Tile nextTile = source.GetNeighborInDirection(dir);
int rangeLeft = range;
while (rangeLeft > 0 && nextTile != null)
{
result.Add(nextTile);
nextTile = nextTile.GetNeighborInDirection(dir);
rangeLeft--;
}
return(result);
}
//--------------------------------------------------------------------------------------------------------
private void Update()
{
if (isGameOver)
{
return;
}
blocks.RemoveAll(b => b == null);
if (!allowInput && !IsAnyBlockMoving)
{
// blocks just finished moving to their destinations
if (!SomethingJustPromoted)
{
ScoreMultPanel.ResetLevel();
}
// this part sucks - somehow there's food left over from last frame?
foreach (Block food in GlobalFood)
{
Destroy(food.gameObject);
}
GlobalFood.Clear();
CreateBlocks();
SaveGameState();
allowInput = true;
SomethingJustPromoted = false;
}
swipeDir = GetSwipeDirection();
if (swipeDir == BoardDirection.Null)
{
return;
}
ExecuteSwipe(out bool somethingMoved);
if (!somethingMoved)
{
return;
}
turnCount++;
allowInput = false;
ClearTutorials();
}
public static BoardTile ProcessDPad(BoardTile boardTile, BoardDirection direction, ItemType item)
{
switch (direction)
{
case BoardDirection.UP:
if (item == ItemType.Sliding)
{
return(new BoardTile(boardTile.X, 7));
}
else
{
return(new BoardTile(boardTile.X, boardTile.Y + 1));
}
case BoardDirection.DOWN:
if (item == ItemType.Sliding)
{
return(new BoardTile(boardTile.X, 0));
}
else
{
return(new BoardTile(boardTile.X, boardTile.Y - 1));
}
case BoardDirection.LEFT:
if (item == ItemType.Sliding)
{
return(new BoardTile(0, boardTile.Y));
}
else
{
return(new BoardTile(boardTile.X - 1, boardTile.Y));
}
case BoardDirection.RIGHT:
if (item == ItemType.Sliding)
{
return(new BoardTile(7, boardTile.Y));
}
else
{
return(new BoardTile(boardTile.X + 1, boardTile.Y));
}
default:
return(new BoardTile(-1, -1));
}
}
//--------------------------------------------------------------------------------------------------------
private static List <Hex> HexesInDirection(Hex source, BoardDirection dir)
{
List <Hex> result = new List <Hex> {
source
};
Hex crawler = source;
while (crawler.NeighborDirections.Contains(dir))
{
int dirIndex = crawler.NeighborDirections.FindIndex(d => d == dir);
crawler = crawler.Neighbors[dirIndex];
result.Add(crawler);
}
return(result);
}
/// <summary>
/// MovePhaseの実装セット
/// </summary>
#region MovePhase
public void SetDirection(int dir)
{
if (IsDuringTheMove)
{
return;
}
if (!board.CanMoveToDirection(currentSquare, BoardDirection.Up + dir))
{
Debug.Log("Nothing Square!");
return;
}
int nextSquare = board.GetSquare(currentSquare).GetAdjacentSquares(BoardDirection.Up + dir).Number;
if (board.PlayerIsInSquare(nextSquare))
{
Debug.Log("The square has already player!");
return;
}
if (numberOfMoves != 0 && (int)moveDirectionHistories[numberOfMoves - 1] == (dir + 2) % 4)
{
numberOfMoves--;
mobility += board.GetSquare(nextSquare).ConsumptionOfMobility;
moveDirection = BoardDirection.Up + dir;
IsDuringTheMove = true;
currentSquare = nextSquare;
directionUI.SetActive(false);
Debug.Log("Go Back");
return;
}
if (mobility < board.GetSquare(nextSquare).ConsumptionOfMobility)
{
Debug.Log("Cannot Move!");
return;
}
Debug.Log("Go Forward!");
directionUI.SetActive(false);
moveDirectionHistories[numberOfMoves] = BoardDirection.Up + dir;
moveDirection = moveDirectionHistories[numberOfMoves];
currentSquare = board.GetSquare(currentSquare).GetAdjacentSquares(BoardDirection.Up + dir).Number;
numberOfMoves++;
mobility -= board.GetSquare(nextSquare).ConsumptionOfMobility;
IsDuringTheMove = true;
}
public Player MovePlayer(BoardTile tile, BoardDirection direction)
{
var curPlayer = GetCurrentPlayer();
var oldPos = curPlayer.Position;
// curPlayer.Position = tile;
var othPlayer = PlayerList.GetAll().SingleOrDefault(plyr => plyr.Position.X == tile.X && plyr.Position.Y == tile.Y);
if (othPlayer != null)
{
othPlayer.Position = oldPos;
othPlayer.FacingDirection = Utilities.Opposite(direction);
}
curPlayer.Position = tile;
curPlayer.FacingDirection = direction;
curPlayer.MoveLeft -= 1;
return(curPlayer);
}
//----------------------------------------------------------------------------------------------
private static BoardDirection GetOppositeDirection(BoardDirection dir)
{
switch (dir)
{
case BoardDirection.DownRight:
return(BoardDirection.UpLeft);
case BoardDirection.UpLeft:
return(BoardDirection.DownRight);
case BoardDirection.UpRight:
return(BoardDirection.DownLeft);
}
// this must be BoardDirection.DownLeft
return(BoardDirection.UpRight);
}
//----------------------------------------------------------------------------------------------
private static (int, int) GetOffsetsForDirection(BoardDirection dir)
{
switch (dir)
{
case BoardDirection.DownRight:
return(1, -1);
case BoardDirection.UpLeft:
return(-1, 1);
case BoardDirection.UpRight:
return(1, 1);
}
// this must be BoardDirection.DownLeft
return(-1, -1);
}
} //End public BoardVals[,] getGameBoard()
public BoardDirection getReverseDirection(BoardDirection direction)
{
//Declare variables
BoardDirection reverseDirection = BoardDirection.NUll;
switch (direction)
{
case BoardDirection.Up:
reverseDirection = BoardDirection.Down;
break;
case BoardDirection.Down:
reverseDirection = BoardDirection.Up;
break;
case BoardDirection.Left:
reverseDirection = BoardDirection.Right;
break;
case BoardDirection.Right:
reverseDirection = BoardDirection.Left;
break;
case BoardDirection.UpLeft:
reverseDirection = BoardDirection.DownRight;
break;
case BoardDirection.UpRight:
reverseDirection = BoardDirection.DownLeft;
break;
case BoardDirection.DownLeft:
reverseDirection = BoardDirection.UpRight;
break;
case BoardDirection.DownRight:
reverseDirection = BoardDirection.UpLeft;
break;
default:
break;
} //End switch (direction)
return(reverseDirection);
} //End public BoardDirection getReverseDirection(BoardDirection direction)
//--------------------------------------------------------------------------------------------------------
private static BoardDirection Opposite(BoardDirection dir)
{
switch (dir)
{
case BoardDirection.UpLeft: return(BoardDirection.DownRight);
case BoardDirection.Up: return(BoardDirection.Down);
case BoardDirection.DownLeft: return(BoardDirection.UpRight);
case BoardDirection.UpRight: return(BoardDirection.DownLeft);
case BoardDirection.Down: return(BoardDirection.Up);
case BoardDirection.DownRight: return(BoardDirection.UpLeft);
}
return(BoardDirection.Null);
}
//--------------------------------------------------------------------------------------------------------
private HungryNeko AdjacentHungryNeko(Hex hex, BoardDirection dir)
{
foreach (HungryNeko neko in HungryNekos)
{
if (neko.IsHungry)
{
for (int i = 0; i < neko.FeedingHexes.Count; i++)
{
if (neko.FeedingHexes[i] == hex && neko.FeedingDirections[i] == dir)
{
return(neko);
}
}
}
}
return(null);
}
private bool CanReachTile(Tile tile, bool includeBackground, out BoardDirection inDirection)
{
inDirection = this.StartingDirection;
var tileIsInPath = this.Path.Contains(tile);
if (tileIsInPath)
{
return(false);
}
var tileHasPickup = Board.Instance.HasPickup(tile, includeBackground);
if (!tileHasPickup)
{
return(false);
}
var lastTile = this.Path.PeekLastTile() ?? this.AllowedStartingTile;
var fromDirection = inDirection;
if (!this.Path.IsClear())
{
// Change from direction to be from end of drawn path
fromDirection.Set(this.Path.PeekSecondLastTile(), lastTile);
}
inDirection.Set(lastTile, tile, fromDirection);
var pathSection = Board.Instance.Pathfind(lastTile, tile, inDirection);
var canPathfindToTile = true;
foreach (var t in pathSection)
{
if (t != lastTile && this.Path.Contains(t))
{
canPathfindToTile = false;
break;
}
}
return(canPathfindToTile);
}
public bool CanLeave(bool isUpper, BoardDirection direction)
{
if (isUpper)
{
if (upperState == HexagonState.Rock)
{
return(false);
}
if (direction == BoardDirection.Right || direction == BoardDirection.TopRight)
{
return((blockState & (int)HexagonEdget.UpperRight) == 0);
}
if (direction == BoardDirection.Left || direction == BoardDirection.TopLeft)
{
return((blockState & (int)HexagonEdget.UpperLeft) == 0);
}
if (direction == BoardDirection.BottomRight || direction == BoardDirection.BottomLeft)
{
return((blockState & (int)HexagonEdget.UpperDown) == 0 && (blockState & (int)HexagonEdget.DownUp) == 0);
}
}
else
{
if (lowerState == HexagonState.Rock)
{
return(false);
}
if (direction == BoardDirection.Right || direction == BoardDirection.BottomRight)
{
return((blockState & (int)HexagonEdget.DownRight) == 0);
}
if (direction == BoardDirection.Left || direction == BoardDirection.BottomLeft)
{
return((blockState & (int)HexagonEdget.DownLeft) == 0);
}
if (direction == BoardDirection.TopLeft || direction == BoardDirection.TopRight)
{
return((blockState & (int)HexagonEdget.UpperDown) == 0 && (blockState & (int)HexagonEdget.DownUp) == 0);
}
}
return(true);
}