Esempio n. 1
0
 // Use this for initialization
 void Start()
 {
     lives = 3;
     round = 1;
     boardController = GameObject.FindGameObjectWithTag ("Ground").GetComponent<BoardController> ();
     ballController = GameObject.FindGameObjectWithTag ("Ball").GetComponent<BallController> ();
 }
Esempio n. 2
0
    void Awake()
    {
        // Making sure there's no existing board
        if (boardHolder != null)
            Destroy (boardHolder);

        // Create a new board and find required scripts
        boardHolder = Instantiate (boardManager);
        boardScript = boardHolder.GetComponent<BoardController>();
        cardSlotScript = slotHolder.GetComponent<CardSlotManager> ();

        // Determine if we're running a tutorial or a multiplayer game. Will eventually require support for multiple game modes
        // --> use switch() and unique game mode managers
        if (tutorial) {
            // Start the tutorial
            tutorialScript = tutorialManager.GetComponent<TutorialController>();
            tutorialScript.StartTutorial();
        }
        else {
            // Starting a new multiplayer game
            boardScript.StartGame ();

            // Update Cardslots to reflect player colours
            cardSlotScript.ChangeSlotColours(PlayerColour.Instance.redSheep);
        }
    }
Esempio n. 3
0
        public void PutBoardUpdatesBoard()
        {
            var controller  = new BoardController();
            var board = new Board()
                {
                    Questions = new List<Question>
                        {
                            new Question()
                                {
                                    Answers = new List<Answer>
                                        {
                                            new Answer
                                                {
                                                    Text = "A1"
                                                },
                                            new Answer
                                                {
                                                    Text = "A2"
                                                }
                                        },
                                    Text = "Question 1",
                                    Order = 1
                                }
                        },
                    Name = "Board Name"
                };

            controller.PostBoard(board);
        }
Esempio n. 4
0
 public override void Initialize(BaseController _tokenController)
 {
     m_tokenController = (TokenController)_tokenController;
     m_tokenController.GetModel().OnTokenMoved += OnTokenMoved;
     m_tokenController.GetModel().OnTokenTeleported += OnTokenTeleported;
     m_boardController = GameObject.FindObjectOfType<BoardController>();
     base.Initialize(_tokenController);
 }
Esempio n. 5
0
 //diagonal
 public override List<Position> getAvailableSpaces(BoardController board)
 {
     List<Position> availableMoves = new List<Position>();
     availableMoves.Add(this.position.move(1,1));
     availableMoves.Add(this.position.move(1,-1));
     availableMoves.Add(this.position.move(-1,-1));
     availableMoves.Add(this.position.move(-1,1));
     return availableMoves;
 }
Esempio n. 6
0
 public bool positionIsInRange(BoardController board, Position newPos)
 {
     foreach(Position availPos in getAvailableSpaces(board)) {
       if(availPos.x == newPos.x && availPos.y == newPos.y) {
     return true;
       }
     }
     return false;
 }
Esempio n. 7
0
 public override void Initialize(BaseController _boardController)
 {
     m_boardController = (BoardController)_boardController;
     m_TilesView = new List<TileView>();
     m_StairsView = new List<StairView>();
     m_slideView = new List<SlideView>();
     SetupAllTilesView();
     SetupAllStairsView();
     SetupAllSliderView();
     base.Initialize(_boardController);
 }
Esempio n. 8
0
 void Start()
 {
     board = GameObject.Find("Board").GetComponent<BoardController>();
     board.driver = this.gameObject;
     InitShowControls();
     scAttack.Show();
     player = GameObject.Find("Player").GetComponent<PlayerController>();
     player.canCharge = false;
     player.driver = gameObject;
     enemies = GameObject.FindObjectsOfType(typeof(TinyEnemyController)) as TinyEnemyController[];
 }
Esempio n. 9
0
File: Loader.cs Progetto: Sundem/TD
        void Awake()
        {
            Instantiate<GameObject>(boardManager);

            var boardController = new BoardController();

            boardController.PreInit();
            boardController.Load();
            boardController.Init();

            Instantiate(Resources.Load<GameObject>("Prefabs/3D/mouse_tank"), Vector3.zero, Quaternion.identity);
        }
	void Awake () {
		if(Instance != null && Instance != this) 
		{
			DestroyImmediate(gameObject);
			return;
		}

		Instance = this;
		DontDestroyOnLoad(gameObject);
		boardController = GetComponent<BoardController>();
		enemies = new List<Enemy>();
	}
Esempio n. 11
0
        public MainWindow()
        {
            InitializeComponent();

            InitalizeWindow();

            InitalizeGrid();

            boardController = new BoardController(BoardXML);

            InitalizeSquare();
        }
Esempio n. 12
0
    void Awake()
    {
        if (Instance != null && Instance != this) {
            DestroyImmediate(gameObject);
            return;
        }

        //Screen.SetResolution(640, 480, true);
        Instance = this;
        DontDestroyOnLoad (gameObject);
        boardController = GetComponent<BoardController> ();
        enemies = new List<Enemy> ();
    }
Esempio n. 13
0
        void OnEnable()
        {
            boardController = new BoardController();
            path = boardController.GetPath(new Index(0, 3), new Index(29, 32));

            transform.position = boardController.GetCellPosition(new Index(0, 3));

            var targetCellPos = boardController.GetCellPosition(path.First<Index>());
            var direction = targetCellPos - transform.position;
            direction.Normalize();

            transform.rotation = Quaternion.LookRotation(direction);
        }
