Пример #1
0
        public override bool UseItem(Player player)
        {
            CalamityMod.CalPlayer.CalamityPlayer CalamityPlayer = player.GetModPlayer <CalamityMod.CalPlayer.CalamityPlayer>();
            for (int h = 0; h < 1; h++)
            {
                Vector2 vel = new Vector2(0, -1);
                vel *= 0f;
                Projectile.NewProjectile(player.Center.X, player.Center.Y, vel.X, vel.Y, mod.ProjectileType("Drainer"), 0, 0, player.whoAmI);
            }
            player.Hurt(PlayerDeathReason.LegacyEmpty(), 2, 0, false, false, false, -1);
            CalamityPlayer.stress += 2500;
            player.statLife        = (player.statLife - player.statLifeMax2 / 4);
            PlayerDeathReason damageSource = PlayerDeathReason.ByOther(13);

            if (Main.rand.Next(2) == 0)
            {
                damageSource = PlayerDeathReason.ByOther(player.Male ? 14 : 15);
            }
            if (player.statLife <= 0)
            {
                player.KillMe(damageSource, 1.0, 0, false);
            }
            player.lifeRegenCount = 0;
            player.lifeRegenTime  = 0;
            return(true);
        }
Пример #2
0
 public override void OnHitByItem(Player player, Item item, int damage, float knockback, bool crit)
 {
     if (reflectPhase)
     {
         player.Hurt(PlayerDeathReason.LegacyEmpty(), item.damage, 0, true, false, false, -1);
         Main.PlaySound(SoundID.DD2_LightningBugZap, npc.position);
     }
 }
Пример #3
0
        private void FacPlant(CommandArgs args)
        {
            var play = _playerList[args.Player.UUID];

            if (play.CheckCooldown("faceplant", _config.FaceplantCooldown, out var left) && !args.Player.HasPermission("facommands.nocd"))
            {
                args.Player.SendErrorMessage($"This command is on cooldown for {left} seconds.");
                return;
            }
            args.Player.SendInfoMessage("You planted your face on the ground. Serious man...?");
            NetMessage.SendPlayerDeath(args.Player.Index, PlayerDeathReason.LegacyEmpty(), 9999, _random.Next(-1, 1), false);
            var seriouslyRealGender = args.Player.TPlayer.Male ? "his" : "her";

            TSPlayer.All.SendMessage($"{args.Player.Name} planted {seriouslyRealGender} face on the ground. Are you crazy?!", Color.BlanchedAlmond);
            if (!args.Player.Group.HasPermission("facommands.nocd"))
            {
                play.SetCooldown("faceplant", _config.FaceplantCooldown);
            }
        }
