Пример #1
0
        public override bool MysticShoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            Vector2 muzzleOffset = Vector2.Normalize(new Vector2(speedX, speedY)) * 50f;

            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            if (modPlayer.MysticMode == 1)
            {
                charge++;
                Main.PlaySound(SoundID.Item60, position);
                if (charge > 2)
                {
                    int numberProjectiles = 24;
                    for (int i = 0; i < numberProjectiles; i++)
                    {
                        Vector2 perturbedSpeed = new Vector2(speedX, speedY).RotatedByRandom(MathHelper.ToRadians(7));
                        float   scale          = 1f - (Main.rand.NextFloat() * .4f);
                        perturbedSpeed = perturbedSpeed * scale;
                        Projectile.NewProjectile(position.X, position.Y, perturbedSpeed.X, perturbedSpeed.Y, type, damage, knockBack, player.whoAmI);
                    }

                    charge = 0;
                    Main.PlaySound(SoundID.Item84, position);
                }
                return(false);
            }
            return(true);
        }
Пример #2
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            if (modPlayer.SoulStoneVisuals)
            {
                if (modPlayer.spelunker)
                {
                    player.findTreasure = true;
                }
                Lighting.AddLight((int)(player.position.X + (float)(player.width / 2)) / 16, (int)(player.position.Y + (float)(player.height / 2)) / 16, 0.8f, 0.95f, 1f);
                if (modPlayer.owl)
                {
                    player.nightVision = true;
                }
                if (modPlayer.hunter)
                {
                    player.detectCreature = true;
                }
                if (modPlayer.danger)
                {
                    player.dangerSense = true;
                }
            }
            player.maxMinions++;
            if (modPlayer.calm)
            {
                player.calmed = true;
            }
            player.resistCold    = true;
            player.lifeMagnet    = true;
            player.statLifeMax2 += (player.statLifeMax + player.statLifeMax2) / 5 / 20 * 20 - (player.statLifeMax / 5 / 20 * 20);
        }
Пример #3
0
        public override void AI()
        {
            if (!justSpawned)
            {
                justSpawned = true;
            }
            else
            {
                for (int i = 0; i < 2; i++)
                {
                    Vector2 newPos = projectile.Center;
                    newPos -= projectile.velocity * ((float)i * 0.25f);
                    int dust = Dust.NewDust(newPos, 1, 1, 156, 0f, 0f, 150, default(Color), 1.5f);
                    Main.dust[dust].noGravity = true;
                    Main.dust[dust].position  = newPos;
                    Dust dust3 = Main.dust[dust];
                    dust3.velocity *= 0.2f;
                }
            }

            timer++;
            if (timer > 4 || ((LaugicalityWorld.downedEtheria || LaugicalityPlayer.Get(Main.player[projectile.owner]).Etherable > 0) && LaugicalityWorld.downedTrueEtheria && timer > 2))
            {
                if (Main.myPlayer == projectile.owner)
                {
                    Projectile.NewProjectile(projectile.Center.X, projectile.Center.Y, projectile.velocity.X * Main.rand.NextFloat(0.15f, 1.6f), projectile.velocity.Y * Main.rand.NextFloat(0.15f, 1.5f), ModContent.ProjectileType <BlitzBolt2>(), (int)(projectile.damage / 1.2f), 3, Main.myPlayer);
                }
                timer = 0;
            }
        }
Пример #4
0
        public override bool Shoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            Vector2 muzzleOffset = Vector2.Normalize(new Vector2(speedX, speedY)) * 25f;

            if (Collision.CanHit(position, 0, 0, position + muzzleOffset, 0, 0))
            {
                position += muzzleOffset;
            }
            int numberProjectiles = 3;

            for (int i = 0; i < numberProjectiles; i++)
            {
                Vector2 perturbedSpeed = new Vector2(speedX, speedY).RotatedByRandom(MathHelper.ToRadians(8));

                float scale = 1f - (Main.rand.NextFloat() * .3f);
                perturbedSpeed = perturbedSpeed * scale;
                if (i == 0)
                {
                    Projectile.NewProjectile(position.X, position.Y, perturbedSpeed.X, perturbedSpeed.Y, ModContent.ProjectileType <FrostballProjectile>(), damage, knockBack, player.whoAmI);
                }
                else
                {
                    Projectile.NewProjectile(position.X, position.Y, perturbedSpeed.X, perturbedSpeed.Y, type, damage, knockBack, player.whoAmI);
                }
            }
            counter++;
            if (((LaugicalityWorld.downedEtheria || LaugicalityPlayer.Get(player).Etherable > 0) && LaugicalityWorld.downedTrueEtheria) || counter >= 2)
            {
                counter = 0;
                Projectile.NewProjectile(position.X, position.Y, speedX * 1.5f, speedY * 1.5f, ModContent.ProjectileType <Projectiles.Ranged.AvalancheProjectile>(), damage * 3, knockBack, player.whoAmI);
            }

            return(false);
        }