Esempio n. 14
0
 public void move(BoardController board, bool movePlayer1)
 {
     Model.State state = getState (board, movePlayer1);
     if(state.isTerminal) {
         Debug.Log("AI Not moving; game is over!");
         return;
     }
     Model.Action act = strat.getAction(state);
     PieceController mover = getPiece(board, act);
     PieceController captured = board.getTile(act.newPos).myPiece;
     if(captured != null) {
         Debug.Log("AI Moving player "+mover.model.playerNum+"'s "+ mover.model.color+" piece at (" + mover.model.position.x+","+mover.model.position.y+") "
                  +" to capture player "+captured.model.playerNum+"'s "+captured.model.color+" piece at ("+captured.model.position.x+","+captured.model.position.y+").");
         board.combine(mover, captured);
     } else {
         Debug.Log("AI Moving player "+mover.model.playerNum+"'s "+ mover.model.color+" piece at (" + mover.model.position.x+","+mover.model.position.y+") "
                  +" to ("+act.newPos.x+","+act.newPos.y+").");
         mover.move(act.newPos);
     }
 }
Esempio n. 15
0
        /// <summary>
        /// Консольный интерфейс добавления задач.
        /// </summary>
        /// <param name="boardController"></param>
        protected static void AddTaskToBoard(BoardController boardController, IPusher pusher)
        {
            Console.Clear();

            var nameTask = TryParseName("задачи");
            var date     = TryParseDate();
            var priority = TryParsePriority();

            if (pusher == null)
            {
                throw new ArgumentNullException("Следует передать интерфейс добавления задачи!");
            }
            try
            {
                pusher.AddTask(boardController, new Task(nameTask, date, priority));
            }
            catch (ArgumentException ex)
            {
                Console.Error.WriteLine(ex.Message);
            }
        }
Esempio n. 16
0
 public BoardController GetBoardController()
 {
     if (_boardController != null)
     {
         return(_boardController);
     }
     else
     {
         if (_board != null)
         {
             _boardController = new BoardController(_board);
             return(_boardController);
         }
         else
         {
             GenerateBoard();
             _boardController = new BoardController(_board);
             return(_boardController);
         }
     }
 }
Esempio n. 17
0
    private void Awake()
    {
        // Singleton setup for GameManager
        if (Instance == null)
        {
            //DontDestroyOnLoad(gameObject); // comment out singleton to goto menu
            Instance = this;
        }
        else if (Instance != this)
        {
            Destroy(gameObject);
        }

        PlayerController      = GetComponent <PlayerController>();
        MoneyController       = GetComponent <MoneyController>();
        CorporationController = GetComponent <CorporationController>();
        TileController        = GetComponent <TileController>();
        BoardController       = GetComponent <BoardController>();
        HudController         = GetComponent <HudController>();
        MainMenuController    = GetComponent <MainMenuController>();
    }
Esempio n. 18
0
        public void BoardControllerEnsureListOfUserBoards()
        {
            // Arrange
            List <Board> data_store_boards = new List <Board>
            {
                new Board {
                    Title = "My Awesome Board", BoardId = 1, Owner = owner
                },
                new Board {
                    Title = "My Grocery Board", BoardId = 2, Owner = owner
                }
            };
            BoardController controller = new BoardController(mock_repository.Object);

            mock_repository.Setup(r => r.GetAllBoards()).Returns(data_store_boards);
            // Act
            ViewResult result = controller.Index() as ViewResult;

            // Assert
            CollectionAssert.AreEqual(data_store_boards, result.ViewBag.Boards);
        }
Esempio n. 19
0
    private void SwitchPiece(int indexToSwitchTo)
    {
        AvailableWoodMaterial[currentPieceIndex].transform.position = Vector3.zero;
        AvailableWoodMaterial[currentPieceIndex].transform.rotation = Quaternion.identity;
        AvailableWoodMaterial[currentPieceIndex].SetActive(false);
        currentPieceIndex = indexToSwitchTo;

        AvailableWoodMaterial[currentPieceIndex].SetActive(true);
        currentBoardController = AvailableWoodMaterial[currentPieceIndex].GetComponent <BoardController>();
        if (currentAction == ActionState.OnSaw || (previousAction == ActionState.OnSaw && currentAction == ActionState.ChangingCamera))
        {
            EnableCurrentBoardMovement(true);
            RestrictCurrentBoardMovement(false, false);
            PlacePieceAtSpawnPoint(new Vector3(0.0f, 0.0f, -3.0f));
        }
        else if (currentAction == ActionState.UsingRuler || (previousAction == ActionState.UsingRuler && currentAction == ActionState.ChangingCamera))
        {
            EnableCurrentBoardMovement(false);
            PlacePieceAtSpawnPoint(new Vector3(-3.0f, 0.0f, 0.0f));
        }
    }
Esempio n. 20
0
    private void OnCombatEnd(bool suicide = false, bool draw = false)
    {
        UnitCard winner = attackingUnit;
        UnitCard loser  = defendingUnit;

        if (draw) //they both died
        {
            winner = null;
            loser  = null;
        }

        if (suicide) //swap winner and loser
        {
            winner = defendingUnit;
            loser  = attackingUnit;
        }

        if (winner != null)
        {
            LogWindow.Log("Combat Ended! " + winner.name + " is victorious!");
        }
        else
        {
            LogWindow.Log("Combat Ended! No one came out victorious!");
        }

        gameObject.SetActive(false);

        location.OnCombatEnd(winner, loser);

        player1Card.OnCombatEnd();
        player2Card.OnCombatEnd();

        GameController.GetPlayerController(PlayerInfo.PLAYER1).OnCombatEnd();
        GameController.GetPlayerController(PlayerInfo.PLAYER2).OnCombatEnd();

        BoardController.OnCombatEnd(winner);

        GameController.OnCombatEnd();
    }