Пример #4
0
        /// <summary>
        /// Calculates the amount of damage dealt to a player after factoring in their defense stats.
        /// </summary>
        public static double GetHurtDamage(PvPPlayer damagedPlayer, int damage)
        {
            damagedPlayer.TPlayer.stealth = 1f;
            int    damage1 = damage;
            double dmg     = Main.CalculatePlayerDamage(damage1, damagedPlayer.TPlayer.statDefense);

            if (dmg >= 1.0)
            {
                dmg = (int)((1.0 - damagedPlayer.TPlayer.endurance) * dmg);
                if (dmg < 1.0)
                {
                    dmg = 1.0;
                }
                if (damagedPlayer.TPlayer.ConsumeSolarFlare())
                {
                    dmg = (int)(0.7 * dmg);
                    if (dmg < 1.0)
                    {
                        dmg = 1.0;
                    }
                }
                if (damagedPlayer.TPlayer.beetleDefense && damagedPlayer.TPlayer.beetleOrbs > 0)
                {
                    dmg = (int)((1.0 - 0.15f * damagedPlayer.TPlayer.beetleOrbs) * dmg);
                    damagedPlayer.TPlayer.beetleOrbs = damagedPlayer.TPlayer.beetleOrbs - 1;
                    if (dmg < 1.0)
                    {
                        dmg = 1.0;
                    }
                }
                if (damagedPlayer.TPlayer.defendedByPaladin)
                {
                    if (damagedPlayer.TPlayer.whoAmI != Main.myPlayer)
                    {
                        if (Main.player[Main.myPlayer].hasPaladinShield)
                        {
                            Player player = Main.player[Main.myPlayer];
                            if (player.team == damagedPlayer.TPlayer.team && damagedPlayer.TPlayer.team != 0)
                            {
                                float num1  = player.Distance(damagedPlayer.TPlayer.Center);
                                bool  flag3 = num1 < 800.0;
                                if (flag3)
                                {
                                    for (int index = 0; index < (int)byte.MaxValue; ++index)
                                    {
                                        if (index != Main.myPlayer && Main.player[index].active && (!Main.player[index].dead && !Main.player[index].immune) && (Main.player[index].hasPaladinShield && Main.player[index].team == damagedPlayer.TPlayer.team && Main.player[index].statLife > Main.player[index].statLifeMax2 * 0.25))
                                        {
                                            float num2 = Main.player[index].Distance(damagedPlayer.TPlayer.Center);
                                            if ((double)num1 > num2 || num1 == num2 && index < Main.myPlayer)
                                            {
                                                flag3 = false;
                                                break;
                                            }
                                        }
                                    }
                                }
                                if (flag3)
                                {
                                    int damage2 = (int)(dmg * 0.25);
                                    dmg = (int)(dmg * 0.75);
                                    player.Hurt(PlayerDeathReason.LegacyEmpty(), damage2, 0);
                                }
                            }
                        }
                    }
                    else
                    {
                        bool flag3 = false;
                        for (int index = 0; index < (int)byte.MaxValue; ++index)
                        {
                            if (index != Main.myPlayer && Main.player[index].active && (!Main.player[index].dead && !Main.player[index].immune) && Main.player[index].hasPaladinShield && Main.player[index].team == damagedPlayer.TPlayer.team && Main.player[index].statLife > Main.player[index].statLifeMax2 * 0.25)
                            {
                                flag3 = true;
                                break;
                            }
                        }
                        if (flag3)
                        {
                            dmg = (int)(dmg * 0.75);
                        }
                    }
                }
            }
            return(dmg);
        }