Пример #5
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.GlobalOverflow += .1f;
            modPlayer.SporeShard      = 2;
        }
Пример #6
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.Incineration    = 2;
            modPlayer.OverflowDamage += .1f;
        }
Пример #7
0
        public override void UpdateArmorSet(Player player)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            player.setBonus = "50% more Potentia discharges to other Potentias when used\nDioritus Mystic Burst\nDecreases Mystic Burst cooldown" +
                              "\nGreatly increased Potentia Regen when time is stopped\n'Out of Time' cooldown is shorter\nAutomatically stops time after taking a hit below 25% life";
            modPlayer.GlobalAbsorbRate *= 1.5f;
            if (Laugicality.zaWarudo > 0)
            {
                if (modPlayer.Lux < modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost && modPlayer.MysticMode != 1)
                {
                    modPlayer.Lux += 1f / 4f;
                }
                if (modPlayer.Vis < modPlayer.VisMax + modPlayer.VisMaxPermaBoost && modPlayer.MysticMode != 2)
                {
                    modPlayer.Vis += 1f / 4f;
                }
                if (modPlayer.Mundus < modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost && modPlayer.MysticMode != 3)
                {
                    modPlayer.Mundus += 1f / 4f;
                }
            }
            modPlayer.MysticSwitchCoolRate += 2;
            modPlayer.zCoolDown            -= 10 * 60;
            modPlayer.AndioChestguard       = true;
        }
Пример #8
0
        public override void UpdateArmorSet(Player player)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            player.setBonus             = "+50 to all Potentias\n25% Reduced Potentia useage\nThe lower your Potentia, the higher your Mystic damage\nPotentia does not decrease when time is stopped\nTime stop lasts longer\nAutomatically stops time after taking a hit below 25% life";
            modPlayer.zaWarudoDuration += 2 * 60;
            modPlayer.AndioChestplate   = true;
            modPlayer.LuxMax           += 50;
            modPlayer.VisMax           += 50;
            modPlayer.MundusMax        += 50;
            if (modPlayer.MysticMode == 1 && modPlayer.Lux < (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost))
            {
                modPlayer.MysticDamage += (1 - (modPlayer.Lux / (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost))) / 5;
            }
            if (modPlayer.MysticMode == 2 && modPlayer.Vis < (modPlayer.VisMax + modPlayer.VisMaxPermaBoost))
            {
                modPlayer.MysticDamage += (1 - (modPlayer.Vis / (modPlayer.VisMax + modPlayer.VisMaxPermaBoost))) / 5;
            }
            if (modPlayer.MysticMode == 3 && modPlayer.Mundus < (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost))
            {
                modPlayer.MysticDamage += (1 - (modPlayer.Mundus / (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost))) / 5;
            }
            modPlayer.GlobalPotentiaUseRate *= .75f;
            if (Laugicality.zaWarudo > 0)
            {
                modPlayer.GlobalPotentiaUseRate = 0;
            }
        }
Пример #9
0
        public override void HoldItem(Player player)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            item.useAnimation = item.useTime = 24 - modPlayer.ObsidiumHeart * 2;
            base.HoldItem(player);
        }
Пример #10
0
        public override void NPCLoot()
        {
            if (plays == 0)
            {
                plays = 1;
            }
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get();

            if (LaugicalityWorld.downedEtheria)
            {
                Item.NewItem((int)npc.position.X, (int)npc.position.Y, npc.width, npc.height, ModContent.ItemType <EtherialTank>(), 1);
            }
            if (!Main.expertMode)
            {
                Item.NewItem((int)npc.position.X, (int)npc.position.Y, npc.width, npc.height, ModContent.ItemType <SteamBar>(), Main.rand.Next(15, 30));

                Item.NewItem((int)npc.position.X, (int)npc.position.Y, npc.width, npc.height, ModContent.ItemType <SoulOfWrought>(), Main.rand.Next(20, 40));
            }

            if (Main.expertMode)
            {
                npc.DropBossBags();
            }
            LaugicalityWorld.downedSteamTrain = true;
        }