Esempio n. 21
0
        public void TestPiecePositions()
        {
            GameObject      b    = new GameObject();
            Piece           p    = b.AddComponent <Piece>();
            BoardController c    = b.AddComponent <BoardController>();
            BoardPreparator prep = b.AddComponent <BoardPreparator>();

            prep.setTestData(p);
            c.setTestData(prep);
            float x = 10;
            float y = 5;

            b.transform.position = new Vector2(x, y);
            Assert.AreEqual(p.GetXPosition(), x);
            Assert.AreEqual(p.GetYPosition(), y);
            int x2 = 15;
            int y2 = 15;

            p.MoveTo(x2, y2);
            Assert.AreEqual(p.GetXPosition(), x2);
            Assert.AreEqual(p.GetYPosition(), y2);
        }
Esempio n. 22
0
    void Start()
    {
        orbitCamera = GameCamera.GetComponent <OrbitCamera>();

        numberOfCuts = DadosToCut.Count;
        UI_Manager.DisplayPlans(true);
        StillCutting          = true;
        BladeControl.Moveable = false;
        foreach (GameObject go in AvailableWoodMaterial)
        {
            go.SetActive(false);
        }
        foreach (DadoBlock dadoBlock in DadosToCut)
        {
            MeshRenderer meshRenderer = dadoBlock.GetComponent <MeshRenderer>();
            meshRenderer.material.color = Color.white;
        }
        AvailableWoodMaterial[currentPieceIndex].SetActive(true);
        currentBoardController = AvailableWoodMaterial[currentPieceIndex].GetComponent <BoardController>();
        UI_Manager.UpdateSelectionButtons(currentPieceIndex, AvailableWoodMaterial.Count);
        SetupForCutting();
    }
Esempio n. 23
0
    private void SwitchPiece(int indexToSwitchTo)
    {
        MiterGauge.HideMiterGauge();
        AvailableWoodMaterial[currentPieceIndex].transform.position = Vector3.zero;
        AvailableWoodMaterial[currentPieceIndex].transform.rotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
        AvailableWoodMaterial[currentPieceIndex].SetActive(false);
        currentPieceIndex = indexToSwitchTo;

        AvailableWoodMaterial[currentPieceIndex].SetActive(true);
        currentBoardController = AvailableWoodMaterial[currentPieceIndex].GetComponent <BoardController>();
        if (currentAction == ActionState.OnSaw || previousAction == ActionState.OnSaw)
        {
            EnableCurrentBoardMovement(true);
            RestrictCurrentBoardMovement(false, false);
        }
        else if (currentAction == ActionState.UsingRuler || previousAction == ActionState.UsingRuler)
        {
            EnableCurrentBoardMovement(false);
        }
        MiterGauge.WoodMaterial = AvailableWoodMaterial[currentPieceIndex].GetComponent <Rigidbody>();
        PlacePiece();
    }
Esempio n. 24
0
        public void GetResult_WhenTurtleInExit_ShouldReturnSuccess()
        {
            var exitPoint = new Point
            {
                X = 0,
                Y = 1
            };
            var gameSettings = new GameSettingsBuilder()
                               .WithStartingPositionDirection(Directions.North)
                               .WithStartingPositionX(0)
                               .WithStartingPositionY(0)
                               .WithExitPoint(exitPoint)
                               .Build();

            var sut = new BoardController(gameSettings);

            sut.MoveTurtle();

            var result = sut.GetResult();

            Assert.Equal(MovesResultPossibilities.Success, result);
        }
Esempio n. 25
0
    private void LoadObjects()
    {
        if (player == null)
        {
            player = GameObject.Find("Player").GetComponent <PlayerController>();
        }

        if (board == null)
        {
            board = GameObject.Find("Board").GetComponent <BoardController>();
        }

        if (frontground == null)
        {
            frontground = GameObject.Find("Frontground").GetComponent <Image>();
        }

        if (winSoundPlayer == null)
        {
            winSoundPlayer = GameObject.Find("Win Sound Player").GetComponent <WinSoundPlayer>();
        }
    }
Esempio n. 26
0
    void Update()
    {
        if (playerMove)
        {
            MovePlayer();
        }

        if (!gameOver)
        {
            CheckPlayerTimeOutToOver();
        }

        //Vegetable Picking
        if (Input.GetKeyDown(PickKey) && isTrigger && selectedObject.tag == "Veg")
        {
            PickVegetableFromTable();
        }

        //Picking Final Salad From Cjopping Board
        else if (Input.GetKeyDown(PickKey) && isTrigger && selectedObject.tag == "Board" && playerMove)
        {
            BoardController boardController = selectedObject.GetComponent <BoardController>();
            InstantiateVegetableFromBoard(boardController.boardId);
        }

        // Drop To Board
        else if (Input.GetKeyDown(DropKey) && isTrigger && selectedObject.tag == "Board" && playerMove)
        {
            BoardController boardController = selectedObject.GetComponent <BoardController>();
            DropToBoard(boardController.boardId, selectedObject);
        }

        //Drop or Devlivering Salad To Customer
        else if (Input.GetKeyDown(DropKey) && isTrigger && selectedObject.tag == "Customer")
        {
            CustomerController customerController = selectedObject.GetComponent <CustomerController>();
            DropToCustomerPlate(customerController.customerId);
        }
    }