Пример #5
0
        //Classic Tshock's death implementation.
        //Death with no message on chat or if you want to know who died, you can turn on messages.
        //Slightly modified death messages.
        public static void PlayerDeath(object sender, GetDataHandlers.KillMeEventArgs args)
        {
            if (args.Handled)
            {
                return;
            }

            args.Player.Dead         = true;
            args.Player.RespawnTimer = TShock.Config.RespawnSeconds;


            foreach (NPC npc in Main.npc)
            {
                if (npc.active && (npc.boss || npc.type == 13 || npc.type == 14 || npc.type == 15) &&
                    Math.Abs(args.Player.TPlayer.Center.X - npc.Center.X) + Math.Abs(args.Player.TPlayer.Center.Y - npc.Center.Y) < 4000f)
                {
                    args.Player.RespawnTimer = TShock.Config.RespawnBossSeconds;
                    break;
                }
            }

            // Handle kicks/bans on mediumcore/hardcore deaths.
            if (args.Player.TPlayer.difficulty == 1 || args.Player.TPlayer.difficulty == 2)             // Player is not softcore
            {
                bool   mediumcore = args.Player.TPlayer.difficulty == 1;
                bool   shouldBan  = mediumcore ? TShock.Config.BanOnMediumcoreDeath : TShock.Config.BanOnHardcoreDeath;
                bool   shouldKick = mediumcore ? TShock.Config.KickOnMediumcoreDeath : TShock.Config.KickOnHardcoreDeath;
                string banReason  = mediumcore ? TShock.Config.MediumcoreBanReason : TShock.Config.HardcoreBanReason;
                string kickReason = mediumcore ? TShock.Config.MediumcoreKickReason : TShock.Config.HardcoreKickReason;

                if (shouldBan)
                {
                    if (!args.Player.Ban(banReason, false, "TShock"))
                    {
                        TShock.Log.ConsoleDebug("GetDataHandlers / HandlePlayerKillMeV2 kicked with difficulty {0} {1}", args.Player.Name, args.Player.TPlayer.difficulty);
                        args.Player.Kick("You died! Normally, you'd be banned.", true, true);
                    }
                }
                else if (shouldKick)
                {
                    TShock.Log.ConsoleDebug("GetDataHandlers / HandlePlayerKillMeV2 kicked with difficulty {0} {1}", args.Player.Name, args.Player.TPlayer.difficulty);
                    args.Player.Kick(kickReason, true, true, null, false);
                }
            }

            if (args.Player.TPlayer.difficulty == 2 && Main.ServerSideCharacter && args.Player.IsLoggedIn)
            {
                if (TShock.CharacterDB.RemovePlayer(args.Player.Account.ID))
                {
                    TShock.Log.ConsoleDebug("GetDataHandlers / HandlePlayerKillMeV2 ssc delete {0} {1}", args.Player.Name, args.Player.TPlayer.difficulty);
                    args.Player.SendErrorMessage("You have fallen in hardcore mode, and your items have been lost forever.");
                    TShock.CharacterDB.SeedInitialData(args.Player.Account);
                }
            }


            args.Player.TPlayer.KillMe(args.PlayerDeathReason, args.Damage, args.Direction, args.Pvp);

            if (args.Player.HasPermission("server.gmod"))
            {
                Main.player[args.Player.Index].respawnTimer = 1;
                args.Player.RespawnTimer         = 1;
                args.Player.TPlayer.respawnTimer = 1;
            }

            NetMessage.SendPlayerDeath(args.Player.Index, PlayerDeathReason.LegacyEmpty(), args.Damage, args.Direction, args.Pvp);
            NetMessage.SendPlayerDeath(args.Player.Index, PlayerDeathReason.LegacyEmpty(), args.Damage, args.Direction, args.Pvp, args.Player.Index);

            if (args.Pvp)
            {
                TSPlayer[] players = TShock.Players;
                foreach (TSPlayer tSPlayer in players)
                {
                    if (tSPlayer?.TPlayer.hostile ?? false)
                    {
                        tSPlayer.SendMessage($"[c/66ff66:{TShock.Players[args.PlayerDeathReason._sourcePlayerIndex].Name}] [i/p{args.PlayerDeathReason._sourceItemPrefix}:{args.PlayerDeathReason._sourceItemType}] [c/595959:→] [c/ff6666:{args.Player.Name}]", Color.DarkRed);
                    }
                }
                SurvivalCore.SrvPlayers[args.Player.Index].PvpDeaths++;
                SurvivalCore.SrvPlayers[args.PlayerDeathReason._sourcePlayerIndex].PvpKills++;
            }


            else
            {
                TSPlayer[] players2 = TShock.Players;
                foreach (TSPlayer tSPlayer2 in players2)
                {
                    if (tSPlayer2 != null)
                    {
                        if (args.Player.Name == "Xedlefix")
                        {
                            tSPlayer2.SendMessage(args.PlayerDeathReason.GetDeathText(args.Player.Name) + " - Welp",
                                                  Color.Gold);
                        }
                        else if (SurvivalCore.IsDeathMessage[tSPlayer2.Index])
                        {
                            tSPlayer2.SendMessage(args.PlayerDeathReason.GetDeathText(args.Player.Name).ToString(),
                                                  Color.Maroon);
                        }
                    }
                }
                SurvivalCore.SrvPlayers[args.Player.Index].Deaths++;
            }


            args.Handled = true;
        }
