void RpcFindTankScripts(int playerOnTurn)
 {
     // poiščemo primerne skritpe na tankih
     fireScript       = tanks[playerOnTurn].GetComponent <TankFire>();
     moveAndAimScript = tanks[playerOnTurn].GetComponent <TankMoveAndAim>();
 }
示例#2
0
    // popravi in pošlje informacijo o spremenjeni mapi vsem tankom
    public void SendMapInfoToTanks()
    {
        // popravi heightArray
        for (int x = 0; x < mapGrid.GetLength(0); x++)
        {
            for (int y = 0; y < mapGrid.GetLength(1); y++)
            {
                if (mapGrid[x, y] == 0)
                {
                    heightArray[x] = y - 1;
                    break;
                }
            }
        }


        // poiščemo vse tanke
        GameObject[] tanks = GameObject.FindGameObjectsWithTag("Player");
        foreach (GameObject tank in tanks)
        {
            TankMoveAndAim tankMoveScript = tank.GetComponent <TankMoveAndAim>();

            // pošljemo vsem tankom novo mapo
            tankMoveScript.mapHightArray = heightArray;
            // rečemo naj pogleda če se rabi tank kaj premakniti
            tankMoveScript.SetCoorectionBool(true);

            if (isNetworkGame)
            {
                tankMoveScript.CorrectTankNetworkPosition();
            }
        }

        // če je network match pošlji info o mapi še drugemu network igralcu
        if (NetworkInfo.isNetworkMatch)
        {
            GameObject[] allNetPlayers = GameObject.FindGameObjectsWithTag("NetworkPlayer");
            foreach (GameObject netPlayer in allNetPlayers)
            {
                netPlayer.GetComponent <NetworkPlayerManager>().SetMissileDestroyedCount(1);

                if (isMainMissile)
                {
                    netPlayer.GetComponent <NetworkPlayerManager>().CheckMap(heightArray);
                }
            }
        }


        //if (!isNetworkGame || isServer)
        if (!isNetworkGame)// || isServer)
        {
            GameObject.Find("GameManager").GetComponent <PlayerManager>().StopWaitingForNextPlayer();
        }

        /*
         * else if (isNetworkGame || !isServer)
         * {
         *  GameObject[] allNetPlayers = GameObject.FindGameObjectsWithTag("NetworkPlayer");
         *  foreach (GameObject netPlayer in allNetPlayers)
         *  {
         *      netPlayer.GetComponent<NetworkPlayerManager>().StopWaitingForNextPlayerRemote();
         *  }
         * }
         */
        // zgenerira edgeCollider za ground
        GenerateGroundEdgeCollider();
    }
    // korutina za začetek nasljednjega igralca
    IEnumerator WaitThenStartNextPlayerTrun()
    {
        /// Waiting ...
        ///
        // timerja še ne odšteva
        timerIsCounting = false;

        // please wait sliko nastavi na active
        if (!img_SelectionImageGameObjects[0].activeInHierarchy)
        {
            img_SelectionImageGameObjects[0].SetActive(true);
        }

        // še na vseh clientih ..
        if (isServer)
        {
            // parameter true pomeni da smo [0] sliko aktivira
            RpcActivateWaitAndOtherImages(true);
        }

        // čakamo dokler je true ... ; na false se postavi ko izteče timer, ali ko se uniči iztrelek; Timer se ustavi ko ustrelimo, tako da ni komplikacij tukaj
        while (waitingForNextPlayer)
        {
            yield return(null);
        }

        /// start next tanks turn
        ///
        // določimo index naslednjega igralca
        int nextPlayerIndex = playerOnHisTurn + 1;

        // če je index večji ali enak številu vseh tankov, je na vrsti spet tank z indexom 0;
        if (nextPlayerIndex >= tanks.Length)
        {
            nextPlayerIndex = 0;
        }

        // nastavimo index igralca na vrsti
        playerOnHisTurn = nextPlayerIndex;  // ta naj bi bil syncan tako da bi se moral takoj postaviti na vseh clientih (ampak mislim da se ne bo ker nismo v Cmd-ju - ne vem)
        // pošljemo ta index vsem tankom
        foreach (GameObject tank in tanks)
        {
            if (tank != null)
            {
                tank.GetComponent <TankMoveAndAim>().SetSelectedTank(playerOnHisTurn);
            }
        }

        // če je network sporoči še vsem clientom
        if (isServer)
        {
            RpcSetSelectedTank(playerOnHisTurn);
        }

        // aktiviramo vse slike z gumbi
        foreach (GameObject imageGO in img_SelectionImageGameObjects)
        {
            if (!imageGO.activeInHierarchy)
            {
                imageGO.SetActive(true);
            }
        }

        // če je network sporoči še vsem clientom
        if (isServer)
        {
            RpcActivateWaitAndOtherImages(false);
        }

        // poiščemo primerne skritpe na tankih
        fireScript       = tanks[playerOnHisTurn].GetComponent <TankFire>();
        moveAndAimScript = tanks[playerOnHisTurn].GetComponent <TankMoveAndAim>();

        // če je network sporoči še vsem clientom
        if (isServer)
        {
            RpcFindTankScripts(playerOnHisTurn);
        }

        // konča premike; brez tega: če držiš tipko za premik ko se čas izteče se to shrani
        // in ko je spet na vrsti ta tank se premika čeprav ne držiš tipke za premik!
        MoveStop();
        // deaktiviramo merjeneje z dotikom če je slučajno še aktivirano; to bi se zgodilo če se odšteje čas ko še merimo;
        TouchAimDeactivate();

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //**************************************************************************************************************
        // tole še 1x poglej
        // mogoče je potreben Rpc
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // nastavi sliderje in input fielde; just back check
        fireScript.FirePowerChangeBySliderOrInputField(false, false);
        moveAndAimScript.AimValueChangeBySliderOrInputField(false, false);

        if (!NetworkInfo.isNetworkMatch)
        {
            // izpiše kateri igralec je na vrsti
            playersTurnGameObject.GetComponent <Text>().text = "Player " + playerOnHisTurn + "!";
            // aktivira sliko
            playersTurnGameObject.SetActive(true);
            // počaka #.#f sekund; ta čas je napis aktiven
            while (true)
            {
                yield return(new WaitForSeconds(1.5f));

                break;
            }
            // ne rabimo slike ki pravi Please Wait;
            img_SelectionImageGameObjects[0].SetActive(false);

            // deaktiviramo napis;
            playersTurnGameObject.SetActive(false);
        }
        else if (NetworkInfo.isNetworkMatch && isServer)
        {
            // določi ime
            string nextPlayerName = "Player " + playerOnHisTurn + "!";
            // izpiše na vseh clientih
            RpcPrintNextPlayer(nextPlayerName);

            // počaka #.#f sekund; ta čas je napis aktiven
            while (true)
            {
                yield return(new WaitForSeconds(1.5f));

                break;
            }

            // deaktivira "Please Wait" sliko samo na primernem clientu in
            // deaktivira sliko z imenom za naslednjega igralca na vseh clientih
            RpcDeactivateWaitAndNextPlayerImage(playerOnHisTurn);
        }

        // nastavimo preostali čas na začetni čas
        roundTimeLeft = startRoundTime;
        // začnemo šteti
        timerIsCounting = true;
        yield return(null);
    }
