public override void OnExit(StatedMono <PlayerStateEnum> statedMono)
{
if (draggedPiece)
{
draggedPiece.Unselect();
}
}
/// <summary>
/// I really don't check if p1 == p2, it's unecessary. The only edge case is in doubling movement speed (And I don't care about this for the moment)
/// </summary>
/// <param name="statedMono"></param>
public override void OnEnter(StatedMono<GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
PlacePieceData placePieceData = grid.frameDataBuffer.GetLast<MessageData<PlacePieceData>>((x) => x.message == "PlacePiece").obj;
p1 = placePieceData.piece;
Vector2 position = placePieceData.position;
p2 = grid.gridPieces[(int)position.x][(int)position.y];
startTime = grid.clock.CurrentRenderTime;
p1StartPosition = p1.ViewPosition;
p2StartPosition = p2.ViewPosition;
if (Vector2.SqrMagnitude((Vector2)p1.PhysicsPosition - position) <= 1 && (grid.PlacingWillCreateConnection(p1.PieceType, p2.PhysicsPosition, p1.PhysicsPosition) || grid.PlacingWillCreateConnection(p2.PieceType, p1.PhysicsPosition, p2.PhysicsPosition)))
{
p1EndPosition = p2.PhysicsPosition;
p2EndPosition = p1.PhysicsPosition;
grid.InterChange(p1, p2);
playerConnections = grid.GetCrossConnections(p1.PieceType, p1.PhysicsPosition);
ServiceProvider.GetService<SFXSystem>().PlaySFX(grid.validSwapAudioClip);
}
else
{
p1EndPosition = p1.PhysicsPosition;
p2EndPosition = p2.PhysicsPosition;
playerConnections = null;
ServiceProvider.GetService<SFXSystem>().PlaySFX(grid.badSwapAudioClip);
}
}
public override void OnExit(StatedMono <PieceStateEnum> statedMono)
{
Piece piece = statedMono as Piece;
piece.StopBehaviour();
piece.pooledElement.Pool();
}
public override void OnEnter(StatedMono <PlayerStateEnum> statedMono)
{
Player player = statedMono as Player;
draggedPiece = player.frameDataBuffer.GetLast <MessageData <Piece> >(x => x.message == "PieceTaken").obj;
currentGrid = ServiceProvider.GetService <Grid>(); //Just get the grid and catch it
}
public override void OnEnter(StatedMono <LevelStateEnum> statedMono)
{
LevelSystem levelSystem = statedMono as LevelSystem;
int currentScore = ServiceProvider.GetService <ScoreSystem>().GetScore();
PersistentDataSystem persistentDataSystem = ServiceProvider.GetService <PersistentDataSystem>();
ScoreSavedData scoreSavedData = persistentDataSystem.GetSavedData <ScoreSavedData>();
int bestScore = scoreSavedData.bestScore;
if (bestScore < currentScore)
{
scoreSavedData.bestScore = currentScore;
persistentDataSystem.SaveData(scoreSavedData);
}
ServiceProvider.GetService <ResultScreenView>().Show(currentScore, scoreSavedData.bestScore);
IPausable[] pausables = GameObjectExtensions.FindObjectsOfTypeAll <IPausable>(true);
for (int i = 0; i < pausables.Length; i++)
{
pausables[i].Pause(); //Awake all entities in the level
}
timer = levelSystem.clock.CurrentRenderTime + 5f;
}
public override void OnEnter(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
pieceToDestroy = grid.frameDataBuffer.GetLast <MessageData <List <Piece> > >((x) => x.message == "DeletePieces").obj;
timer = grid.clock.CurrentRenderTime + 0.25f;
positions = new List <Vector2>(pieceToDestroy.Count);
for (int i = 0; i < pieceToDestroy.Count; i++)
{
positions.Add(pieceToDestroy[i].PhysicsPosition);
}
if (pieceToDestroy.Count >= 5)
{
ServiceProvider.GetService <SFXSystem>().PlaySFX(grid.comboAudioClip);
}
if (grid.LastState.stateType == GridStateEnum.GENERATING_NEW_PIECES)
{
countCombo++;
}
else
{
countCombo = 1;
}
ServiceProvider.GetService <ScoreSystem>().AddScore(pieceToDestroy.Count, countCombo);
}
public override GridStateEnum CheckForNextState(StatedMono <GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
if (grid.frameDataBuffer.Exists <MessageData <Piece> >((x) => x.message == "PieceTaken")) //This is the most important, let player play
{
return(GridStateEnum.PIECE_BEING_DRAGGED);
}
//Gestion state by message
if (grid.frameDataBuffer.Exists <MessageData <Vector2> >((x) => x.message == "Generate"))
{
return(GridStateEnum.GENERATING_PIECES);
}
if (grid.frameDataBuffer.Exists <MessageData <List <Piece> > >((x) => x.message == "DeletePieces"))
{
return(GridStateEnum.DELETING_PIECES);
}
if (grid.frameDataBuffer.Exists <MessageData <Piece> >((x) => x.message == "PlacePiece"))
{
return(GridStateEnum.SWITCHING_PIECES);
}
return(this.stateType);
}
public override void OnUpdate(StatedMono <PlayerStateEnum> statedMono)
{
Player player = statedMono as Player;
Vector2 position = (Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -Camera.main.transform.position.z)));
//Help the player to understand what is permitted
position.x = Mathf.Clamp(position.x, draggedPiece.PhysicsPosition.x - 1, draggedPiece.PhysicsPosition.x + 1);
position.y = Mathf.Clamp(position.y, -(draggedPiece.PhysicsPosition.y + 1), -(draggedPiece.PhysicsPosition.y - 1));
//Not a real distance, but do the job
float distToY = Mathf.Abs(position.y + draggedPiece.PhysicsPosition.y);
float distToX = Mathf.Abs(position.x - draggedPiece.PhysicsPosition.x);
//Goal: inside a small square where player can drag the piece freely, or outside the square : -> clamp to the lines
//We can improve this with 1/x function, and find the nearest point to the curve, for lerping position between line clamping. But... no time for this, square + lerp do the job for this test.
if (distToY > distToX && distToY > 0.2f) //Sort of clamp on a line (not true in case of rotation)
{
position.x = draggedPiece.PhysicsPosition.x;
}
else if (distToX > 0.2f)
{
position.y = -draggedPiece.PhysicsPosition.y;
}
//
draggedPiece.ViewPosition = Vector2.Lerp(draggedPiece.ViewPosition, position, player.clock.DeltaRenderTime * 8f);
if (!Input.GetMouseButton(0))
{
currentGrid.PlacePiece(draggedPiece, currentGrid.WorldToGridPosition(draggedPiece.ViewPosition));
draggedPiece.Unselect();
draggedPiece = null;
}
}
public override PlayerStateEnum CheckForNextState(StatedMono <PlayerStateEnum> statedMono)
{
if (draggedPiece == null) //A click, you can replace this by a more sophisticated input module in real project.
{
return(PlayerStateEnum.WAITING_FOR_INPUT);
}
return(this.stateType);
}
public override void OnEnter(StatedMono <PieceStateEnum> statedMono)
{
Piece piece = statedMono as Piece;
ServiceProvider.GetService <SFXSystem>().PlayUniqueSFX(piece.destroyAudioClip);
timerForPooling = piece.clock.CurrentRenderTime + 1f;
piece.pieceView.PlayDestroyVFX();
}
public override void OnExit(StatedMono <PlayerStateEnum> statedMono)
{
Player player = statedMono as Player;
if (selectedPiece && !player.frameDataBuffer.Exists <MessageData <Piece> >((x) => x.message == "PieceTaken"))
{
selectedPiece.Unselect();
}
}
public override LevelStateEnum CheckForNextState(StatedMono <LevelStateEnum> statedMono)
{
if (timer != -1 && ((LevelSystem)statedMono).clock.CurrentRenderTime > timer && waitCoroutine == null)
{
return(LevelStateEnum.RUN);
}
return(this.stateType);
}
public override PlayerStateEnum CheckForNextState(StatedMono <PlayerStateEnum> statedMono)
{
if (foundPiece)
{
return(nextState);
}
return(this.stateType);
}
public override LevelStateEnum CheckForNextState(StatedMono <LevelStateEnum> statedMono)
{
if (timer.GetRemainingTime() <= 0)
{
return(LevelStateEnum.END);
}
return(this.stateType);
}
public override void OnEnter(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
allPiecesFall = false;
missingPosition = grid.frameDataBuffer.GetLast <MessageData <List <Vector2> > >((x) => x.message == "GeneratePieces").obj;
piecesToMove.Clear();
//Ok now count what is missing per column
int[] missingPiecePerColumn = new int[(int)grid.size.x];
int[] maxYPerColumn = new int[(int)grid.size.x];
for (int i = 0; i < missingPosition.Count; i++)
{
int x = (int)missingPosition[i].x;
missingPiecePerColumn[x] += 1;
maxYPerColumn[x] = Mathf.Max(maxYPerColumn[x], (int)missingPosition[i].y);
}
for (int i = 0; i < missingPiecePerColumn.Length; i++) //Just place them in the right place in the array. View position will be placed later.
{
int maxY = maxYPerColumn[i];
int missingCount = missingPiecePerColumn[i];
if (missingCount > 0)
{
int keepPieceY = maxY - missingCount;
for (int j = 0; j <= keepPieceY; j++) //Place kept pieces at final position
{
Piece p = grid.gridPieces[i][j];
Vector3 pPosition = p.PhysicsPosition;
pPosition.y += missingCount;
p.PhysicsPosition = pPosition;
piecesToMove.Add(p);
}
for (int j = maxY; j > missingCount - 1; j--)
{
grid.gridPieces[i][j] = grid.gridPieces[i][j - missingCount]; //Interchange
}
for (int j = 0; j < missingCount; j++) //Populate missing pieces
{
Piece p = grid.Populate(i, j);
p.ViewPosition = new Vector2(i, -j + missingCount);
piecesToMove.Add(grid.gridPieces[i][j]);
}
}
}
yVelocity = 0f;
}
public override GridStateEnum CheckForNextState(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
if (pieceToDestroy.Count == 0)
{
return(GridStateEnum.GENERATING_NEW_PIECES);
}
return(this.stateType);
}
public override PieceStateEnum CheckForNextState(StatedMono <PieceStateEnum> statedMono)
{
Piece p = statedMono as Piece;
if (p.frameDataBuffer.Exists <MessageData>((x) => x.message == ("BeReleased")))
{
return(PieceStateEnum.WAITING_FOR_INPUT);
}
return(this.stateType);
}
public override void OnExit(StatedMono <GridStateEnum> statedMono)
{
//Just replace all pieces, jsut in case
Grid grid = (Grid)statedMono;
foreach (var item in piecesToMove)
{
item.ViewPosition = new Vector2(item.PhysicsPosition.x, -item.PhysicsPosition.y);
item.gameObject.SetActive(true);
}
}
public override void OnUpdate(StatedMono <GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
List <Piece> connections = grid.GetFirstPiecesConnection(3);
if (connections != null)
{
grid.frameDataBuffer.AddData(new MessageData <List <Piece> >("DeletePieces", connections));
}
}
public override void OnUpdate(StatedMono <LevelStateEnum> statedMono)
{
LevelSystem levelSystem = statedMono as LevelSystem;
if (loadingCoroutine == null && timer < levelSystem.clock.CurrentRenderTime)
{
AutoScriptFlowSystem autoScriptFlow = ServiceProvider.GetService <AutoScriptFlowSystem>();
autoScriptFlow.autoIAwake = false;
autoScriptFlow.autoIStart = false;
loadingCoroutine = ServiceProvider.GetService <CoroutineProvider>().StartCoroutine(levelSystem.gameRootScenePackage.LoadScenePackageCoroutine());
}
}
public override void OnExit(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
for (int i = 0; i < grid.size.x; i++)
{
for (int j = 0; j < grid.size.y; j++)
{
grid.gridPieces[i][j].ViewPosition = new Vector3(i, -j, grid.ViewPosition.z); //Starting to left top
}
}
}
public override PieceStateEnum CheckForNextState(StatedMono <PieceStateEnum> statedMono)
{
Piece piece = statedMono as Piece;
if (timerForPooling <= piece.clock.CurrentRenderTime)
{
return(PieceStateEnum.WAITING_FOR_INPUT);
}
else
{
return(this.stateType);
}
}
public override GridStateEnum CheckForNextState(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
float deltaTime = grid.clock.CurrentRenderTime - startTime;
if (deltaTime > 2f)
{
return(GridStateEnum.WAITING_FOR_INPUT);
}
else
{
return(this.stateType);
}
}
public override void OnExit(StatedMono <GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
grid.gridView.StopHighlighting(highlightList);
grid.gridView.Select(draggedPiece.PhysicsPosition, false);
if (lastGridViewHover != null)
{
grid.gridView.Hover((Vector2)lastGridViewHover, false);
}
lastGridViewHover = null;
}
public override void OnUpdate(StatedMono <GridStateEnum> statedMono)
{
Grid grid = (Grid)statedMono;
float deltaTime = grid.clock.DeltaRenderTime;
float gt = gravity * deltaTime;
yVelocity += gt;
gt *= 0.5f * deltaTime;
float deltaPosition = yVelocity * deltaTime + gt; //Cache this
bool stillFalling = false;
foreach (var p in piecesToMove)
{
Vector2 targetPosition = p.PhysicsPosition;
targetPosition.y *= -1f;
p.ViewPosition = new Vector2(p.ViewPosition.x, Mathf.Max(targetPosition.y, p.ViewPosition.y + deltaPosition));
if (!stillFalling && p.ViewPosition.y - targetPosition.y >= 0.01f)
{
stillFalling = true;
}
if (p.ViewPosition.y > grid.ViewPosition.y + 1f)
{
p.gameObject.SetActive(false);
}
else
{
p.gameObject.SetActive(true);
}
}
if (!stillFalling)
{
allPiecesFall = true;
}
List <Piece> connections = grid.GetFirstPiecesConnection(3);
if (connections != null)
{
grid.frameDataBuffer.AddData(new MessageData <List <Piece> >("DeletePieces", connections));
}
}
/// <summary>
/// Main purpose: Add a small effect when generating piece
/// </summary>
/// <param name="statedMono"></param>
public override void OnUpdate(StatedMono<GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
float deltaTime = grid.clock.CurrentRenderTime - startTime;
//Ok do the switch
float speed = 1f/timeToSwitch; //We can catch this for performance
p1.ViewPosition = Vector2.Lerp(p1StartPosition, new Vector2(p1EndPosition.x, -p1EndPosition.y), deltaTime * speed);
p2.ViewPosition = Vector2.Lerp(p2StartPosition, new Vector2(p2EndPosition.x, -p2EndPosition.y), deltaTime * speed);
if (playerConnections != null)
{
grid.frameDataBuffer.AddData(new MessageData<List<Piece>>( "DeletePieces", playerConnections)); //This is not very CPU friendly, but I lack a sort of "blackboard" tool
}
}
public override void OnUpdate(StatedMono <PlayerStateEnum> statedMono)
{
string message = null;
if (Input.GetMouseButton(0)) //A click, you can replace this by a more sophisticated input module in real project.
{
//This is algorithm for testing if player did 1% of the distance of the diagonal of it screen.
//if (startDragPoint == null)
// startDragPoint = Input.mousePosition;
//if (Vector2.Distance((Vector2)startDragPoint, Input.mousePosition) /(Mathf.Sqrt(Screen.height* Screen.height + Screen.width* Screen.width)) >= 0.01)
//
if (startDragPoint == null)
{
startDragPoint = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -Camera.main.transform.position.z));
}
//But I prefere to check if player did 10% of the current grid cellul as a swipe
if (Vector2.Distance((Vector2)startDragPoint, Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -Camera.main.transform.position.z))) >= 0.1)
{
foundPiece = currentGrid.AskForAPiece((Vector2)startDragPoint);
message = "PieceTaken";
nextState = PlayerStateEnum.DRAGGING_PIECE;
}
}
else if (Input.GetMouseButtonUp(0))
{
Vector2 position = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -Camera.main.transform.position.z));
foundPiece = currentGrid.AskForAPiece(position);
message = "PieceSelected";
nextState = PlayerStateEnum.SELECTING_PIECE;
}
else
{
startDragPoint = null;
}
if (foundPiece)
{
currentGrid.Take(foundPiece); //Just in case, double check we really can get this
Player player = statedMono as Player;
player.frameDataBuffer.AddData(new MessageData <Piece>(message, foundPiece)); //Pass the data to the next state
foundPiece.Select();
}
}
public override PlayerStateEnum CheckForNextState(StatedMono <PlayerStateEnum> statedMono)
{
Player player = statedMono as Player;
if (player.frameDataBuffer.Exists <MessageData <Piece> >((x) => x.message == "PieceTaken"))
{
return(PlayerStateEnum.DRAGGING_PIECE);
}
if (foundPiece)
{
return(PlayerStateEnum.WAITING_FOR_INPUT);
}
return(this.stateType);
}
public override PieceStateEnum CheckForNextState(StatedMono <PieceStateEnum> statedMono)
{
Piece p = statedMono as Piece;
if (p.frameDataBuffer.Exists <MessageData>((x) => x.message == ("BeTaken")))
{
return(PieceStateEnum.DRAGGED);
}
if (p.frameDataBuffer.Exists <MessageData>((x) => x.message == ("Destroy")))
{
return(PieceStateEnum.BEING_DESTROYED);
}
return(this.stateType);
}
public override GridStateEnum CheckForNextState(StatedMono <GridStateEnum> statedMono)
{
Grid grid = statedMono as Grid;
if (grid.frameDataBuffer.Exists <MessageData <PlacePieceData> >((x) => x.message == "PlacePiece"))
{
return(GridStateEnum.SWITCHING_PIECES);
}
if (draggedPiece.CurrentStateType != PieceStateEnum.DRAGGED)
{
return(GridStateEnum.WAITING_FOR_INPUT);
}
return(this.stateType);
}