Пример #6
0
        public override void UpdateBadLifeRegen()
        {
            if (explorationBoost)
            {
                player.gills        = true;
                player.findTreasure = true;
                Lighting.AddLight((int)((double)player.position.X + (double)(player.width / 2)) / 16, (int)((double)player.position.Y + (double)(player.height / 2)) / 16, 0.8f, 0.95f, 1f);
                player.nightVision = true;
                player.pickSpeed  -= 0.25f;
                player.tileSpeed  += 0.25f;
                player.wallSpeed  += 0.25f;
                ++player.blockRange;
                player.dangerSense   = true;
                player.fishingSkill += 15;
                player.sonarPotion   = true;
                player.cratePotion   = true;
            }

            if (defensiveBoost)
            {
                player.lavaImmune     = true;
                player.fireWalk       = true;
                player.buffImmune[24] = true;

                player.lifeRegen += 4;

                player.statDefense += 8;

                if ((double)player.thorns < 1.0)
                {
                    player.thorns = 0.3333333f;
                }


                player.lifeMagnet = true;

                player.lifeForce     = true;
                player.statLifeMax2 += player.statLifeMax / 5;

                player.endurance += 0.1f;

                player.resistCold = true;

                player.wellFed       = true;
                player.statDefense  += 2;
                player.meleeCrit    += 2;
                player.meleeDamage  += 0.05f;
                player.meleeSpeed   += 0.05f;
                player.magicCrit    += 2;
                player.magicDamage  += 0.05f;
                player.rangedCrit   += 2;
                player.rangedDamage += 0.05f;
                player.thrownCrit   += 2;
                player.thrownDamage += 0.05f;
                player.minionDamage += 0.05f;
                player.minionKB     += 0.5f;
                player.moveSpeed    += 0.2f;
            }

            if (movementBoost)
            {
                player.moveSpeed += 0.25f;

                player.slowFall = true;

                player.waterWalk = true;

                player.ignoreWater = true;
                player.accFlipper  = true;
            }

            if (offensiveBoost)
            {
                player.manaRegenBuff = true;

                player.magicDamage += 0.2f;

                player.archery = true;

                player.detectCreature = true;

                player.kbBuff = true;

                ++player.maxMinions;

                player.ammoPotion = true;

                player.meleeCrit  += 10;
                player.rangedCrit += 10;
                player.magicCrit  += 10;
                player.thrownCrit += 10;

                player.inferno = true;
                Lighting.AddLight((int)((double)player.Center.X / 16.0), (int)((double)player.Center.Y / 16.0), 0.65f, 0.4f, 0.1f);
                int   type = 24;
                float num1 = 200f;
                bool  flag = player.infernoCounter % 60 == 0;
                int   num2 = 10;
                if (player.whoAmI == Main.myPlayer)
                {
                    for (int index2 = 0; index2 < 200; ++index2)
                    {
                        NPC npc = Main.npc[index2];
                        if (npc.active && !npc.friendly && (npc.damage > 0 && !npc.dontTakeDamage) && (!npc.buffImmune[type] && (double)Vector2.Distance(player.Center, npc.Center) <= (double)num1))
                        {
                            if (npc.FindBuffIndex(type) == -1)
                            {
                                npc.AddBuff(type, 120, false);
                            }
                            if (flag)
                            {
                                player.ApplyDamageToNPC(npc, num2, 0.0f, 0, false);
                            }
                        }
                    }
                    if (player.hostile)
                    {
                        for (int playerTargetIndex = 0; playerTargetIndex < (int)byte.MaxValue; ++playerTargetIndex)
                        {
                            Player playerb = Main.player[playerTargetIndex];
                            if (playerb != player && playerb.active && (!playerb.dead && playerb.hostile) && (!playerb.buffImmune[type] && (playerb.team != player.team || playerb.team == 0)) && (double)Vector2.Distance(player.Center, player.Center) <= (double)num1)
                            {
                                if (player.FindBuffIndex(type) == -1)
                                {
                                    player.AddBuff(type, 120, true);
                                }
                                if (flag)
                                {
                                    player.Hurt(PlayerDeathReason.LegacyEmpty(), num2, 0, true, false, false, -1);
                                    if (Main.netMode != 0)
                                    {
                                        PlayerDeathReason reason = PlayerDeathReason.ByPlayer(player.whoAmI);
                                        NetMessage.SendPlayerHurt(playerTargetIndex, reason, num2, 0, false, true, 0, -1, -1);
                                    }
                                }
                            }
                        }
                    }
                }

                player.thrownDamage += 0.1f;
                player.meleeDamage  += 0.1f;
                player.rangedDamage += 0.1f;
                player.magicDamage  += 0.1f;
                player.minionDamage += 0.1f;
            }
        }