示例#4
0
    public void MapCompatibility(int[] correctHeightArray)
    {
        if (heightArray != correctHeightArray && !isMainMissile)
        {
            for (int x = 0; x < heightArray.Length; x++)
            {
                if (heightArray[x] > correctHeightArray[x])
                {
                    for (int y = heightArray[x]; y > correctHeightArray[x]; y--)
                    {
                        mapGrid[x, y] = 0;
                        Vector3Int tilePosition = new Vector3Int(x, y, 0);
                        groundTileMap.SetTile(tilePosition, null);
                    }
                }
                else if (heightArray[x] < correctHeightArray[x])
                {
                    for (int y = heightArray[x]; y <= correctHeightArray[x]; y++)
                    {
                        mapGrid[x, y] = 5;
                        Vector3Int tilePosition = new Vector3Int(x, y, 0);
                        int        arrayIndex   = Random.Range(0, 2);
                        groundTileMap.SetTile(tilePosition, grassTiles[arrayIndex]);
                    }
                }
            }

            heightArray = correctHeightArray;

            // poiščemo vse tanke
            GameObject[] tanks = GameObject.FindGameObjectsWithTag("Player");
            foreach (GameObject tank in tanks)
            {
                TankMoveAndAim tankMoveScript = tank.GetComponent <TankMoveAndAim>();

                // pošljemo vsem tankom novo mapo
                tankMoveScript.mapHightArray = heightArray;
                // rečemo naj pogleda če se rabi tank kaj premakniti
                tankMoveScript.SetCoorectionBool(true);

                if (isNetworkGame)
                {
                    tankMoveScript.CorrectTankNetworkPosition();
                }
            }
        }

        // zgenerira edgeCollider za ground
        GenerateGroundEdgeCollider();

        /*
         * if (isServer)
         * {
         *  GameObject.Find("GameManager").GetComponent<PlayerManager>().StopWaitingForNextPlayer();
         * }
         *
         * else
         */
        {
            GameObject[] allNetPlayers = GameObject.FindGameObjectsWithTag("NetworkPlayer");
            foreach (GameObject netPlayer in allNetPlayers)
            {
                netPlayer.GetComponent <NetworkPlayerManager>().StopWaitingForNextPlayerRemote();
            }
        }
    }