Пример #11
0
        public override void UpdateEquip(Player player)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.MysticDamage += 0.15f;
            player.thrownDamage    += .15f;
        }
Пример #12
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.Frost       = true;
            modPlayer.SnowDamage += .25f;
        }
Пример #13
0
        public override void UpdateEquip(Player player)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            player.statManaMax2      += 20;
            modPlayer.MysticDuration += 1f;
        }
Пример #14
0
        public override bool MysticShoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            if (modPlayer.MysticMode == 1 && modPlayer.Lux >= LuxCost)
            {
                item.scale = Math.Min(Math.Max(1.5f, item.scale + .05f), 2.5f);
                return(false);
            }
            else
            {
                item.scale = 1;
            }
            if (modPlayer.MysticMode == 2)
            {
                if (!IllusionCharged)
                {
                    IllusionCharged = true;
                }
                else
                {
                    IllusionCharged    = false;
                    player.immune      = true;
                    player.immuneTime  = 30;
                    player.velocity.X += speedX;
                    player.velocity.Y += speedY;
                }
            }
            else
            {
                IllusionCharged = false;
            }
            return(true);
        }
Пример #15
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            switch (modPlayer.MysticMode)
            {
            case 1:
                if (modPlayer.Lux <= modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost && (modPlayer.CurrentLuxCost > modPlayer.Lux || (modPlayer.Vis >= (modPlayer.VisMax + modPlayer.VisMaxPermaBoost) * modPlayer.VisOverflow * modPlayer.GlobalOverflow) || (modPlayer.Mundus >= (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost) * modPlayer.MundusOverflow * modPlayer.GlobalOverflow)))
                {
                    modPlayer.MysticSwitch();
                }
                break;

            case 2:
                if (modPlayer.Vis <= modPlayer.VisMax + modPlayer.VisMaxPermaBoost && (modPlayer.CurrentVisCost > modPlayer.Vis || (modPlayer.Lux >= (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost) * modPlayer.LuxOverflow * modPlayer.GlobalOverflow) || (modPlayer.Mundus >= (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost) * modPlayer.MundusOverflow * modPlayer.GlobalOverflow)))
                {
                    modPlayer.MysticSwitch();
                }
                break;

            default:
                if (modPlayer.Mundus <= modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost && (modPlayer.CurrentMundusCost > modPlayer.Mundus || (modPlayer.Vis >= (modPlayer.VisMax + modPlayer.VisMaxPermaBoost) * modPlayer.VisOverflow * modPlayer.GlobalOverflow) || (modPlayer.Lux >= (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost) * modPlayer.LuxOverflow * modPlayer.GlobalOverflow)))
                {
                    modPlayer.MysticSwitch();
                }
                break;
            }
        }
Пример #16
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.GlobalOverflow   += .1f;
            modPlayer.GlobalAbsorbRate += .15f;
        }
Пример #17
0
        public override void AI()
        {
            CheckActive();
            GetTarget();
            if (projectile.ai[0] != 0)
            {
                NPC npc = Main.npc[(int)projectile.ai[0]];
                if (npc.life < 1)
                {
                    projectile.ai[0] = 0;
                }
                else
                {
                    HomeIn(npc);
                }
            }
            else
            {
                Wander();
            }

            if (!Main.player[projectile.owner].active)
            {
                projectile.Kill();
            }

            LaugicalityPlayer laugicalityPlayer = LaugicalityPlayer.Get(Main.player[projectile.owner]);

            if (!laugicalityPlayer.Focus.IsCapacity() || !laugicalityPlayer.SkeletronPrimeEffect)
            {
                projectile.Kill();
            }
        }