Esempio n. 27
0
    //Awake is always called before any Start functions
    void Awake()
    {
        //Check if instance already exists
        if (instance == null)
        {
            //if not, set instance to this
            instance = this;
        }

        //If instance already exists and it's not this:
        else if (instance != this)
        {
            //Then destroy this. This enforces our singleton pattern, meaning there can only ever be one instance of a GameManager.
            Destroy(gameObject);
        }

        //Get a component reference to the attached BoardManager script
        board = GetComponent <BoardController>();

        //Call the InitGame function to initialize the first level
        board.InitGame();
    }
Esempio n. 28
0
        public void DelSubTaskTest()
        {
            // Arrange
            var nameBoard   = Guid.NewGuid().ToString();
            var nameTask    = "Name";
            var data        = DateTime.Parse("01.01.2023");
            var nameSubTask = "NameSubTask";

            // Act
            var controller = new BoardController(nameBoard);

            controller.AddTask(new Model.Task(nameTask, data));
            var task = controller.Tasks.First(t => t.Name == nameTask);

            controller.AddSubTask(task, new Task(nameSubTask, data));
            controller.DelSubTask(task, nameSubTask);
            var controller2 = new BoardController(nameBoard);

            // Assert
            Assert.IsNull(controller2.GetSubTasks(task));
            Assert.ThrowsException <ArgumentNullException>(() => controller2.DelSubTask(task, nameSubTask));
        }
Esempio n. 29
0
        public FrmSolitaireGUI(FrmSolitaire Invoker)
        {
            InitializeComponent();
            LoadCards();

            BoardController = new BoardController();
            Logic           = new SolitaireLogicComponent(StateController, BoardController);
            originalSize    = this.Size;

            ResizeBuffer(this.Width, this.Height);
            Resize += (s, e) => ResizeBuffer(((Form)s).Width, ((Form)s).Height);

            new Thread(() => {
                while (true)
                {
                    Thread.Sleep(15);
                    Draw();
                }
            }).Start();

            Invoker.OnScanComplete += Invoker_OnScanComplete;
        }
Esempio n. 30
0
        public void AddTaskTest()
        {
            // Arrange
            var nameBoard = Guid.NewGuid().ToString();
            var nameTask  = "Name";
            var data      = DateTime.Parse("01.01.2023");

            // Act
            var controller = new BoardController(nameBoard);

            controller.AddTask(new Model.Task(nameTask, data));
            var controller2 = new BoardController(nameBoard);
            var task        = controller.Tasks.First();

            // Assert
            Assert.IsNull(task.ExecutorsNik);
            Assert.AreEqual(task.DeadLine, data);
            Assert.AreEqual(task.Name, nameTask);
            Assert.AreEqual(task.Priority, Model.Priority.P4);
            Assert.AreEqual(task.Status, Model.Status.NotPerformed);
            Assert.IsNull(task.SubTasks);
            Assert.ThrowsException <ArgumentException>(() => controller.AddTask(new Model.Task(nameTask, data)));
        }
Esempio n. 31
0
        private IEnumerator SeekerCharge(BoardController board, Action after, SubHUDSprite seeker, Vector2 start, Vector2 end)
        {
            yield return(0.6f);

            float speed = -6;

            while ((start - end).Sign().Equals((seeker.Position - end).Sign()))
            {
                CheckSeekerCollision(board, seeker);
                speed            = Calc.Approach(speed, 26f, 30f * Engine.DeltaTime);
                seeker.Position += speed * (end - start).SafeNormalize();
                yield return(null);
            }
            while (speed > 0.5)
            {
                CheckSeekerCollision(board, seeker);
                speed            = Calc.Approach(speed, 0, 40f * Engine.DeltaTime);
                seeker.Position += speed * (end - start).SafeNormalize();
                yield return(null);
            }
            seeker.sprite.Play("takeHit");
            seeker.sprite.OnLoop = s => { seeker.RemoveSelf(); after(); };
        }
Esempio n. 32
0
 public GameplayController(
     Gameplay gameplay,
     Hud hud,
     PauseView pauseView,
     SummaryView summaryView,
     PenaltyView penaltyView,
     BonusView bonusView,
     Board board,
     BoardController boardInputController,
     LevelIntroView levelIntroView,
     TutorialView tutorialView)
 {
     m_gameplay             = gameplay;
     m_hud                  = hud;
     m_pauseView            = pauseView;
     m_summaryView          = summaryView;
     m_penaltyView          = penaltyView;
     m_bonusView            = bonusView;
     m_board                = board;
     m_levelIntroView       = levelIntroView;
     m_boardInputController = boardInputController;
     m_tutorialView         = tutorialView;
 }
Esempio n. 33
0
    // Use this for initialization
    void Awake()
    {
        if (Instance != null)
        {
            return;
        }

        Instance             = this;
        pieceToGameObjectMap = new Dictionary <Piece, GameObject>();
        boardController      = BoardController.Instance;
        board = boardController.Board;

        for (int i = 0; i < board.Pieces.Count; i++)
        {
            Piece      piece   = board.Pieces[i];
            GameObject pieceGO = new GameObject();
            pieceGO.name = piece.GetType().FullName;
            pieceGO.transform.SetParent(this.transform);
            pieceGO.transform.position = new Vector3(piece.Tile.C, piece.Tile.R);
            pieceGO.AddComponent <SpriteRenderer>();
            pieceToGameObjectMap.Add(boardController.Board.Pieces[i], pieceGO);
        }
    }
