public static SerializablePieceType serializePieceType(Manager.PieceType pieceType)
{
if (pieceType == null)
{
return(new SerializablePieceType("none", 0));
}
string name = pieceType.getTypeName();
switch (name)
{
case "standard":
case "bomb":
{
SerializablePieceType serializablePieceType = new SerializablePieceType(name, 1);
serializablePieceType.values[0] = ((Manager.NumberedPieceType)pieceType).number.ToString();
return(serializablePieceType);
}
default:
{
return(new SerializablePieceType(name, 0));
}
}
}
public static SerializableBoard serializeBoard(Board board)
{
int index = 0;
SerializableBoard serializableBoard = new SerializableBoard(board.tiles.Count);
foreach (GameObject tile in board.tiles)
{
Tile tileComponent = tile.GetComponent <Tile>();
GameObject piece = tileComponent.piece;
Manager.PieceType pieceType = null;
if (piece != null)
{
Piece pieceComponent = tileComponent.piece.GetComponent <Piece>();
pieceType = pieceComponent.pieceType;
}
serializableBoard.pieces[index++] = serializePieceType(pieceType);
}
serializableBoard.score = board.score;
serializableBoard.highestTile = board.highest;
serializableBoard.spawningScore = board.spawningScore;
serializableBoard.combo = board.comboManager.combo;
serializableBoard.comboTime = board.comboManager.comboTime;
serializableBoard.canMakeMove = board.canMakeMove();
return(serializableBoard);
}
public Vector2Int lowestPieceCount()
{
int lowestPiece = 999999999;
int count = 0;
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece != null)
{
Piece pieceComponent = tile.piece.GetComponent <Piece>();
Manager.PieceType pieceType = pieceComponent.pieceType;
if (!(pieceType is Manager.NumberedPieceType))
{
continue;
}
int number = ((Manager.NumberedPieceType)pieceType).getNumber();
if (number < lowestPiece)
{
lowestPiece = number;
count = 0;
}
if (number == lowestPiece)
{
count++;
}
}
}
return(new Vector2Int(lowestPiece, count));
}
public GameObject createPiece(Manager.PieceType pieceType)
{
if (pieceType is Manager.NumberedPieceType)
{
Manager.NumberedPieceType numberedPieceType = (Manager.NumberedPieceType)pieceType;
if (numberedPieceType.getNumber() > highest)
{
highest = numberedPieceType.getNumber();
}
}
return(Manager.instance.createPiece(pieceType));
}
public static bool deserializeBoard(SerializableBoard serializableBoard, Board board)
{
if (!serializableBoard.canMakeMove)
{
return(false);
}
int index = 0;
foreach (SerializablePieceType serializablePieceType in serializableBoard.pieces)
{
Manager.PieceType pieceType = deserializePieceType(serializablePieceType);
GameObject tile = board.tiles[index++];
Tile tileComponent = tile.GetComponent <Tile>();
GameObject oldPiece = tileComponent.piece;
tileComponent.unsetPiece();
if (oldPiece != null)
{
Destroy(oldPiece);
}
if (pieceType != null)
{
GameObject piece = Manager.instance.createPiece(pieceType);
piece.transform.localPosition = tile.transform.position;
tileComponent.setPiece(piece);
Piece pieceComponent = piece.GetComponent <Piece>();
pieceComponent.scaleIn.Stop(TweenStopBehavior.Complete);
}
}
board.score = serializableBoard.score;
board.highest = serializableBoard.highestTile;
board.spawningScore = serializableBoard.spawningScore;
board.comboManager.combo = serializableBoard.combo;
board.comboManager.comboTime = serializableBoard.comboTime;
board.displayScore = board.score;
Color na = new Color();
Manager.instance.getPieceColors(board.highest, out board.scoreColor, out na);
board.comboManager.scale = board.comboManager.combo > 0 ? 1 : 0;
board.comboManager.displayComboTime = serializableBoard.comboTime;
board.comboManager.comboColor = Manager.instance.getComboColor(Mathf.Max(board.comboManager.combo, 1));
return(true);
}
public void afterMove(bool success)
{
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
tile.pieceExploded = false;
}
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece != null)
{
Piece pieceComponent = tile.piece.GetComponent <Piece>();
Manager.PieceType pieceType = pieceComponent.pieceType;
if (pieceType is Manager.NumberedPieceType)
{
Manager.NumberedPieceType numberedPieceType = (Manager.NumberedPieceType)pieceType;
if (numberedPieceType.getNumber() > highest)
{
highest = numberedPieceType.getNumber();
}
}
}
}
if (success)
{
if (highest > spawningScore)
{
spawningScore = highest;
}
spawningScore += Manager.instance.gameMode.getProgressionSpeed();
placeRandomPiece();
}
save();
}
public void placeRandomPiece(Manager.PieceType pieceType)
{
List <Tile> empty = new List <Tile>();
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece == null && !tile.pieceExploded)
{
empty.Add(tile);
}
}
if (empty.Count == 0)
{
return;
}
Tile emptyTile = empty[(int)Mathf.Floor(UnityEngine.Random.value * empty.Count)];
GameObject piece = createPiece(pieceType);
emptyTile.setPiece(piece);
}
public MergeBehaviorPair(Manager.PieceType pieceType, Piece newPiece)
{
this.pieceType = pieceType;
this.newPiece = newPiece;
}
public bool canMerge(Manager.PieceType a, Manager.PieceType b)
{
return(a.canMerge(b) || b.canMerge(a));
}
public bool merge(Manager.Direction direction, bool didCompress)
{
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece != null)
{
GameObject piece = tile.piece;
Piece pieceComponent = piece.GetComponent <Piece>();
pieceComponent.merge = 0;
}
}
bool change = true;
bool looped = false;
while (change)
{
change = false;
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece != null)
{
Piece piece = tile.piece.GetComponent <Piece>();
Manager.PieceType pieceType = piece.pieceType;
GameObject neighborAhead = tile.neighbors[direction];
Tile neighborAheadTile = neighborAhead != null?neighborAhead.GetComponent <Tile>() : null;
Piece neighborAheadPiece = neighborAheadTile != null && neighborAheadTile.piece != null?neighborAheadTile.piece.GetComponent <Piece>() : null;
Manager.PieceType neighborAheadPieceType = neighborAheadPiece != null ? neighborAheadPiece.pieceType : null;
GameObject neighborBehind = tile.neighbors[Manager.instance.opposite(direction)];
Tile neighborBehindTile = neighborBehind != null?neighborBehind.GetComponent <Tile>() : null;
Piece neighborBehindPiece = neighborBehindTile != null && neighborBehindTile.piece != null?neighborBehindTile.piece.GetComponent <Piece>() : null;
Manager.PieceType neighborBehindPieceType = neighborBehindPiece != null ? neighborBehindPiece.pieceType : null;
if (neighborAheadTile != null && neighborAheadPiece != null && canMerge(pieceType, neighborAheadPieceType) && (neighborBehindTile == null || neighborBehindPiece == null || !canMerge(pieceType, neighborBehindPieceType)))
{
change = true;
neighborAheadPiece.merge = piece.merge + 1;
neighborAheadPiece.combo = pieceType.contribuesToCombo() ? 1 : 0;
neighborAheadPiece.scoreAccumulator = piece.scoreAccumulator + piece.pieceType.getPointsForMerge();
List <Manager.PieceType> mergingPieceTypes = new List <Manager.PieceType>();
mergingPieceTypes.AddRange(piece.mergingPieceTypes);
mergingPieceTypes.Add(neighborAheadPiece.pieceType);
neighborAheadPiece.mergingPieceTypes = mergingPieceTypes;
GameObject pieceObject = tile.piece;
Piece pieceToAnimate = pieceObject.GetComponent <Piece>();
tile.unsetPiece();
Vector3 position = piece.oldPosition;
Vector3 tilePosition = tile.transform.localPosition;
float scaleBy = transform.localScale.x;
Vector2 vector = Manager.instance.directionVector(direction) * 0.4f * scaleBy;
pieceToAnimate.clearAnimations();
pieceToAnimate.moveWhenMergeAnimation = TweenFactory.Tween(null, new Vector3(0, 0, -3) + position * scaleBy, new Vector3(vector.x, vector.y, -3) + position * scaleBy, 0.25f, TweenScaleFunctions.CubicEaseOut, t =>
{
if (pieceObject == null)
{
return;
}
pieceObject.transform.localPosition = t.CurrentValue;
}, t =>
{
Destroy(pieceObject);
});
pieceToAnimate.scaleOutWhenMergeAnimation = TweenFactory.Tween(null, new Vector3(Manager.instance.tileScale, Manager.instance.tileScale, Manager.instance.tileScale), new Vector3(0, 0, 0), 0.25f, TweenScaleFunctions.CubicEaseOut, t =>
{
if (pieceObject == null)
{
return;
}
pieceObject.transform.localScale = t.CurrentValue * scaleBy;
});
}
}
}
if (!change && !looped)
{
animateOffset();
return(false);
}
looped = true;
}
float toAddScore = 0;
int maxCombo = 0;
Dictionary <Tile, GameObject> newPieces = new Dictionary <Tile, GameObject>();
List <MergeBehaviorPair> mergeBehaviors = new List <MergeBehaviorPair>();
foreach (GameObject gameObject in tiles)
{
Tile tile = gameObject.GetComponent <Tile>();
if (tile.piece != null)
{
GameObject piece = tile.piece;
Piece pieceComponent = piece.GetComponent <Piece>();
int combo = pieceComponent.combo;
int merge = pieceComponent.merge;
if (combo > maxCombo)
{
maxCombo = combo;
}
toAddScore += pieceComponent.scoreAccumulator;
if (merge > 0)
{
Manager.PieceType pieceType = pieceComponent.mergingPieceTypes[0];
for (int i = 1; i < pieceComponent.mergingPieceTypes.Count; i++)
{
pieceType = pieceComponent.mergingPieceTypes[i].mergeResult(pieceType);
}
GameObject newPiece = createPiece(pieceType);
Piece newPieceComponent = newPiece.GetComponent <Piece>();
newPieceComponent.scaleIn.Stop(TweenStopBehavior.Complete);
tile.unsetPiece();
newPieces[tile] = newPiece;
newPieceComponent.tile = tile;
for (int i = 0; i < pieceComponent.mergingPieceTypes.Count; i++)
{
mergeBehaviors.Add(new MergeBehaviorPair(pieceComponent.mergingPieceTypes[i], newPieceComponent));
}
Destroy(piece);
newPieceComponent.clearAnimations();
newPieceComponent.mergeAnimation = TweenFactory.Tween(null, new Vector3(1.15f, 1.15f, 1.15f), new Vector3(1f, 1f, 1f), 0.2f, TweenScaleFunctions.QuadraticEaseIn, t =>
{
if (newPiece == null)
{
return;
}
Vector3 scale = t.CurrentValue;
if (newPieceComponent.tile == null)
{
scale *= Manager.instance.tileScale;
}
newPiece.transform.localScale = scale;
});
}
}
}
foreach (Tile tile in newPieces.Keys)
{
tile.setPiece(newPieces[tile]);
}
foreach (MergeBehaviorPair behavior in mergeBehaviors)
{
behavior.execute();
}
comboManager.addCombo(maxCombo);
toAddScore *= comboManager.getComboMultiplier();
score += (int)Mathf.Floor(toAddScore);
compress(direction);
animateOffset();
return(true);
}