Пример #18
0
        public override bool MysticShoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            if ((LaugicalityWorld.downedEtheria || LaugicalityPlayer.Get(player).Etherable > 0) && LaugicalityWorld.downedTrueEtheria)
            {
                modPlayer.MysticDamage     += .25f;
                modPlayer.GlobalAbsorbRate *= 1.5f;
                modPlayer.GlobalOverflow   += .5f;
            }
            if (modPlayer.MysticMode == 2)
            {
                int numberProjectiles = Main.rand.Next(1, 3);
                for (int i = 0; i < numberProjectiles; i++)
                {
                    Vector2 perturbedSpeed = new Vector2(speedX, speedY).RotatedByRandom(MathHelper.ToRadians(10));
                    float   scale          = 1f - (Main.rand.NextFloat() * .3f);
                    perturbedSpeed = perturbedSpeed * scale;
                    if (Main.player[Main.myPlayer] == player)
                    {
                        Projectile.NewProjectile(position.X, position.Y, perturbedSpeed.X, perturbedSpeed.Y, ModContent.ProjectileType <PlutoIllusion>(), damage, knockBack, player.whoAmI);
                    }
                }
            }
            return(true);
        }
Пример #19
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            player.endurance += 0.10f;
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            if (modPlayer.SoulStoneVisuals && modPlayer.inf)
            {
                player.AddBuff(116, 2);
            }
            player.allDamage      += 0.10f;
            player.meleeCrit      += 10;
            player.rangedCrit     += 10;
            player.magicCrit      += 10;
            player.thrownCrit     += 10;
            player.manaRegenBonus += 25;
            player.magicDamage    += 0.20f;
            player.kbBuff          = true;
            if (modPlayer.battle)
            {
                player.enemySpawns = true;
            }
            if (player.thorns < 1f)
            {
                player.thorns = 0.333333343f;
            }
            player.ammoCost80    = true;
            player.rangedDamage += 0.10f;
        }
Пример #20
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            player.lavaImmune     = true;
            player.fireWalk       = true;
            player.buffImmune[24] = true;
            if (modPlayer.ww)
            {
                player.waterWalk = true;
            }
            player.gills         = true;
            player.ignoreWater   = true;
            player.accFlipper    = true;
            player.cratePotion   = true;
            player.sonarPotion   = true;
            player.fishingSkill += 15;
            player.tileSpeed    += 0.25f;
            player.wallSpeed    += 0.25f;
            player.blockRange++;
            player.pickSpeed -= 0.25f;
            if (modPlayer.SoulStoneMovement)
            {
                if (modPlayer.feather)
                {
                    player.slowFall = true;
                }
            }
            player.moveSpeed += 0.25f;
        }
Пример #21
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.IllusionDamage += .1f;
            modPlayer.VisMax         += 50;
        }
Пример #22
0
 public override void Update(Player player, ref int buffIndex)
 {
     if (LaugicalityPlayer.Get(player).Connected <= 1)
     {
         LaugicalityPlayer.Get(player).Connected = 1;
     }
 }
Пример #23
0
        private void GetRocketBoots(Player player)
        {
            float accelMax = .7f;

            if (player.controlJump && rocketBootTime < rocketBootTimeMax && !LaugicalityPlayer.Get(player).MobilityCurse4)
            {
                if (rocketAccel < accelMax)
                {
                    rocketAccel += .075f;
                }
                if (player.velocity.Y > -maxVel)
                {
                    player.velocity.Y -= rocketAccel;
                }
                if (player.velocity.Y > 0)
                {
                    player.velocity.Y *= .75f;
                }
                RocketDust(player);
                rocketBootTime++;
                player.fallStart = (int)player.position.Y / 16;
                if (player.rocketDelay2 <= 0)
                {
                    Main.PlaySound(SoundID.Item24, player.position);
                    player.rocketDelay2 = 15;
                }
            }
            else
            {
                rocketAccel = .75f;
            }
        }
Пример #24
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.MysticDamage += .08f;
            switch (modPlayer.MysticMode)
            {
            case 1:
                if (modPlayer.Lux < (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost) / 2)
                {
                    modPlayer.MysticDamage += .08f;
                }
                break;

            case 2:
                if (modPlayer.Vis < (modPlayer.VisMax + modPlayer.VisMaxPermaBoost) / 2)
                {
                    modPlayer.MysticDamage += .08f;
                }
                break;

            default:
                if (modPlayer.Mundus < (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost) / 2)
                {
                    modPlayer.MysticDamage += .08f;
                }
                break;
            }
        }