Esempio n. 34
0
    // Use this for initialization
    void Start()
    {
        Board = GameObject.Find("Board").GetComponent <BoardController>();

        Started        = false;
        TurnLength     = 1.0f;
        TurnButton     = GameObject.Find("TurnButton").GetComponent <Button>();
        ButtonText     = GameObject.Find("ButtonText").GetComponent <Text>();
        TimerText      = GameObject.Find("TimerText").GetComponent <Text>();
        TimerText.text = TurnLength.ToString();

        GameOverText   = GameObject.Find("GameOverText").GetComponent <Text>();
        PlayerTurnText = GameObject.Find("PlayerTurnText").GetComponent <Text>();
        BlockBoard     = GameObject.Find("BlockBoard");

        NeedNewBoard  = false;
        NeedNewCards  = 20;
        TurnCount     = 0;
        FirstTurn     = true;
        MatchTurn     = true;
        CurrentPlayer = P1;
        OtherPlayer   = P2;
    }
Esempio n. 35
0
    // TODO : Frozen, Silenced, DivineShield, Taunt, etc... renderers/overlays

    public static MinionController Create(BoardController parentBoard, Minion minion)
    {
        // Creating a new GameObject to hold all the components
        GameObject minionObject = new GameObject(minion.Card.Name);

        minionObject.transform.ChangeParent(parentBoard.transform);

        // Adding a BoxCollider to the GameObject
        BoxCollider collider = minionObject.AddComponent <BoxCollider>();

        collider.size = new Vector3(2.5f, 3.5f, 0.5f);

        // Adding a MinionController to the GameObject
        MinionController minionController = minionObject.AddComponent <MinionController>();

        minionController.Minion   = minion;
        minionController.Collider = collider;

        // Initializing the MinionController
        minionController.Initialize();

        return(minionController);
    }
        public void MoveSelectedPiece_SelectedPoint_PieceMovedRaised(
            int pointCount, int newPointModelIndex, int stubPointModelIndex, int pointIndex, int neightborIndex, int expectedCallCount)
        {
            // Arrange
            var stubPoints = TestHelper.CreatePointsWithBounds(pointCount);

            stubPoints[pointIndex].Neighbors = new List <PointModel> {
                stubPoints[neightborIndex]
            };

            var stubBoardService = Substitute.For <IBoardService>();

            stubBoardService.CreateInitialBoard()
            .Returns(new Tuple <List <PointModel>, List <List <PointModel> > >(stubPoints, null));

            var stubBoardModel = Substitute.For <BoardModel>(stubBoardService);

            var mockEventSubscriber = new MockEventSubscriber();

            stubBoardModel.NewPieceAdded    += mockEventSubscriber.Handle;
            stubBoardModel.SelectionChanged += mockEventSubscriber.Handle;
            stubBoardModel.PieceMoved       += mockEventSubscriber.Handle;

            var stubPlayer = Substitute.For <PlayerModel>(1, Colors.Yellow);

            var boardController = new BoardController(stubBoardModel);

            boardController.AddNewPiece(stubPoints[stubPointModelIndex], stubPlayer);
            boardController.ChangeSelection(stubPoints[stubPointModelIndex], stubPlayer, true);
            mockEventSubscriber.Reset();

            // Act
            boardController.MoveSelectedPiece(stubPoints[newPointModelIndex]);

            // Assert
            Assert.AreEqual(expectedCallCount, mockEventSubscriber.HitCount);
        }
        public void MoveSelectedPiece_ValidSelectedPoint_PieceIsMovedToCorrectPoint()
        {
            // Arrange
            var stubPoints = TestHelper.CreatePointsWithBounds(5);

            stubPoints[2].Neighbors = new List <PointModel> {
                stubPoints[3]
            };

            var stubBoardService = Substitute.For <IBoardService>();

            stubBoardService.CreateInitialBoard()
            .Returns(new Tuple <List <PointModel>, List <List <PointModel> > >(stubPoints, null));

            var mockBoardModel = Substitute.For <BoardModel>(stubBoardService);

            var stubEventSubscriber = new MockEventSubscriber();

            mockBoardModel.NewPieceAdded    += stubEventSubscriber.Handle;
            mockBoardModel.SelectionChanged += stubEventSubscriber.Handle;
            mockBoardModel.PieceMoved       += stubEventSubscriber.Handle;

            var stubPlayer = Substitute.For <PlayerModel>(1, Colors.Yellow);

            var boardController = new BoardController(mockBoardModel);

            boardController.AddNewPiece(stubPoints[1], stubPlayer);
            boardController.ChangeSelection(stubPoints[1], stubPlayer, true);

            // Act
            boardController.MoveSelectedPiece(stubPoints[2]);

            // Assert
            var expectedPoint = mockBoardModel.Points.Where(p => p.Bounds.Contains(stubPoints[2].Bounds)).First();

            Assert.AreEqual(stubPoints[2].Piece, expectedPoint.Piece);
        }
