public override bool Shoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
        {
            OrchidModPlayer modPlayer   = player.GetModPlayer <OrchidModPlayer>();
            Item            currentCard = modPlayer.gamblerCardDummy;

            if (OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer) > 0)
            {
                if (player.altFunctionUse == 2 || modPlayer.gamblerCardDummy.type == 0)
                {
                    Main.PlaySound(SoundID.Item64, player.position);
                    OrchidModGamblerHelper.drawDummyCard(player, modPlayer);
                    currentCard = modPlayer.gamblerCardDummy;
                    this.checkStats(currentCard, player, modPlayer);
                    Color floatingTextColor = new Color(255, 200, 0);
                    CombatText.NewText(player.Hitbox, floatingTextColor, modPlayer.gamblerCardDummy.Name);
                    return(false);
                }
            }
            else
            {
                return(false);
            }

            currentCard = modPlayer.gamblerCardDummy;
            this.checkStats(currentCard, player, modPlayer);
            currentCard.GetGlobalItem <OrchidModGlobalItem>().gamblerShootDelegate(player, position, speedX, speedY, type, item.damage, item.knockBack, true);
            return(false);
        }
 public override bool CanUseItem(Player player)
 {
     if (player == Main.player[Main.myPlayer])
     {
         OrchidModPlayer modPlayer = player.GetModPlayer <OrchidModPlayer>();
         Item[]          cards     = modPlayer.gamblerCardsItem;
         int             count     = OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer);
         if (OrchidModGamblerHelper.containsGamblerCard(item, player, modPlayer) || player.altFunctionUse == 2 || count < this.cardRequirement || count >= 20)
         {
             return(false);
         }
         else
         {
             if (OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer) <= 0)
             {
                 bool found = false;
                 for (int i = 0; i < Main.maxInventory; i++)
                 {
                     Item item = Main.LocalPlayer.inventory[i];
                     if (item.type != 0)
                     {
                         OrchidModGlobalItem orchidItem = item.GetGlobalItem <OrchidModGlobalItem>();
                         if (orchidItem.gamblerDeck)
                         {
                             found = true;
                             break;
                         }
                     }
                 }
                 if (!found)
                 {
                     int gamblerDeck = ItemType <Gambler.Decks.GamblerAttack>();
                     player.QuickSpawnItem(gamblerDeck, 1);
                 }
             }
             item.useAnimation = 20;
             item.useTime      = 20;
             for (int i = 0; i < 20; i++)
             {
                 if (cards[i].type == 0)
                 {
                     cards[i] = new Item();
                     cards[i].SetDefaults(item.type, true);
                     OrchidModGamblerHelper.clearGamblerCardCurrent(player, modPlayer);
                     OrchidModGamblerHelper.clearGamblerCardsNext(player, modPlayer);
                     modPlayer.gamblerShuffleCooldown = 0;
                     modPlayer.gamblerRedraws         = 0;
                     OrchidModGamblerHelper.drawGamblerCard(player, modPlayer);
                     return(true);
                 }
             }
             //item.TurnToAir();
         }
     }
     return(base.CanUseItem(player));
 }
Exemple #3
0
 public override bool CanUseItem(Player player)
 {
     if (player == Main.LocalPlayer)
     {
         OrchidModPlayer modPlayer   = player.GetModPlayer <OrchidModPlayer>();
         Item            currentCard = modPlayer.gamblerCardCurrent;
         if (OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer) > 0)
         {
             if (player.altFunctionUse == 2)
             {
                 if (modPlayer.gamblerRedraws > 0 && modPlayer.gamblerRedrawCooldownUse <= 0)
                 {
                     modPlayer.gamblerRedraws--;
                     modPlayer.gamblerRedrawCooldownUse = 30;
                     Main.PlaySound(SoundID.Item64, player.position);
                     OrchidModGamblerHelper.drawGamblerCard(player, modPlayer);
                     currentCard = modPlayer.gamblerCardCurrent;
                     this.checkStats(currentCard, player, modPlayer);
                 }
                 return(false);
             }
             else
             {
                 if (modPlayer.gamblerShuffleCooldown <= 0)
                 {
                     OrchidModGamblerHelper.drawGamblerCard(player, modPlayer);
                     Main.PlaySound(SoundID.Item64, player.position);
                     currentCard = modPlayer.gamblerCardCurrent;
                     this.checkStats(currentCard, player, modPlayer);
                 }
             }
         }
         else
         {
             return(false);
         }
     }
     return(base.CanUseItem(player));
 }