Пример #25
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.MysticDuration += .33f;
            modPlayer.OverflowDamage += .1f;
        }
Пример #26
0
        public override void ModifyWeaponDamage(Player player, ref float add, ref float mult, ref float flat)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            add += modPlayer.ObsidiumHeart * .1f;
            base.ModifyWeaponDamage(player, ref add, ref mult, ref flat);
        }
Пример #27
0
        public override bool Shoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            Vector2 muzzleOffset = Vector2.Normalize(new Vector2(speedX, speedY)) * 40f;

            if (Collision.CanHit(position, 0, 0, position + muzzleOffset, 0, 0))
            {
                position += muzzleOffset;
            }
            int numberProjectiles = 1;

            if (Main.rand.Next(8) == 0)
            {
                numberProjectiles++;
            }
            if (((LaugicalityWorld.downedEtheria || LaugicalityPlayer.Get(player).Etherable > 0) && LaugicalityWorld.downedTrueEtheria))
            {
                numberProjectiles++;
            }
            for (int i = 0; i < numberProjectiles; i++)
            {
                Vector2 perturbedSpeed = new Vector2(speedX, speedY).RotatedByRandom(MathHelper.ToRadians(8));

                float scale = 1f - (Main.rand.NextFloat() * .3f);
                perturbedSpeed = perturbedSpeed * scale;
                Projectile.NewProjectile(position.X, position.Y, perturbedSpeed.X, perturbedSpeed.Y, type, damage, knockBack, player.whoAmI);
            }

            return(false);
        }
Пример #28
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.MysticEruption     = true;
            modPlayer.MysticBurstDamage += .05f;
        }
Пример #29
0
        public override void OnHitNPC(Player player, NPC target, int damage, float knockback, bool crit)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            LuxCost = 8;
            if (modPlayer.MysticMode == 1 && modPlayer.Lux >= LuxCost * modPlayer.LuxUseRate * modPlayer.GlobalPotentiaUseRate)
            {
                Projectile.NewProjectile(target.Center.X, target.Center.Y, 0f, 0f, ModContent.ProjectileType <MarsDestruction>(), damage, knockback, Main.myPlayer);

                modPlayer.Lux -= LuxCost * modPlayer.LuxUseRate * modPlayer.GlobalPotentiaUseRate;
                if (modPlayer.Lux < 0)
                {
                    modPlayer.Lux = 0;
                }
                if (modPlayer.Lux > (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost) * modPlayer.LuxOverflow * modPlayer.GlobalOverflow)
                {
                    modPlayer.Lux = (modPlayer.LuxMax + modPlayer.LuxMaxPermaBoost) * modPlayer.LuxOverflow * modPlayer.GlobalOverflow;
                }
                modPlayer.Vis += LuxCost * modPlayer.GlobalAbsorbRate * modPlayer.VisAbsorbRate * modPlayer.LuxDischargeRate * modPlayer.LuxUseRate * modPlayer.GlobalPotentiaUseRate;
                if (modPlayer.Vis > (modPlayer.VisMax + modPlayer.VisMaxPermaBoost) * modPlayer.VisOverflow * modPlayer.GlobalOverflow)
                {
                    modPlayer.Vis = (modPlayer.VisMax + modPlayer.VisMaxPermaBoost) * modPlayer.VisOverflow * modPlayer.GlobalOverflow;
                }
                modPlayer.Mundus += LuxCost * modPlayer.GlobalAbsorbRate * modPlayer.MundusAbsorbRate * modPlayer.LuxDischargeRate * modPlayer.LuxUseRate * modPlayer.GlobalPotentiaUseRate;
                if (modPlayer.Mundus > (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost) * modPlayer.MundusOverflow * modPlayer.GlobalOverflow)
                {
                    modPlayer.Mundus = (modPlayer.MundusMax + modPlayer.MundusMaxPermaBoost) * modPlayer.MundusOverflow * modPlayer.GlobalOverflow;
                }
            }
            LuxCost = 0;
        }
Пример #30
0
        public override void UpdateAccessory(Player player, bool hideVisual)
        {
            LaugicalityPlayer modPlayer = LaugicalityPlayer.Get(player);

            modPlayer.MysticMarblite = true;
            modPlayer.MysticDamage  += .1f;
        }