Esempio n. 38
0
    private bool research(int testX, int testY, BoardController controller, string color)
    {
        GameObject piece=controller.getPiece(testX+1, testY);
        if (piece!=null&&piece.GetComponent<GamePiece>().canHoldRequests)
            if (check (testX+1, testY, color)) return true;
        piece=controller.getPiece(testX-1, testY);
        if (piece!=null&&piece.GetComponent<GamePiece>().canHoldRequests)
            if (check (testX-1, testY, color)) return true;
        piece=controller.getPiece(testX, testY+1);
        if (piece!=null&&piece.GetComponent<GamePiece>().canHoldRequests)
            if (check (testX, testY+1, color)) return true;
        piece=controller.getPiece(testX, testY-1);
        if (piece!=null&&piece.GetComponent<GamePiece>().canHoldRequests)
            if (check (testX, testY-1, color)) return true;

        piece=controller.getPiece(testX+1, testY+1);
        if (piece!=null&&(piece.GetComponent<GamePiece>().transportsRequestsDiagonallym()||controller.getPiece(testX, testY).GetComponent<GamePiece>().transportsRequestsDiagonallym()))
            if (check (testX+1, testY+1, color)) return true;
        piece=controller.getPiece(testX+1, testY-1);
        if (piece!=null&&(piece.GetComponent<GamePiece>().transportsRequestsDiagonallym()||controller.getPiece(testX, testY).GetComponent<GamePiece>().transportsRequestsDiagonallym()))
            if (check (testX+1, testY-1, color)) return true;
        piece=controller.getPiece(testX-1, testY+1);
        if (piece!=null&&(piece.GetComponent<GamePiece>().transportsRequestsDiagonallym()||controller.getPiece(testX, testY).GetComponent<GamePiece>().transportsRequestsDiagonallym()))
            if (check (testX-1, testY+1, color)) return true;
        piece=controller.getPiece(testX-1, testY-1);
        if (piece!=null&&(piece.GetComponent<GamePiece>().transportsRequestsDiagonallym()||controller.getPiece(testX, testY).GetComponent<GamePiece>().transportsRequestsDiagonallym()))
            if (check (testX-1, testY-1, color)) return true;

        for (int i=0; i<pointsChecked.Count; i++) {
            if (((Vector2)pointsChecked[i]).x==testX&&((Vector2)pointsChecked[i]).y==testY) {
                pointsChecked.RemoveAt(i);
                i--;
            }
        }

        return false;
    }
Esempio n. 39
0
    public static void FindHints()
    {
        instance.hints.Clear();

        for (int j = 0; j < BoardController.height; ++j)
        {
            for (int i = 0; i < BoardController.width; ++i)
            {
                BaseGem gem = BoardController.GetGem(i, j);

                // Swap Right
                BaseGem otherGem = BoardController.GetGem(i + 1, j);
                if (otherGem && otherGem.type != gem.type)
                {
                    HintInfo hintInfo = instance.GetHint(gem, otherGem);

                    if (hintInfo != null && !instance.hints.Contains(hintInfo))
                    {
                        instance.hints.Add(hintInfo);
                    }
                }

                // Swap Up
                otherGem = BoardController.GetGem(i, j + 1);
                if (otherGem && otherGem.type != gem.type)
                {
                    HintInfo hintInfo = instance.GetHint(gem, otherGem);

                    if (hintInfo != null && !instance.hints.Contains(hintInfo))
                    {
                        instance.hints.Add(hintInfo);
                    }
                }
            }
        }
    }
Esempio n. 40
0
    void Start()
    {
        //Instatiate Board manager and the Board MVC as a component
        boardManager    = new BoardManager();
        boardController = new BoardController();
        boardManager.SetBoardController(boardController);
        boardManager.InstantiateBoardMVC();
        BoardLayout();

        //Instatiate Program manager and the Program MVC as a component
        programManager    = new ProgramManager();
        programController = new ProgramController();
        programManager.SetProgramController(programController);
        programManager.SetBoardController(boardManager.boardController);
        programManager.InstantiateProgramModeMVC();

        //Display initial board setup
        boardDisplay.color            = new Color(1, 1, 1, 1);
        programModeInstructions.color = new Color(1, 1, 1, 1);
        boardDisplay.text             = boardManager.boardView.UpdateBoardDisplay();

        //Win condition UI and instructions
        levelWinCondition.text = WinConditionStatus();
    }
Esempio n. 41
0
    /// <summary>
    /// Generates a new board.
    /// </summary>
    public void GenerateBoard()
    {
        // Base case: no tile prefab.
        if (tilePrefab == null) {
            Debug.LogError ("Missing reference to tile prefab.");
            return;
        }

        // Delete the old board object.
        if (board != null) {
            GameObject.DestroyImmediate (board.gameObject);
        }

        // Construct a board definition.
        BoardDefinition generatedBoardDefinition = new BoardDefinition (20, 20);

        // Construct the board GameObject.
        GameObject boardObject = new GameObject ("Generated Board");
        boardObject.transform.SetParent (transform);
        board = boardObject.AddComponent<BoardController> ();

        // Load the tiles onto the board.
        board.LoadBoard (generatedBoardDefinition, tilePrefab);
    }
Esempio n. 42
0
    public void Update()
    {
        if (!_CollapsingCollumns)
        {
            return;
        }
        for (int x = 0; x < _BoardSize._Column; ++x)
        {
            for (int y = 0; y < _BoardSize._Row; ++y)
            {
                if (_LinkerObjects[x, y] &&
                    _LinkerObjects[x, y].IsFalling())
                {
                    return;
                }
            }
        }
        _CollapsingCollumns = false;

        int shuffleCount = 0;

        while (shuffleCount < _MaxShuffles &&
               !BoardController.HasAnyThreeOrMoreChains(_BoardSize, _LinkerObjects))
        {
            ++shuffleCount;
            if (shuffleCount < _MaxShuffles)
            {
                BoardController.ShuffleBoard(_BoardSize, ref _BoardTiles, ref _LinkerObjects);
            }
            else
            {
                PostGameResults._ShuffleFailure = true;
                Publisher.Instance.NotifyAll(ESubjectTypes.LevelEnd);
            }
        }
    }
Esempio n. 43
0
 static void TasksMenu(UserController userController, BoardController boardController)
 {
     while (true)
     {
         Console.Clear();
         int i = 0;
         foreach (var task in boardController.Tasks)
         {
             Console.WriteLine($"[{++i}] {task}");
         }
         Console.WriteLine("[0] Назад.");
         if (Int32.TryParse(Console.ReadLine(), out int input))
         {
             if (input == 0)
             {
                 return;
             }
             if (input <= i)
             {
                 TaskMenu(userController, boardController, boardController.Tasks[--input]);
             }
         }
     }
 }
