C# Player.Initialize方法代码示例

 private void CreateAndAddPlayer()
 {
     var playerInstance = new Player(DefaultBattlefieldSize);
     playerInstance.Initialize();
     Players.Add(playerInstance);
     Player = playerInstance;
 }

    void Start()
    {
        for (int i = 0; i < (int)GameData.ColorNames.NumColors; i++) {
            GameData.SetColorData( (GameData.ColorNames)i, m_pColors[i]);
        }

        EndGameLabel.gameObject.SetActiveRecursively(false);

        ScaleToWin *= GameData.WinSize;
        m_nCurrentGameMode = GameData.nextGameMode;

        m_pEnemyManager = GetComponentInChildren<EnemyManager>();
        m_pEnemyManager.Initialize(this);

        m_pPlayer = GetComponentInChildren<Player>();
        m_pPlayer.Initialize(this);

        switch (m_nCurrentGameMode)
        {
            case GameData.GameMode.Normal:
                break;
            case GameData.GameMode.Endless:
                ScaleToWin = 100;
                ScaleToLose = -100;
                break;
            case GameData.GameMode.Progression:
                break;
            case GameData.GameMode.Reverse:
                break;
            default:
                break;
        }
    }

        public void CarSizeTest()
        {
            Player player = new Player();
            player.Initialize();
            const int carSize = 5;
            Transport car = new Transport(TransportType.Car, String.Empty, 100, null, null, 10000);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));
            Asset wife = new Partner();
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(wife));
            Asset[] carTravellers = {
                                       new Child(),
                                       new Pet()
                                   };

            // Start from 1 as we already added wife asset
            for (var i = 1; i < player.CarSize; i++) {
                Assert.AreEqual(AssetResponse.AddedSuccessfully,
                                player.Accept(carTravellers[RandomHelper.Next(0, carTravellers.Length)]));
            }

            Assert.AreEqual(player.CarSize, player.Assets[AssetType.Transportable].Count);

            for (var i = 0; i < player.CarSize; i++) {
                Assert.AreEqual(AssetResponse.CarFull,
                                player.Accept(carTravellers[RandomHelper.Next(0, carTravellers.Length)]));
            }
        }

        public void StoryCardLogicTest()
        {
            StoryCardData target = new StoryCardData();
            var stories = StoryCardData.PopulateStoryCards();
            StateFactory.SetInstance(new StateFactory());
            StateFactory.AddFactory(GameStates.Wait, new WaitFactory());

            var gameTime = new GameTime();
            var player = new Player();
            player.Initialize();
            player.Accept(new Transport(TransportType.Car, String.Empty, int.MaxValue, null, null, 0));
            var world = new List<WorldObject> { new StartingNode(Vector2.Zero), new Spinner(Vector2.Zero) };
            var gameInfo = new GameInfo(world, new[] { player }, 100, GameRuleType.Retirement);
            gameInfo.GetNextPlayer();

            foreach (var story in stories) {
                var performingLogic = story.PureLogic;

                Assert.IsNotNull(performingLogic);
                try {
                    var returnedStates = story.PureLogic.PerformLogic(gameTime, gameInfo);
                } catch (Exception e) {
                    Console.WriteLine(e);
                }

            }
        }

 public ActionScene(Game game, Texture2D theTexture, Texture2D backgroundTexture, SpriteFont font,Rectangle screenBounds, params IController[] controllers)
     : this(game,theTexture,backgroundTexture,font)
 {
     TwoPlayers = false;
     _player1 = new Player(Game, ref _actionTexture,  new Vector2(screenBounds.Width / 3, 0), new Rectangle(323, 15, 30, 30),controllers);
     _player1.Initialize();
     Components.Add(_player1);
 }

        public void CanInitializePlayer()
        {
            var player = new Player(10);
            Assert.IsTrue(player.Id == Guid.Empty);

            player.Initialize();
            Assert.IsTrue(player.Id != Guid.Empty);
        }

        public void AddPlayer(Player player)
        {
            Players.Add(player);

            if (AvailablesIndexes.Count != 0)
                player.Index = AvailablesIndexes.Pop();
            else
                player.Index = PlayerIndex.Four;

            player.Initialize();
        }

    public void Initialize()
    {
        //renderer.material.color = color;
        _idx = 0;
        //Player prefab = bricReality?ScreenManager.instance.playerRealityPrefab:ScreenManager.instance.playerFantasyPrefab;
        Player prefab = ((int)realityLevel>=(int)RealityLevel.Player)?ScreenManager.instance.playerRealityPrefab:ScreenManager.instance.playerFantasyPrefab;
        _player = GameObject.Instantiate(prefab) as Player;
        _player.Initialize(this);

        GameObject prefab2 = ((int)realityLevel>=(int)RealityLevel.Princess)?ScreenManager.instance.princessRealityPrefab:ScreenManager.instance.princessFantasyPrefab;
        //GameObject prefab2 = bricReality?ScreenManager.instance.princessRealityPrefab:ScreenManager.instance.princessFantasyPrefab;
        _princess = GameObject.Instantiate(prefab2) as GameObject;
        _princess.transform.localScale = new Vector3(
            _princess.transform.localScale.x/(float)level,
            _princess.transform.localScale.y/(float)level,
            _princess.transform.localScale.z
            );
        _princess.transform.position = new Vector3(
            transform.position.x,
            transform.position.y + Camera.main.orthographicSize - _princess.transform.localScale.y*3,
            _princess.transform.position.z
            );

        _nextBlocPosition = new Vector3(
            transform.position.x,
            transform.position.y - transform.localScale.y/2f,
            0
        );

        //CreateNextBloc();
        float cumulatedWidth = 0;
        while (cumulatedWidth<Camera.main.orthographicSize*2 && Mathf.Approximately(cumulatedWidth,Camera.main.orthographicSize*2)==false) {
            CreateNextBloc();
            cumulatedWidth += _lastBlockBounds.size.y;
        }

        _firstBloc = _blocs[0];

        _destroyBlocPosition = new Vector3(
            transform.position.x,
            transform.position.y - transform.localScale.y/2f,
            0
        );
        _generateBlocPosition = new Vector3(
            transform.position.x,
            transform.position.y + transform.localScale.y/2f,
            0
            );
    }

        public void CarTest()
        {
            Player player = new Player();
            player.Initialize();
            const int carSize = 5;
            const int carValue = 123111;
            Transport car = new Transport(TransportType.Car, String.Empty, 100, null, null, carValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));

            Assert.AreEqual(carValue, player.TotalValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));
            Assert.AreEqual(carValue, player.TotalValue);

            const int secondCarValue = 1000;
            Transport car2 = new Transport(TransportType.Car, String.Empty, 100, null, null, secondCarValue);

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car2));

            Assert.AreEqual(secondCarValue, player.TotalValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car2));
            Assert.AreEqual(secondCarValue, player.TotalValue);
        }

        private static Game BuildGame()
        {
            var game = new Game(10);

            var firstPlayer = new Player(10);
            firstPlayer.Initialize();

            var secondPlayer = new Player(10);
            secondPlayer.Initialize();

            game.FirstPlayer = firstPlayer;
            game.SecondPlayer = secondPlayer;

            game.Start();

            return game;
        }

        public void CashTest()
        {
            const int cash = 12312;
            Vector2 location = Vector2.Zero;

            Player player = new Player();
            player.Initialize();
            player.Cash += cash;
            Transport worthlessCar = new Transport(TransportType.Car, String.Empty, 100, null, null, 0);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(worthlessCar));

            Asset asset1 = new House(15212, "testing house", String.Empty);
            Asset asset2 = new Partner();

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset1));
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset2));

            int expected = cash;
            int actual;
            player.Cash = expected;
            actual = player.Cash;
            Assert.AreEqual(expected, actual);
        }

        private void BuildPlayerList()
        {
            LocalSteamId = MyAPIGateway.Multiplayer.MyId;

            Log.Trace("Start building local player list for local steam id " +
                LocalSteamId, "BuildPlayerList");

            var localIngamePlayers = new List<IMyPlayer>();
            MyAPIGateway.Multiplayer.Players.GetPlayers(localIngamePlayers, (x) =>
                x.SteamUserId == LocalSteamId
            );

            if (localIngamePlayers.Count == 0) {
                Log.Error("Failed to find player for my steamId" + LocalSteamId, "Initialize");
            }

            Log.Trace("Building " + localIngamePlayers.Count + " players.", "BuildPlayerList");

            foreach (IMyPlayer ingamePlayer in localIngamePlayers) {
                Player player = new Player(ingamePlayer);
                LocalPlayers.Add(player);
                player.Initialize();
            }
        }

        public void LoadContent(Stream fileStream)
        {
            CreateTiles(fileStream);

            player = new Player();

            player.Initialize(content.Load<Texture2D>("Graphics\\dough-01"), content.Load<Texture2D>("Graphics\\dough-02"), content.Load<Texture2D>("Graphics\\dough-03"), startPos, screenRect, this);
        }

        public void PassportStampTest()
        {
            Player player = new Player();
            player.Initialize();

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(new PassportStamp(IslandType.Beach)));
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(new PassportStamp(IslandType.Beach)));
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(new PassportStamp(IslandType.City)));
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(new PassportStamp(IslandType.Jungle)));
            Assert.AreEqual(AssetResponse.CollectedAllPassportStamps, player.Accept(new PassportStamp(IslandType.Snow)));
            Assert.AreEqual(AssetResponse.CollectedAllPassportStamps, player.Accept(new PassportStamp(IslandType.City)));
        }

    /// <summary>
    /// Allows the game to perform any initialization it needs to before starting to run.
    /// This is where it can query for any required services and load any non-graphic
    /// related content.  Calling base.Initialize will enumerate through any components
    /// and initialize them as well.
    /// </summary>
    protected override void Initialize()
    {
        // TODO: Add your initialization logic here

            base.Initialize();
            player = new Player(this);
            bullet = new Bullet(this);
            weapon = new Weapons(this);
            particle = new Particle(this);
            Enemy_List = new List<Enemy>();
            Particle_list = new List<Particle>();
            enemy = new Enemy(this);
            player.Initialize();
            bullet.Initialize();
            enemy.Initialize();
    }