public Player(FightEngine engine, PlayerProfile profile, Team team)
			: base(engine)
		{
			if (profile == null) throw new ArgumentNullException("profile");
			if (team == null) throw new ArgumentNullException("team");

			m_profile = profile;
			m_spritemanager = Engine.GetSubSystem<Drawing.SpriteSystem>().CreateManager(Profile.SpritePath);
			m_animationmanager = Engine.GetSubSystem<Animations.AnimationSystem>().CreateManager(Profile.AnimationPath);
			m_soundmanager = Engine.GetSubSystem<Audio.SoundSystem>().CreateManager(Profile.SoundPath);
			m_statemanager = Engine.GetSubSystem<StateMachine.StateSystem>().CreateManager(this, Profile.StateFiles);
			m_commandmanager = Engine.GetSubSystem<Commands.CommandSystem>().CreateManager(Profile.CommandPath);
			m_constants = new PlayerConstants(this, Engine.GetSubSystem<IO.FileSystem>().OpenTextFile(Profile.ConstantsPath));
			m_dimensions = new CharacterDimensions(Constants);
			m_palettes = BuildPalettes();
			m_palettenumber = 0;
			m_power = 0;
			m_palfx = new PaletteFx();
			m_team = team;
			m_helpers = new Dictionary<Int32, List<Helper>>();

			if (Engine.GetSubSystem<InitializationSettings>().PreloadCharacterSprites == true)
			{
				SpriteManager.LoadAllSprites();
			}

			SpriteManager.UseOverride = true;

			SetLocalAnimation(0, 0);

			CurrentScale = Constants.Scale;
			PushFlag = true;
		}

		public void ShowScorePanel(PlayerProfile.PlayerProfile profile, FractionDifficulty? newDifficulty, bool playerHasWon)
		{
			btnPause.IsEnabled = false;
			btnSpeed.IsEnabled = false;

			GDOwner.GameSpeedMode = GameSpeedModes.NORMAL;

			AddElement(new HUDScorePanel(profile, newDifficulty, playerHasWon));
		} 

    public static void Clear()
    {
        if (current == null)
        {
            current = new PlayerProfile();

            PlayerPrefs.SetString("PlayerProfile", "");
            PlayerPrefs.Save();
        }
    }

 public InformationController(InformationServiceClient service, 
         PlayerProfile profile, 
         PlayerStats stats, 
         List<GameInformation> gameList)
 {
     _service = service;
     this.stats = stats;
     this.profile = profile;
     this.gameList = gameList;
 }

    public static void Save()
    {
        if (current == null)
        {
            current = new PlayerProfile();
        }

        string xml = XmlManager.SerializeObject(typeof(PlayerProfile), current);
        PlayerPrefs.SetString("PlayerProfile", xml);
        PlayerPrefs.Save();
    }

 public override void PlayerSpawning(ClientInfo _cInfo, int _chunkViewDim, PlayerProfile _playerProfile)
 {
     if (Motd.IsEnabled)
     {
         Motd.Send(_cInfo);
     }
     if (ClanManager.IsEnabled)
     {
         ClanManager.CheckforClantag(_cInfo);
     }
 }

		public HUDScorePanel(PlayerProfile.PlayerProfile playerprofile, FractionDifficulty? newDifficulty, bool playerHasWon)
		{
			gainLevel = newDifficulty;
			successScreen = playerHasWon;
			profile = playerprofile;

			RelativePosition = FPoint.Zero;
			Size = new FSize(WIDTH, HEIGHT);
			Alignment = HUDAlignment.CENTER;
			Background = FlatColors.BackgroundHUD;
		}

    // Use this for initialization
    public void Launch()
    {
        PROFILE = Resources.Load("Tuning/PlayerProfile") as PlayerProfile;
        SETUP = Resources.Load("Tuning/GameSetup") as GameSetup;
        INPUT = Resources.Load("Tuning/InputManager") as InputManager;
        DontDestroyOnLoad(this);

        GameEventManager.GameStart += GameStart;
        GameEventManager.GameOver += GameOver;
        GameEventManager.Respawn += Respawn;
        GameEventManager.EndGame += EndGame;
    }

	// Use this for initialization
	void Start () {
		profile = GetComponent<PlayerProfile>();
		Levels= GetComponentsInChildren<LevelItemController>();
		int total = 0;
		foreach(LevelItemController level in Levels)
		{
			level.LevelSelector = this;
			total+=profile.GetProfitForLevel(level.SceneName);
		}

		TotalProfit.Value = total;

	}

        static Program()
        {
            var profile = new PlayerProfile();
            var stats = new PlayerStats();
            var gameList = new List<GameInformation>();
            var gameService = new GameServiceClient();
            var infoService = new InformationServiceClient();
            var state = new BasicObservable<MatchState>(new MatchState());
            infoController = new InformationController(infoService, profile, stats, gameList);
            gameController = new GameController(gameService, state);

            infoController.GetGameList();
        }

    public static void Load()
    {
        if (current == null)
        {
            current = new PlayerProfile();
        }

        string xml = PlayerPrefs.GetString("PlayerProfile");
        if (string.IsNullOrEmpty(xml.Trim()) == false)
        {
            //Debug.Log(xml);
            current = (PlayerProfile)XmlManager.DeserializeObject(typeof(PlayerProfile), xml);
        }
    }

    public PlayerInformation()
    {
		NakedArmorInventory = new Inventory();
        MainInventory = new Inventory();
		ArmoryInventory = new Inventory();
		jukeBox = new Jukebox();
		playerShopInventory = new Inventory();
        Equip = new Equipment();
		questLog = new QuestLog();
		profile = new PlayerProfile();
		playerData = new ParseObject("PlayerData");
		parseObjectID = " ";
		PlayerName = " ";
	}

		public EngineInitialization(CombatMode mode, PlayerProfile p1, Int32 p1palette, PlayerProfile p2, Int32 p2palette, StageProfile stage, Int32 seed)
		{
			if (mode == CombatMode.None) throw new ArgumentOutOfRangeException("mode");
			if (p1 == null) throw new ArgumentNullException("p1");
			if (p1palette < 0 || p1palette > 11) throw new ArgumentOutOfRangeException("p1palette");
			if (p2 == null) throw new ArgumentNullException("p2");
			if (p2palette < 0 || p2palette > 11) throw new ArgumentOutOfRangeException("p2palette");
			if (stage == null) throw new ArgumentNullException("stage");

			m_mode = mode;
			m_p1 = new PlayerCreation(p1, p1.GetValidPaletteIndex(p1palette));
			m_p2 = new PlayerCreation(p2, p2.GetValidPaletteIndex(p2palette));
			m_stage = stage;
			m_seed = seed;
		}

        public static void RequestToSpawnPlayer(ClientInfo _cInfo, int _chunkViewDim, PlayerProfile _playerProfile)
        {
            try {
                Log.Out ("Player connected" +
                    ", entityid=" + _cInfo.entityId +
                    ", name=" + _cInfo.playerName +
                    ", steamid=" + _cInfo.playerId +
                    ", ip=" + _cInfo.ip
                );

                PersistentContainer.Instance.Players [_cInfo.playerId, true].SetOnline (_cInfo);
                PersistentData.PersistentContainer.Instance.Save ();
            } catch (Exception e) {
                Log.Out ("Error in AllocsLogFunctions.RequestToSpawnPlayer: " + e);
            }
        }

    public void Init()
    {
        this.TargetableObjects = new List<GameTarget>();

        this._playerOneProfile = new PlayerProfile();
        this._playerTwoProfile = new PlayerProfile();
        this._playerOneGeneral.Setup(new CardGameGeneral(13805062));
        this._playerTwoGeneral.Setup(new CardGameGeneral(1813937494));

        Debug.Log("Adding the two generals to the target list");
        this.TargetableObjects.Add(new GameTarget(Enumerations.Player.PlayerOne, this._playerOneGeneral));
        this.TargetableObjects.Add(new GameTarget(Enumerations.Player.PlayerTwo, this._playerTwoGeneral));

        DisplayCards();

        //Hide the Card Profile
        HideCardProfile();
    }

            public PlayerProfile(PlayerProfile player) {
                /* shallow copy */
                updateInfo(player.info);
                pbinfo = player.pbinfo;
                name = player.name;
                plugin = player.plugin;
                stats = player.stats;
                state = player.state;
                qmsg = player.qmsg;
                tag = player.tag;
                time = player.time;
                random_value = player.random_value;

                last_kill = player.last_kill;
                last_death = player.last_death;
                last_spawn = player.last_spawn;
                last_chat = player.last_chat;
                last_score = player.last_score;

                savedTeamId = player.savedTeamId;
                savedSquadId = player.savedSquadId;

                targetTeamId = player.targetTeamId;
                targetSquadId = player.targetSquadId;

                delayedTeamId = player.delayedTeamId;
                delayedSquadId = player.delayedSquadId;
            }

        private bool isPlayerIdle(PlayerProfile player) {
            int last_kill_time = getIntegerVarValue("last_kill_time");
            int last_death_time = getIntegerVarValue("last_death_time");
            int last_chat_time = getIntegerVarValue("last_chat_time");
            int last_spawn_time = getIntegerVarValue("last_spawn_time");
            int last_score_time = getIntegerVarValue("last_score_time");


            if (player.getLastKill() > last_kill_time &&
                player.getLastDeath() > last_death_time &&
                player.getLastChat() > last_chat_time &&
                player.getLastSpawn() > last_spawn_time &&
                player.getLastScore() > last_score_time)
                return true;

            return false;

        }

        private void KickPlayerWithMessage(PlayerProfile player, string message) {
            if (player == null)
                return;

            player.state = PlayerState.kicked;
            this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", player.name, message);
            if (players.ContainsKey(player.name))
                players.Remove(player.name);
        }

        public void stats_fetching_loop() {
            DebugWrite("Starting stats fetching thread", 1);
            getPlayerList();
            while (true) {
                if (new_player_queue.Count == 0) {
                    // if there are no more players, put yourself to sleep
                    DebugWrite("No new players, stats fetching thread going to sleep", 1);
                    wake_handle.Reset();
                    wake_handle.WaitOne();
                    DebugWrite("Stats fetching thread is now awake!", 1);
                }


                InsaneBalancer plugin = this;

                while (new_player_queue.Count > 0) {
                    if (!plugin_enabled)
                        break;

                    List<String> keys = new List<string>(new_player_queue.Keys);

                    String name = keys[keys.Count - 1];

                    CPunkbusterInfo info = null;
                    new_player_queue.TryGetValue(name, out info);

                    if (info == null)
                        continue;

                    // make sure I am the only one modifying these dictionarie at this time
                    lock (mutex) {
                        if (new_player_queue.ContainsKey(name))
                            new_player_queue.Remove(name);

                        if (!new_players_batch.ContainsKey(name))
                            new_players_batch.Add(name, null);
                    }

                    String msg = new_player_queue.Count + " more player" + ((new_player_queue.Count > 1) ? "s" : "") + " in queue";
                    if (new_player_queue.Count == 0)
                        msg = "no more players in queue";

                    plugin.DebugWrite("Getting battlelog stats for ^b" + name + "^n, " + msg, 1);
                    if (new_players_batch.ContainsKey(info.SoldierName))
                        new_players_batch[name] = new PlayerProfile(plugin, info);
                }

                // abort the thread if the plugin was disabled
                if (!plugin_enabled) {
                    plugin.DebugWrite("detected that plugin was disabled, aborting stats fetching thread", 1);
                    lock (mutex) {
                        new_player_queue.Clear();
                        new_players_batch.Clear();
                        scratch_list.Clear();
                    }
                    return;
                }

                DebugWrite("Done fetching stats, " + new_players_batch.Count + " player" + ((new_players_batch.Count > 1) ? "s" : "") + " in new batch, waiting for players list now", 1);
                scratch_handle.Reset();
                getPlayerList();
                scratch_handle.WaitOne();
                scratch_handle.Reset();
                lock (mutex) {
                    // remove the nulls, and the ones that left
                    List<String> players_to_remove = new List<string>();
                    foreach (KeyValuePair<String, PlayerProfile> pair in new_players_batch)
                        if (pair.Value == null || !scratch_list.Contains(pair.Key))
                            if (!players_to_remove.Contains(pair.Key)) {
                                DebugWrite("Looks like ^b" + pair.Key + "^n left, removing him from new batch", 3);
                                players_to_remove.Add(pair.Key);
                            }


                    // now remove them
                    foreach (String pname in players_to_remove)
                        if (new_players_batch.ContainsKey(pname))
                            new_players_batch.Remove(pname);

                    if (new_players_batch.Count > 0)
                        DebugWrite("Queue exhausted, will insert now a batch of " + new_players_batch.Count + " player" + ((new_players_batch.Count > 1) ? "s" : ""), 1);
                    foreach (KeyValuePair<String, PlayerProfile> pair in new_players_batch)
                        if (pair.Value != null && scratch_list.Contains(pair.Key))
                            plugin.players.Add(pair.Key, pair.Value);

                    new_players_batch.Clear();
                }

            }

        }

        private void enforceImmediateMove(PlayerProfile vp) {

            int dtid = vp.getDelayedTeamId();
            int dsid = vp.getDelayedSquadId();

            vp.resetDelayedTeamSquad();

            DebugWrite("Moving player " + vp + " from ^bTeam(" + TN(vp.getSavedTeamId()) + ").Squad(" + SQN(vp.getSavedSquadId()) + ")^n to ^bDTeam(" + TN(dtid) + ").DSquad(" + SQN(dsid) + ")^n", 3);
            movePlayer(vp, dtid, dsid);

        }