Esempio n. 44
0
    void Start()
    {
        // Store current window size for restoration after fullscreen
        // will remain at default (640x480) if already fullscreen
        if (!Screen.fullScreen)
        {
            width  = Screen.width;
            height = Screen.height;
        }

        // Set static prefab array references
        hexprefabs    = hexprefabcontainer;
        hexelprefabs  = hexelprefabcontainer;
        sounds        = soundcontainer;
        numbers       = numbercontainer;
        hexelpreviews = hexelpreviewcontainer;

        // Create controllers
        gamecontroller  = (GameController)gameObject.AddComponent <GameController>();
        boardcontroller = (BoardController)gameObject.AddComponent <BoardController>();
        rowcontroller   = (RowController)gameObject.AddComponent <RowController>();
        savecontroller  = (SaveController)gameObject.AddComponent <SaveController>();
        soundcontroller = (SoundController)gameObject.AddComponent <SoundController>();
    }
Esempio n. 45
0
    void Awake()
    {
        Instance = this;

        for (int laneIndex = 0; laneIndex < 8; laneIndex++)
        {
            var lane = new BoardLane();
            Lanes.Add(lane);
            float laneRotation = laneIndex / 2 * 90;
            for (int position = 0; position < LaneLength; position++)
            {
                if (laneIndex % 2 == 0)
                {
                    Vector2 newPosition = (InitialStraight + OffsetStraight * position).Rotate(laneRotation);
                    lane.Add(newPosition);
                }
                else
                {
                    Vector2 newPosition = (InitialDiagonal + OffsetDiagonal * position).Rotate(laneRotation);
                    lane.Add(newPosition);
                }
            }
        }
    }
Esempio n. 46
0
        public override IEnumerator Execute(BoardController boardController, List <Point> board)
        {
            if (this.unit == null)
            {
                yield return(null);
            }

            unit.Board = board;

            //MOVE, highlight tiles, move
            List <Point> validPositions = GetMovementValidPositions();

            boardController?.SwitchTilesFromActiveBoards(new HashSet <Point>(validPositions), TileStates.HIGHLIGHT);

            yield return(new WaitForSeconds(0.5f));

            Move();
            boardController?.ClearAllActiveBoardsDecorations();
            yield return(new WaitForSeconds(1f));

            //ATTACK
            Attack();
            yield return(new WaitForSeconds(1f));
        }
Esempio n. 47
0
 void Start()
 {
     cc = GetComponent<CapsuleCollider>();
     board = GameObject.Find("Board").GetComponent<BoardController>();
     inAttackEffect = new List<GameObject>();
     attackCollider = transform.Find("AttackArea").GetComponent<BoxCollider>();
     attackDistance = attackCollider.size.z * .75f;
     anim = transform.GetComponentInChildren<Animator>();
 }
Esempio n. 48
0
 private PieceController getPiece(BoardController board, Model.Action act)
 {
     return board.getTile(act.piece.position).myPiece;
 }
Esempio n. 49
0
 private Model.State getState(BoardController board, bool player1Turn)
 {
     return new Model.State(board.p1, board.p2, player1Turn);
 }
Esempio n. 50
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="roadCharacter"></param>
        private void HandleEndSquareCourse( BoardController boardController)
        {
            int nextRow = mRow;
            int nextColumn = mColumn;
            CardinalPoint roadDirection = mRoadDirection;
            CardinalPoint oppositeCardinalPoint = (CardinalPoint)Enum.ToObject(typeof(CardinalPoint), (((int)(mRoadDirection) + 2) % 4));
            CardinalPoint targetDirection = mOriginRoadDirection;
            switch (roadDirection)
            {
                case CardinalPoint.N:
                    nextRow += 1;
                    break;
                case CardinalPoint.S:
                    nextRow -= 1;
                    break;
                case CardinalPoint.E:
                    nextColumn += 1;
                    break;
                case CardinalPoint.W:
                    nextColumn -= 1;
                    break;
            }

            if ((nextRow < 0) || (nextRow > (boardController.Size - 1)) ||
                (nextColumn > (boardController.Size - 1)) || nextColumn < 0)
            {
                if ((nextRow < 0 && targetDirection == CardinalPoint.S) ||
                    (nextRow > (boardController.Size - 1) &&
                    targetDirection == CardinalPoint.N) ||
                    (nextColumn > (boardController.Size - 1) &&
                    targetDirection == CardinalPoint.E) ||
                    nextColumn < 0 &&
                    targetDirection == CardinalPoint.W)
                {
                    mSpeed = 0f;
                    mArrivedAtDestination = true;
                  }
                else
                {
                    mRoadDirection = oppositeCardinalPoint;
                }
            }
            else
            {
                mReachHalfSquare = false;
                mSquareLocation = 0;
                if (!boardController.HasSquareExit(nextRow, nextColumn, oppositeCardinalPoint))
                {
                    mRoadDirection = oppositeCardinalPoint;
                }
                else
                {
                    mRow = nextRow;
                    mColumn = nextColumn;
                }
            }
        }
