Esempio n. 1
0
                public void Pack(int playerID, MsgScore msg)
                {
                    MsgScore.ScoreData data = new MsgScore.ScoreData();

                    data.PlayerID  = playerID;
                    data.Wins      = Wins;
                    data.Losses    = Losses;
                    data.TeamKills = TeamKills;

                    msg.Scores.Add(data);
                }
Esempio n. 2
0
        public void HandleScoreUpdate(NetworkMessage msg)
        {
            MsgScore sc     = msg as MsgScore;
            Player   player = GetPlayerByID(sc.PlayerID);

            if (player == null)
            {
                return;
            }

            player.Wins      = sc.Wins;
            player.Losses    = sc.Losses;
            player.TeamKills = sc.TeamKills;

            if (PlayerInfoUpdated != null)
            {
                PlayerInfoUpdated.Invoke(this, player);
            }
        }
Esempio n. 3
0
        private static void HandleScoreUpdate(NetworkMessage msg)
        {
            MsgScore sc = msg as MsgScore;

            WriteLine("Player Score was updated " + sc.PlayerID.ToString() + String.Format(" = {0}/{1}/{2}", sc.Wins, sc.Losses, sc.TeamKills));
        }
Esempio n. 4
0
        public void KillPlayer(ServerPlayer player, KilledEventArgs args)
        {
            if (args == null || player == null)
            {
                return;
            }

            if (!player.Info.Alive)
            {
                Logger.Log0("Player " + player.Callsign + " killed while dead");
            }

            player.Info.Alive = false;

            PlayerKilled?.Invoke(this, args);

            Logger.Log4("Player " + player.Callsign + " killed by " + args.KillInfo.Reason.ToString());

            bool wasFromAFlag = false;

            switch (args.KillInfo.Reason)
            {
            case BlowedUpReasons.GotKilledMsg:
                break;

            case BlowedUpReasons.GotShot:
                wasFromAFlag = true;
                Shots.RemoveShotForDeath(player, args.KillInfo.KillerID, args.KillInfo.ShotID);

                if (args.Shot != null)    // tell the flag it took a hit
                {
                    Flags.HandlePlayerTakeHit(player, args.Killer, args.Shot);
                }
                break;

            case BlowedUpReasons.GotRunOver:
                wasFromAFlag = true;
                break;

            case BlowedUpReasons.GotCaptured:
                break;

            case BlowedUpReasons.GenocideEffect:
                break;

            case BlowedUpReasons.SelfDestruct:
                break;

            case BlowedUpReasons.WaterDeath:
                break;

            case BlowedUpReasons.DeathTouch:
                break;

            case BlowedUpReasons.LastReason:
            case BlowedUpReasons.Unknown:
                Logger.Log0("Player " + player.Callsign + " killed by a method that should not happen");
                break;
            }

            if (wasFromAFlag)   // tell the flag it killed
            {
                Flags.HandlePlayerDoDamage(player, args.Killer, FlagTypeList.GetFromAbriv(args.KillInfo.FlagAbreviation));
            }

            // process any scores
            PlayerInfo.ScoreInfo vicScores    = new PlayerInfo.ScoreInfo();
            PlayerInfo.ScoreInfo killerScores = new PlayerInfo.ScoreInfo();
            if (ComputeScores(args.Victim, ref vicScores, args.Killer, ref killerScores, args.KillInfo.Reason))
            {
                args.Victim.Info.Score.ApplyScore(vicScores);
                if (args.Killer != null)
                {
                    args.Killer.Info.Score.ApplyScore(killerScores);
                }

                MsgScore scoreMessage = new MsgScore();
                if (!vicScores.Empty)
                {
                    Logger.Log3("Player " + player.Callsign + " score updated by " + vicScores.ToString());

                    ScoreUpdated?.Invoke(this, args.Victim);
                    args.Victim.Info.Score.Pack(args.Victim.PlayerID, scoreMessage);
                }

                if (args.Killer != null && !killerScores.Empty)
                {
                    Logger.Log3("Player " + player.Callsign + " score updated by " + killerScores.ToString());

                    ScoreUpdated?.Invoke(this, args.Killer);
                    args.Killer.Info.Score.Pack(args.Killer.PlayerID, scoreMessage);
                }

                if (scoreMessage.Scores.Count > 0)
                {
                    SendToAll(scoreMessage, false);
                }
            }

            MsgKilled killedMessage = new MsgKilled();

            killedMessage.VictimID        = args.Victim.PlayerID;
            killedMessage.KillerID        = args.Killer != null ? args.Killer.PlayerID : PlayerConstants.ServerPlayerID;
            killedMessage.ShotID          = args.Shot != null ? args.Shot.PlayerShotID : -1;
            killedMessage.Reason          = args.KillInfo.Reason;
            killedMessage.FlagAbreviation = (args.Shot != null && args.Shot.SourceFlag != null) ? args.Shot.SourceFlag.FlagAbbv : string.Empty;
            killedMessage.PhysicsDriverID = args.KillInfo.PhysicsDriverID;

            SendToAll(killedMessage, false);
        }