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); }