Esempio n. 51
0
        /// <summary>
        /// Perform any transitioning
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="boardController"></param>
        private void UpdateBehavior(float dt, BoardController boardController)
        {

            Parent.AnimController.PlayAnimation(RoadAnimationNames.kIdle, MirrorMode.None);

            if (!mArrivedAtDestination)
            {
                if (mSquareLocation > 0.5f * Square.kPixelSize &&
                    !(mReachHalfSquare))
                {
                    //      Debug.WriteLine("Handle Half Square " + " Position " + roadCharacter.Position + " Row " + roadCharacter.Row + " Column " + roadCharacter.Column + "Direction " + roadCharacter.RoadDirection); 
                    HandleMiddleSquareCourse(boardController);
                    mReachHalfSquare = true;
                }
                else if (mSquareLocation > Square.kPixelSize)
                {
                    //        Debug.WriteLine("Handle End Square " + " Position " + roadCharacter.Position + " Row " + roadCharacter.Row + " Column " + roadCharacter.Column + "Direction " + roadCharacter.RoadDirection); 
                    HandleEndSquareCourse(boardController);
                }
            }
        }
Esempio n. 52
0
 void Update()
 {
     if (controller==null) controller=GameObject.Find("GameController").GetComponent<BoardController>();
     if (controller.selected!=gameObject||controller.getMovesLeft()==0||controller.getPlayerTurn()!=getPlayer()) mouseExited();
     if (gameObject.GetComponent<GamePiece>().getVirusSymbol()!=null) mouseExited();
 }
Esempio n. 53
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="character"></param>
        private void HandleMiddleSquareCourse( BoardController boardController)
        {
            int row = mRow;
            int column = mColumn;
            bool[] squareExitStatus = new bool[4];
            bool noExit = true;
            int randomCardinalPoint = mRandom.Next(0, 4) - 1;
            CardinalPoint targetDirection = mOriginRoadDirection;
            CardinalPoint currentDirection = mRoadDirection;

            // Cardinal Point{ N, W, S, E }
            for (int cardinalPoint = 0; cardinalPoint < 4; cardinalPoint++)
            {
                squareExitStatus[cardinalPoint] = boardController.HasSquareExit(row, column, (CardinalPoint)Enum.ToObject(typeof(CardinalPoint), cardinalPoint));
            }

            if (squareExitStatus[(int)targetDirection] && ((int)currentDirection != ((int)targetDirection + 2) % 4))
            {
                mRoadDirection = targetDirection;
                noExit = false;
            }
            else if (squareExitStatus[(int)mRoadDirection] && ((int)currentDirection != ((int)targetDirection + 2) % 4))
            {
                noExit = false;
            }
            else
            {
                for (int cardinalPoint = 0; cardinalPoint < 4; cardinalPoint++)
                {
                    randomCardinalPoint += 1;
                    if (randomCardinalPoint == 4)
                    {
                        randomCardinalPoint = 0;
                    }

                    if (randomCardinalPoint != (((int)(currentDirection) + 2) % 4) && (randomCardinalPoint != ((int)targetDirection + 2) % 4))
                    {
                        if (squareExitStatus[randomCardinalPoint])
                        {
                            mRoadDirection = (CardinalPoint)Enum.ToObject(typeof(CardinalPoint), randomCardinalPoint);
                            noExit = false;
                            cardinalPoint = 3;
                        }
                    }
                }
            }

            if (noExit)
            {
                if (squareExitStatus[(((int)targetDirection + 2) % 4)])
                {
                    mRoadDirection = (CardinalPoint)Enum.ToObject(typeof(CardinalPoint), (((int)(targetDirection) + 2) % 4));
                }
                else
                {
                    mRoadDirection = (CardinalPoint)Enum.ToObject(typeof(CardinalPoint), (((int)(currentDirection) + 2) % 4));
                }
            }
        }
Esempio n. 54
0
 // Use this for initialization
 void Start()
 {
     time = Time.time;
     Instance = this;
     pickSkill.onClick.AddListener(()=> PickSkillFunc(PlayerController.Instance.boneCount));
 }
Esempio n. 55
0
 // Use this for initialization
 void Start()
 {
     BoardController = FindObjectOfType<BoardController>();
 }
Esempio n. 56
0
 public void Initialize(int size)
 {
     Controller = new BoardController(size);
 }
Esempio n. 57
0
        public void Activity(float dt, BoardController boardController)
        {
            if (mTime >= 1.0f)
            {
                mTime = 0;

                mState = (DebugState) (((int) mState + 1) % 7);

                switch (mState)
                {
                    case DebugState.Idle:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kIdle, MirrorMode.None);
                        break;
                    case DebugState.Walk_Left:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kWalkRight, MirrorMode.None);
                        break;
                    case DebugState.Walk_Right:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kWalkRight, MirrorMode.Horizontal);
                        break;
                    case DebugState.Run_Left:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kRunRight, MirrorMode.None);
                        break;
                    case DebugState.Run_Right:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kRunRight, MirrorMode.Horizontal);
                        break;
                    case DebugState.Run_Forward:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kRunForward, MirrorMode.None);
                        break;
                    case DebugState.Run_Back:
                        Parent.AnimController.PlayAnimation(RoadAnimationNames.kRunBack, MirrorMode.None);
                        break;

                }

            }
            else
            {
                 mTime += dt;
            }

        }
Esempio n. 58
0
	// Use this for initialization
	void Awake ()
	{
		board = GetComponent<Board> ();
		detector = GetComponent<MatchDetector> ();
		boardController = GetComponent<BoardController> ();
	}
Esempio n. 59
0
    public void Start() {
		panelControllerFather = GetComponentInParent<BoardController> ();
        //textUI.text = this.type;
        RefreshDisplayText();
    }
Esempio n. 60
0
 public void Activity(float dt, BoardController boardController)
 {
     UpdateBehavior(dt, boardController);
     StepPosition(dt);
 }