예제 #1
0
    private void SpawnCharacter(int i_TeamIndex, int i_TeamSize, int i_SpawnIndex, int i_PhotonPlayerId, tnCharacterDescription i_CharacterDescription)
    {
        if (m_CharacterPrefab == null || i_CharacterDescription == null)
        {
            return;
        }

        int descriptorCharacterId       = i_CharacterDescription.characterId;
        int descriptorOnlinePlayerIndex = i_CharacterDescription.onlinePlayerIndex;
        int descriptorPlayerId          = i_CharacterDescription.playerId;

        string[] spawnPointsNames = SpawnPoints.GetSpawnPoints(i_TeamIndex, i_TeamSize);

        if (spawnPointsNames == null)
        {
            return;
        }

        if (i_SpawnIndex < 0 || i_SpawnIndex >= spawnPointsNames.Length)
        {
            return;
        }

        string     spawnPointName = spawnPointsNames[i_SpawnIndex];
        GameObject spawnPointGo   = GameObject.Find(spawnPointName);

        if (spawnPointGo == null)
        {
            return;
        }

        TSTransform2D spawnPoint = spawnPointGo.GetComponent <TSTransform2D>();

        if (spawnPoint == null)
        {
            return;
        }

        tnCharacterData characterData = tnGameData.GetCharacterDataMain(descriptorCharacterId);

        if (characterData == null)
        {
            return;
        }

        tnTeamsModule teamsModule = GameModulesManager.GetModuleMain <tnTeamsModule>();

        if (teamsModule == null)
        {
            return;
        }

        tnTeamDescription teamDescription = teamsModule.GetTeamDescription(i_TeamIndex);

        if (teamDescription == null)
        {
            return;
        }

        int   teamId    = teamDescription.teamId;
        Color teamColor = teamDescription.teamColor;

        tnTeamData teamData = tnGameData.GetTeamDataMain(teamId);

        if (teamData == null)
        {
            return;
        }

        bool isLocal = (PhotonNetwork.offlineMode) ? true : tnGameModulesUtils.IsLocalPlayer(descriptorOnlinePlayerIndex);
        bool isHuman = (PhotonNetwork.offlineMode) ? (descriptorPlayerId != Hash.s_NULL) : (descriptorOnlinePlayerIndex >= 0);

        Vector3    spawnPosition = spawnPoint.position.ToVector();
        Quaternion spawnRotation = Quaternion.Euler(0f, 0f, spawnPoint.rotation.AsFloat());

        // Spawn character.

        GameObject characterInstance = Instantiate <GameObject>(m_CharacterPrefab);

        characterInstance.name = characterData.displayName;

        characterInstance.transform.position = spawnPosition;
        characterInstance.transform.rotation = spawnRotation;

        // Configure TSTransform

        TSTransform2D tsTransform = characterInstance.GetComponent <TSTransform2D>();

        if (tsTransform != null)
        {
            tsTransform.position = spawnPoint.position;
            tsTransform.rotation = spawnPoint.rotation;
        }

        // Configure depth2d.

        tnDepth2d depth2d = characterInstance.GetComponent <tnDepth2d>();

        if (depth2d != null)
        {
            depth2d.SetOffset(spawnPointGo.transform.position.z);
        }

        // Configure character stats database.

        tnStatsDatabase teamStats = teamData.teamStats;

        tnStatsContainer statsContainer = characterInstance.GetComponent <tnStatsContainer>();

        if (statsContainer != null)
        {
            statsContainer.SetStatsDatabase(teamStats);
        }

        // Configure character view.

        tnCharacterViewController characterViewController = characterInstance.GetComponent <tnCharacterViewController>();

        if (characterViewController != null)
        {
            // Base color.

            characterViewController.SetBaseColor(teamColor);

            // Charging force bar.

            characterViewController.SetChargingForceBarColor(teamColor);

            // Energy bar.

            characterViewController.SetEnergyBarColor(teamColor);

            // Flag.

            characterViewController.SetFlagSprite(teamData.baseSprite);

            // Animator

            characterViewController.SetAnimatorController(characterData.animatorController);

            // Set facing right.

            characterViewController.SetFacingRight((spawnPoint.position.x < 0f));

            // Player color.

            characterViewController.TurnOffColor();
            characterViewController.SetArrowVisible(false);
            characterViewController.SetArrowColor(Color.white);

            if (isLocal)
            {
                if (PhotonNetwork.offlineMode)
                {
                    if (isHuman)
                    {
                        tnPlayerData playerData = tnGameData.GetPlayerDataMain(descriptorPlayerId);
                        if (playerData != null)
                        {
                            Color playerColor = playerData.color;

                            characterViewController.SetPlayerColor(playerColor);

                            characterViewController.SetArrowVisible(true);
                            characterViewController.SetArrowColor(playerColor);
                        }
                    }
                }
                else
                {
                    List <int> onlinePlayersKeys = tnGameData.GetOnlinePlayersKeysMain();
                    if (onlinePlayersKeys != null)
                    {
                        if (descriptorOnlinePlayerIndex >= 0 && descriptorOnlinePlayerIndex < onlinePlayersKeys.Count)
                        {
                            int onlinePlayerKey = onlinePlayersKeys[descriptorOnlinePlayerIndex];
                            tnOnlinePlayerData onlinePlayerData = tnGameData.GetOnlinePlayerDataMain(onlinePlayerKey);
                            if (onlinePlayerData != null)
                            {
                                Color playerColor = onlinePlayerData.color;

                                characterViewController.SetPlayerColor(playerColor);

                                characterViewController.SetArrowVisible(true);
                                characterViewController.SetArrowColor(playerColor);
                            }
                        }
                    }
                }
            }
        }

        // Input: NOTE that current aiFacotry assumes that all AI are handled by the same client.
        // If you want to support AI in multiplayer you should change the ai factory implementation.
        // Now multiplayer isn't implemented, so now, if you're using AI, you are playing offline --> All AIs are yours.

        if (isLocal)
        {
            tnInputFiller      inputFiller      = null;
            tnRumbleController rumbleController = null;

            int  localPlayerIndex;
            bool localPlayerIndexFound = tnGameModulesUtils.OnlineToLocalPlayerIndex(descriptorOnlinePlayerIndex, out localPlayerIndex);
            if (localPlayerIndexFound || PhotonNetwork.offlineMode)
            {
                tnLocalPartyModule localPartyModule = GameModulesManager.GetModuleMain <tnLocalPartyModule>();

                int          playerId   = (PhotonNetwork.offlineMode) ? descriptorPlayerId : ((localPartyModule != null) ? localPartyModule.GetPlayerId(localPlayerIndex) : Hash.s_NULL);
                tnPlayerData playerData = tnGameData.GetPlayerDataMain(playerId);

                if (playerData != null)
                {
                    string playerInputName     = playerData.playerInputName;
                    string wifiPlayerInputName = playerData.wifiPlayerInputName;

                    PlayerInput     playerInput     = InputSystem.GetPlayerByNameMain(playerInputName);
                    WiFiPlayerInput wifiPlayerInput = WiFiInputSystem.GetPlayerByNameMain(wifiPlayerInputName);

                    if (playerInput != null)
                    {
                        inputFiller      = new tnPlayerInputFiller(playerInput);
                        rumbleController = new tnRumbleController(playerInput);

                        m_LocalPlayersInput.Add(playerInput);
                    }
                    else
                    {
                        if (wifiPlayerInput != null)
                        {
                            inputFiller = new tnWiFiPlayerInputFiller(wifiPlayerInput);

                            m_LocalWifiPlayersInput.Add(wifiPlayerInput);
                        }
                    }
                }
                else
                {
                    tnAIInputFiller aiInputFiller = CreateAIInputFiller(i_TeamIndex, i_SpawnIndex, characterInstance);
                    inputFiller = aiInputFiller;

                    List <tnAIInputFiller> aiList = m_LocalAI[i_TeamIndex];
                    aiList.Add(aiInputFiller);
                }
            }

            // Bind input filler to character instance.

            if (inputFiller != null)
            {
                tnInputController inputController = new tnInputController(inputFiller);
                inputController.SetRumbleController(rumbleController);

                AddInputController(inputController);

                tnCharacterInput characterInput = characterInstance.GetComponent <tnCharacterInput>();
                if (characterInput != null)
                {
                    characterInput.Bind(inputController);
                }
            }

            // Add rumble component.

            if (isHuman)
            {
                tnRumbleParams rumbleParams = Resources.Load <tnRumbleParams>(s_RumbleParams_ResourcePath);

                if (rumbleParams != null)
                {
                    tnRumble rumbleComponent = characterInstance.GetComponent <tnRumble>();
                    if (rumbleComponent == null)
                    {
                        rumbleComponent = characterInstance.AddComponent <tnRumble>();
                    }

                    rumbleComponent.SetParams(rumbleParams);
                }
            }

            // Input Delay.

            int delay = (TrueSyncManager.isOfflineMain) ? m_OfflinePlayerInputDelay : 0;

            if (!isHuman)
            {
                tnMatchSettingsModule matchSettingsModule = GameModulesManager.GetModuleMain <tnMatchSettingsModule>();
                int       aiLevelIndex = (matchSettingsModule != null) ? matchSettingsModule.aiLevelIndex : (tnGameData.aiLevelCountMain / 2);
                tnAILevel aiLevel      = tnGameData.GetAILevelMain(aiLevelIndex);
                if (aiLevel != null)
                {
                    delay = aiLevel.inputDelay;
                }
            }

            // Register on player input collector.

            RegisterObjectOnInputCollector(characterInstance, delay);
        }

        // Configure character info.

        tnCharacterInfo characterInfo = characterInstance.GetComponent <tnCharacterInfo>();

        if (characterInfo == null)
        {
            characterInfo = characterInstance.AddComponent <tnCharacterInfo>();
        }

        int characterIndex = m_Characters.Count;

        characterInfo.SetCharacterIndex(characterIndex);
        characterInfo.SetCharacterId(descriptorCharacterId);
        characterInfo.SetTeamIndex(i_TeamIndex);
        characterInfo.SetTeamId(teamId);
        characterInfo.SetTeamColor(teamColor);

        // Callback.

        OnCharacterSpawned(i_TeamIndex, characterIndex, characterInstance);

        // Add characters to lists.

        m_Characters.Add(characterInstance);
        if (isLocal)
        {
            m_LocalCharacters.Add(characterInstance);
        }

        List <GameObject> team = m_Teams[i_TeamIndex];

        team.Add(characterInstance);

        // Create character result.

        tnCharacterResults characterResults = CreateCharacterResults(descriptorCharacterId);

        characterResults.isHuman = isHuman;

        tnTeamResults teamResults = GetTeamResultsByIndex(i_TeamIndex);

        if (teamResults != null)
        {
            teamResults.AddCharacterResults(characterResults);
        }

        m_CharactersResults.Add(characterResults);

        // Track character result.

        StateTracker.AddTracking(characterResults);

        // Configure TrueSyncObject.

        TrueSyncObject trueSyncObject = characterInstance.GetComponent <TrueSyncObject>();

        if (trueSyncObject != null)
        {
            trueSyncObject.SetOwnerId(i_PhotonPlayerId);
            TrueSyncManager.RegisterTrueSyncObjectMain(trueSyncObject);
        }
    }
    private void SpawnReferee()
    {
        tnMatchSettingsModule matchSettingsModule = GameModulesManager.GetModuleMain <tnMatchSettingsModule>();

        if (matchSettingsModule == null)
        {
            return;
        }

        int refereeOptionId = matchSettingsModule.refereeOption;

        m_HasReferee = false;

        string refereeOption;

        if (tnGameData.TryGetRefereeValueMain(refereeOptionId, out refereeOption))
        {
            m_HasReferee = (refereeOption == "ON");
            if (m_HasReferee)
            {
                GameObject refereeSpawnPointGo = GameObject.Find(s_RefereeSpawnPoint);

                if (refereeSpawnPointGo == null)
                {
                    return;
                }

                TSTransform2D refereeSpawnPointTransform = refereeSpawnPointGo.GetComponent <TSTransform2D>();

                if (refereeSpawnPointTransform == null)
                {
                    return;
                }

                GameObject refereePrefab = Resources.Load <GameObject>(s_ResourcePath_Referee);
                if (refereePrefab != null)
                {
                    Vector3    spawnPosition = refereeSpawnPointTransform.position.ToVector();
                    Quaternion spawnRotation = Quaternion.Euler(0f, 0f, refereeSpawnPointTransform.rotation.AsFloat());

                    GameObject refereeInstance = Instantiate <GameObject>(refereePrefab);
                    refereeInstance.gameObject.name = "Referee";

                    refereeInstance.transform.position = spawnPosition;
                    refereeInstance.transform.rotation = spawnRotation;

                    // Configure TSTransform

                    TSTransform2D tsTransform = refereeInstance.GetComponent <TSTransform2D>();
                    if (tsTransform != null)
                    {
                        tsTransform.position = refereeSpawnPointTransform.position;
                        tsTransform.rotation = refereeSpawnPointTransform.rotation;
                    }

                    // Configure input filler and tnCharacterInput.

                    if (PhotonNetwork.isMasterClient)
                    {
                        tnRefereeInputFiller inputFiller = new tnRefereeInputFiller(refereeInstance);
                        inputFiller.SetBall(m_Ball);

                        tnInputController inputController = new tnInputController(inputFiller);
                        AddInputController(inputController);

                        tnCharacterInput characterInput = refereeInstance.GetComponent <tnCharacterInput>();
                        if (characterInput != null)
                        {
                            characterInput.Bind(inputController);
                        }

                        RegisterObjectOnInputCollector(refereeInstance, 0);
                    }

                    // Configure depth2d.

                    tnDepth2d depth2d = refereeInstance.GetComponent <tnDepth2d>();
                    if (depth2d != null)
                    {
                        depth2d.SetOffset(refereeSpawnPointGo.transform.position.z);
                    }

                    // Setup true sync object.

                    TrueSyncObject trueSyncObject = refereeInstance.GetComponent <TrueSyncObject>();
                    if (trueSyncObject != null)
                    {
                        int ownerId = 0;
                        if (!PhotonNetwork.offlineMode && (PhotonNetwork.masterClient != null))
                        {
                            ownerId = PhotonNetwork.masterClient.ID;
                        }

                        trueSyncObject.SetOwnerId(ownerId);

                        TrueSyncManager.RegisterTrueSyncObjectMain(trueSyncObject);
                    }

                    m_RefereeInstance = refereeInstance;
                }
            }
        }
    }
    private void CreateSupporters()
    {
        if (!m_CreateSupporters)
        {
            return;
        }

        tnTeamsModule teamsModule = GameModulesManager.GetModuleMain <tnTeamsModule>();

        if (teamsModule == null)
        {
            return;
        }

        System.Random random = new System.Random(m_Seed);

        string[] animatedResourceNames = new string[]
        {
            "Characters/Common/p_Supporter01_Animated",
            "Characters/Common/p_Supporter02_Animated",
            "Characters/Common/p_Supporter03_Animated",
        };

        string[] staticResourceNames = new string[]
        {
            "Characters/Common/p_Supporter01",
            "Characters/Common/p_Supporter02",
            "Characters/Common/p_Supporter03",
        };

        // Load animated resources.

        List <GameObject> animatedResources = new List <GameObject>();

        for (int resourceIndex = 0; resourceIndex < animatedResourceNames.Length; ++resourceIndex)
        {
            GameObject resourcePrefab = (GameObject)Resources.Load <GameObject>(animatedResourceNames[resourceIndex]);

            if (resourcePrefab == null)
            {
                continue;
            }

            animatedResources.Add(resourcePrefab);
        }

        // Load static resources.

        List <GameObject> staticResources = new List <GameObject>();

        for (int resourceIndex = 0; resourceIndex < staticResourceNames.Length; ++resourceIndex)
        {
            GameObject resourcePrefab = (GameObject)Resources.Load <GameObject>(staticResourceNames[resourceIndex]);

            if (resourcePrefab == null)
            {
                continue;
            }

            staticResources.Add(resourcePrefab);
        }

        // Iterate each supporter area.

        tnSupporterArea[] supportersAreas = FindObjectsOfType <tnSupporterArea>();

        for (int supporterAreaIndex = 0; supporterAreaIndex < supportersAreas.Length; ++supporterAreaIndex)
        {
            tnSupporterArea supporterArea = supportersAreas[supporterAreaIndex];

            if (supporterArea == null)
            {
                continue;
            }

            // Compute team colors for this area.

            List <Color> teamColors = new List <Color>();

            Vector3 boundsMin = supporterArea.boundsMin;
            Vector3 boundsMax = supporterArea.boundsMax;

            if (boundsMin.x < 0f || boundsMax.x < 0f)
            {
                // Assign to Team 0.

                tnTeamDescription teamDescription = teamsModule.GetTeamDescription(0);
                if (teamDescription != null)
                {
                    Color[] colorsToAdd = GetTeamColors(teamDescription.teamId);
                    teamColors.AddRange(colorsToAdd);
                }
            }

            if (boundsMin.x > 0f || boundsMax.x > 0f)
            {
                // Assign to Team 1.

                tnTeamDescription teamDescription = teamsModule.GetTeamDescription(1);
                if (teamDescription != null)
                {
                    Color[] colorsToAdd = GetTeamColors(teamDescription.teamId);
                    teamColors.AddRange(colorsToAdd);
                }
            }

            Color[] spawnColors = teamColors.ToArray();

            if (spawnColors.Length == 0)
            {
                continue;
            }

            // Spawn supporters.

            for (int supporterIndex = 0; supporterIndex < supporterArea.numPoints; ++supporterIndex)
            {
                GameObject supporterPrefab = null;

                if (supporterIndex < supporterArea.maxAnimators)
                {
                    // Select an animated resource.

                    int resourceIndex = random.Next(0, animatedResources.Count);
                    supporterPrefab = animatedResources[resourceIndex];
                }
                else
                {
                    // Select a static resource.

                    int resourceIndex = random.Next(0, staticResources.Count);
                    supporterPrefab = staticResources[resourceIndex];
                }

                if (supporterPrefab == null)
                {
                    continue;
                }

                Vector2 spawnPoint    = supporterArea.GetPoint(supporterIndex);
                Vector3 spawnPosition = new Vector3(spawnPoint.x, spawnPoint.y, 0f);

                GameObject supporterInstance = (GameObject)Instantiate(supporterPrefab, spawnPosition, Quaternion.identity);

                if (supporterInstance.transform.position.x > 0f)
                {
                    Vector3 flipScale = supporterInstance.transform.localScale;
                    flipScale.x *= -1f;

                    supporterInstance.transform.localScale = flipScale;
                }

                supporterInstance.transform.SetParent(supporterArea.transform, true);

                tnSupporter supporterComponent = supporterInstance.GetComponent <tnSupporter>();
                if (supporterComponent != null)
                {
                    int   randomIndex = random.Next(0, teamColors.Count);
                    Color randomColor = teamColors[randomIndex];
                    supporterComponent.SetColor(randomColor);
                }

                tnDepth2d depth2d = supporterInstance.GetComponent <tnDepth2d>();
                if (depth2d != null)
                {
                    float scale = 0.5f;
                    depth2d.SetScale(scale);

                    float depthLevel = supporterArea.transform.position.z;
                    depth2d.SetOffset(depthLevel);
                }
            }
        }
    }
    private void SpawnBall()
    {
        tnMatchSettingsModule matchSettingsModule = GameModulesManager.GetModuleMain <tnMatchSettingsModule>();

        if (matchSettingsModule == null)
        {
            return;
        }

        int ballId = matchSettingsModule.ballId;

        m_BallId = ballId;

        tnBallData ballData = tnGameData.GetBallDataMain(m_BallId);

        if (ballData == null)
        {
            return;
        }

        tnBall ballPrefab = tnGameData.LoadAndGetBallPrefabMain();

        if (ballPrefab == null)
        {
            return;
        }

        GameObject ballSpawnPointGo = GameObject.Find(s_BallSpawnPoint);

        if (ballSpawnPointGo == null)
        {
            return;
        }

        TSTransform2D ballSpawnPointTransform = ballSpawnPointGo.GetComponent <TSTransform2D>();

        if (ballSpawnPointTransform == null)
        {
            return;
        }

        Vector3    spawnPosition = ballSpawnPointTransform.position.ToVector();
        Quaternion spawnRotation = Quaternion.Euler(0f, 0f, ballSpawnPointTransform.rotation.AsFloat());

        // Spawn ball.

        tnBall ballInstance = Instantiate <tnBall>(ballPrefab);

        ballInstance.gameObject.name = "Ball";

        ballInstance.transform.position = spawnPosition;
        ballInstance.transform.rotation = spawnRotation;

        // Can rotate?

        ballInstance.SetCanRotate(ballData.canRotate);

        // Configure TSTransform

        TSTransform2D tsTransform = ballInstance.GetComponent <TSTransform2D>();

        if (tsTransform != null)
        {
            tsTransform.position = ballSpawnPointTransform.position;
            tsTransform.rotation = ballSpawnPointTransform.rotation;
        }

        // Set ball texture and material.

        tnBallView ballView = ballInstance.GetComponent <tnBallView>();

        if (ballView != null)
        {
            Texture ballTexture = ballData.texture;
            ballView.SetTexture(ballTexture);

            ballView.SetTrailMaterial(ballData.trailMaterial);
            ballView.SetParticleEffect(ballData.particleEffect);
        }

        // Set depth level

        tnDepth2d depth2d = ballInstance.GetComponent <tnDepth2d>();

        if (depth2d != null)
        {
            depth2d.SetOffset(ballSpawnPointGo.transform.position.z);
        }

        // Register True Sync Obejct.

        TrueSyncManager.RegisterTrueSyncObjectMain(ballInstance.gameObject);

        // Bind to camera.

        if (cameraGo != null)
        {
            tnGameCamera gameCamera = cameraGo.GetComponent <tnGameCamera>();
            if (gameCamera != null)
            {
                gameCamera.SetTarget(ballInstance.transform);
            }
        }

        // Bind to slow motion controller.

        if (m_SlowMotionController != null)
        {
            TSRigidBody2D ballRigidbody = ballInstance.GetComponent <TSRigidBody2D>();
            if (ballRigidbody != null)
            {
                m_SlowMotionController.SetTarget(ballRigidbody);
            }
        }

        // Set Bounds of field for respown if ball go out of the field.

        GameObject topLeft     = GameObject.Find(s_TopLeft_Bound);
        GameObject bottomRight = GameObject.Find(s_BottomRight_Bound);

        if (topLeft != null && bottomRight != null)
        {
            TSTransform2D tsTransformTopLeft     = topLeft.GetComponent <TSTransform2D>();
            TSTransform2D tsTransformBottomRight = bottomRight.GetComponent <TSTransform2D>();

            if (tsTransformTopLeft != null && tsTransformBottomRight != null)
            {
                FP minX = tsTransformTopLeft.position.x;
                FP minY = tsTransformBottomRight.position.y;
                FP maxX = tsTransformBottomRight.position.x;
                FP maxY = tsTransformTopLeft.position.y;

                TSVector2 min = new TSVector2(minX, minY);
                TSVector2 max = new TSVector2(maxX, maxY);

                ballInstance.SetBoundLimits(min, max);
                ballInstance.SetSafeRespawnOutField(true);
            }
        }

        // Save instance.

        m_Ball = ballInstance;
    }