Exemple #4
0
        public static void drawGamblerCard(Player player, OrchidModPlayer modPlayer)
        {
            modPlayer.gamblerJustSwitched = true;

            if (modPlayer.gamblerCardNext.Count() != 3)
            {
                OrchidModGamblerHelper.clearGamblerCardsNext(player, modPlayer);
            }

            for (int i = 0; i < 3; i++)
            {
                if (modPlayer.gamblerCardNext[i].type == 0)
                {
                    int rand = Main.rand.Next(OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer));
                    modPlayer.gamblerCardNext[i] = new Item();
                    modPlayer.gamblerCardNext[i].SetDefaults(modPlayer.gamblerCardsItem[rand].type, true);
                }
            }

            modPlayer.gamblerCardCurrent = new Item();
            modPlayer.gamblerCardCurrent.SetDefaults(modPlayer.gamblerCardNext[0].type, true);

            for (int i = 0; i < 2; i++)
            {
                modPlayer.gamblerCardNext[i] = new Item();
                modPlayer.gamblerCardNext[i].SetDefaults(modPlayer.gamblerCardNext[i + 1].type, true);
            }

            modPlayer.gamblerCardNext[2] = new Item();
            modPlayer.gamblerCardNext[2].SetDefaults(0, true);

            for (int i = 0; i < 3; i++)
            {
                if (modPlayer.gamblerCardNext[i].type == 0)
                {
                    int rand = Main.rand.Next(OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer));
                    modPlayer.gamblerCardNext[i] = new Item();
                    modPlayer.gamblerCardNext[i].SetDefaults(modPlayer.gamblerCardsItem[rand].type, true);
                }
            }

            if (OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer) > 3)
            {
                for (int i = 2; i > -1; i--)
                {
                    for (int j = 2; j > -1; j--)
                    {
                        int currentType = modPlayer.gamblerCardNext[i].type;
                        if ((currentType == modPlayer.gamblerCardNext[j].type || currentType == modPlayer.gamblerCardCurrent.type) && i != j)
                        {
                            int k = 0;
                            while (k < 5 && (currentType == modPlayer.gamblerCardNext[j].type || currentType == modPlayer.gamblerCardCurrent.type))
                            {
                                k++;
                                int rand = Main.rand.Next(OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer));
                                modPlayer.gamblerCardNext[i] = new Item();
                                modPlayer.gamblerCardNext[i].SetDefaults(modPlayer.gamblerCardsItem[rand].type, true);
                                currentType = modPlayer.gamblerCardNext[i].type;
                            }
                        }
                    }
                }
            }

            modPlayer.gamblerShuffleCooldown = modPlayer.gamblerShuffleCooldownMax;

            if (modPlayer.gamblerDungeon)
            {
                int rand = Main.rand.Next(3);
                for (int i = 0; i < rand; i++)
                {
                    OrchidModGamblerHelper.addGamblerChip(100, player, modPlayer);
                }
            }

            if (modPlayer.gamblerPennant)
            {
                OrchidModGlobalItem orchidItem = modPlayer.gamblerCardCurrent.GetGlobalItem <OrchidModGlobalItem>();
                if (orchidItem.gamblerCardSets.Contains("Boss"))
                {
                    player.AddBuff(BuffType <Gambler.Buffs.ConquerorsPennantBuff>(), 60 * 10);
                }
            }

            if (modPlayer.gamblerVulture)
            {
                int rand     = Main.rand.Next(3) + 1;
                int projType = ProjectileType <Gambler.Projectiles.Equipment.VultureCharmProj>();
                for (int i = 0; i < rand; i++)
                {
                    float   scale   = 1f - (Main.rand.NextFloat() * .3f);
                    Vector2 target  = Main.MouseWorld;
                    Vector2 heading = target - player.Center;
                    heading.Normalize();
                    heading *= new Vector2(0f, 10f).Length();
                    Vector2 vel = heading.RotatedByRandom(MathHelper.ToRadians(20));
                    vel = vel * scale;
                    Projectile.NewProjectile(player.Center.X, player.Center.Y, vel.X, vel.Y, projType, 12, 0f, player.whoAmI);
                    if (i == 0)
                    {
                        OrchidModProjectile.spawnDustCircle(player.Center, 31, 10, 10, true, 1.5f, 1f, 5f, true, true, false, 0, 0, true);
                    }
                }
            }

            modPlayer.gamblerSeedCount = 0;
        }
        public override void ModifyTooltips(List <TooltipLine> tooltips)
        {
            TooltipLine tt = tooltips.FirstOrDefault(x => x.Name == "Damage" && x.mod == "Terraria");

            if (tt != null)
            {
                string[] splitText   = tt.text.Split(' ');
                string   damageValue = splitText.First();
                string   damageWord  = splitText.Last();
                tt.text = damageValue + " gambling " + damageWord;
            }

            Player          player    = Main.player[Main.myPlayer];
            OrchidModPlayer modPlayer = player.GetModPlayer <OrchidModPlayer>();

            Item[] cards = modPlayer.gamblerCardsItem;
            int    count = OrchidModGamblerHelper.getNbGamblerCards(player, modPlayer);
            int    diff  = this.cardRequirement - count;

            int index = tooltips.FindIndex(ttip => ttip.mod.Equals("Terraria") && ttip.Name.Equals("Tooltip0"));

            if (index != -1)
            {
                int tagCount = this.gamblerCardSets.Count - 1;
                if (tagCount > -1)
                {
                    List <string> alreadyDone = new List <string>();
                    string        tags        = "";
                    foreach (string tag in this.gamblerCardSets)
                    {
                        if (!alreadyDone.Contains(tag))
                        {
                            tags += alreadyDone.Count > 0 ? ", " : "";
                            tags += tag;
                            tagCount--;
                            alreadyDone.Add(tag);
                        }
                    }
                    tags += alreadyDone.Count > 1 ? " sets" : " set";

                    tooltips.Insert(index, new TooltipLine(mod, "TagsTag", tags)
                    {
                        overrideColor = new Color(175, 255, 175)
                    });
                }
            }

            tooltips.Insert(1, new TooltipLine(mod, "CardsNeeded", "Requires " + this.cardRequirement + " cards (Deck : " + count + ")")
            {
                overrideColor = new Color(255, 200, 100)
            });

            if (OrchidModGamblerHelper.containsGamblerCard(item, player, modPlayer))
            {
                tooltips.Insert(1, new TooltipLine(mod, "UseTag", "Currently in your deck")
                {
                    overrideColor = new Color(255, 100, 100)
                });
            }
            else if (count == 20)
            {
                tooltips.Insert(1, new TooltipLine(mod, "UseTag", "Your deck is full")
                {
                    overrideColor = new Color(255, 100, 100)
                });
            }
            else if (count < this.cardRequirement)
            {
                tooltips.Insert(1, new TooltipLine(mod, "UseTag", "Requires " + diff + " more cards")
                {
                    overrideColor = new Color(255, 100, 100)
                });
            }
            else
            {
                tooltips.Insert(1, new TooltipLine(mod, "UseTag", "Use to add to your deck")
                {
                    overrideColor = new Color(255, 200, 100)
                });
            }

            Mod thoriumMod = OrchidMod.ThoriumMod;

            if (thoriumMod != null)
            {
                tooltips.Insert(1, new TooltipLine(mod, "ClassTag", "-Gambler Class-")
                {
                    overrideColor = new Color(255, 200, 0)
                });
            }

            tt = tooltips.FirstOrDefault(x => x.Name == "Speed" && x.mod == "Terraria");
            if (tt != null)
            {
                tooltips.Remove(tt);
            }

            tt = tooltips.FirstOrDefault(x => x.Name == "Consumable" && x.mod == "Terraria");
            if (tt != null)
            {
                tooltips.Remove(tt);
            }
        }