300 lines
13 KiB
Forth
300 lines
13 KiB
Forth
module Degenz.Store
|
|
|
|
open System
|
|
open System.Threading.Tasks
|
|
open DSharpPlus.Entities
|
|
open DSharpPlus
|
|
open DSharpPlus.EventArgs
|
|
open DSharpPlus.SlashCommands
|
|
open Degenz
|
|
open Degenz.Messaging
|
|
open Degenz.PlayerInteractions
|
|
|
|
let getItemEmbeds owned (items : Inventory) =
|
|
items
|
|
|> List.countBy (fun item -> item.Id)
|
|
|> List.map (fun (id,count) -> items |> List.find (fun i -> i.Id = id) , count )
|
|
|> List.map (fun (item,count) ->
|
|
let embed = DiscordEmbedBuilder()
|
|
item.Attributes
|
|
|> List.iter (function
|
|
| Buyable price -> embed.AddField("Price 💰", (if price = 0<GBT> then "Free" else $"{price} $GBT"), true) |> ignore
|
|
| Attackable power ->
|
|
let title = match item.Type with ItemType.Hack -> "$GBT Reward" | _ -> "Power"
|
|
embed.AddField($"{title} |", string power, true) |> ignore
|
|
| RateLimitable time ->
|
|
let title = match item.Type with ItemType.Hack -> "Cooldown" | ItemType.Shield -> "Active For" | _ -> "Expires"
|
|
let ts = TimeSpan.FromMinutes(int time)
|
|
let timeStr = if ts.Hours = 0 then $"{ts.Minutes} mins" else $"{ts.Hours} hours"
|
|
embed.AddField($"{title} |", timeStr, true) |> ignore
|
|
| Stackable max ->
|
|
if owned then
|
|
embed.AddField($"Total Owned |", $"{count}", true) |> ignore
|
|
else
|
|
embed.AddField($"Max Allowed |", $"{max}", true) |> ignore
|
|
| Modifiable effects ->
|
|
let fx =
|
|
effects
|
|
|> List.map (fun f ->
|
|
match f.Effect with
|
|
| Min i -> $"{f.TargetStat} Min + {i}"
|
|
| Max i -> $"{f.TargetStat} Max + {i}"
|
|
| Add i ->
|
|
let str = if i > 0 then "Boost" else "Penalty"
|
|
$"{f.TargetStat} {str} + {i}"
|
|
| RateMultiplier i -> $"{f.TargetStat} Multiplier - i")
|
|
|> String.concat "\n"
|
|
embed.AddField($"Effect - Amount ", $"{fx}", true) |> ignore
|
|
| _ -> ())
|
|
embed
|
|
.WithColor(WeaponClass.getClassEmbedColor item)
|
|
.WithTitle($"{item.Name}")
|
|
|> ignore
|
|
match Embeds.getItemIcon item.Id with
|
|
| Some url -> embed.WithThumbnail(url)
|
|
| None -> embed)
|
|
|> List.map (fun e -> e.Build())
|
|
|> Seq.ofList
|
|
|
|
let getBuyItemsEmbed (playerInventory : Inventory) (storeInventory : Inventory) =
|
|
let embeds = getItemEmbeds false storeInventory
|
|
let buttons =
|
|
storeInventory
|
|
|> List.map (fun item ->
|
|
if playerInventory |> List.exists (fun i -> i.Id = item.Id)
|
|
then DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Buy-{item.Id}", $"Own {item.Name}", true)
|
|
else DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Buy-{item.Id}", $"Buy {item.Name}")
|
|
:> DiscordComponent)
|
|
|
|
DiscordFollowupMessageBuilder()
|
|
.AddEmbeds(embeds)
|
|
.AddComponents(buttons)
|
|
.AsEphemeral(true)
|
|
|
|
let getSellEmbed (items : Inventory) =
|
|
let embeds , buttons =
|
|
items
|
|
|> List.choose (fun item ->
|
|
match item.Attributes with
|
|
| CanSell price ->
|
|
let builder =
|
|
DiscordEmbedBuilder()
|
|
.AddField("Sell For 💰", $"{price} $GBT", true)
|
|
.WithTitle($"{item.Name}")
|
|
.WithColor(WeaponClass.getClassEmbedColor item)
|
|
.Build()
|
|
let button = DiscordButtonComponent(WeaponClass.getClassButtonColor item, $"Sell-{item.Id}", $"Sell {item.Name}") :> DiscordComponent
|
|
Some ( builder , button )
|
|
| _ -> None)
|
|
|> List.unzip
|
|
|
|
// TODO: We should alert the user that they have no sellable items
|
|
DiscordFollowupMessageBuilder()
|
|
.AddEmbeds(embeds)
|
|
.AddComponents(buttons)
|
|
.AsEphemeral(true)
|
|
|
|
let checkHasSufficientFunds (item : Item) player =
|
|
match item.Attributes with
|
|
| CanBuy price ->
|
|
if player.Bank - price >= 0<GBT>
|
|
then Ok player
|
|
else Error $"You do not have sufficient funds to buy this item! Current balance: {player.Bank} GBT"
|
|
| _ -> Error $"{item.Name} item cannot be bought"
|
|
|
|
let checkDoesntExceedStackCap (item : Item) player =
|
|
let itemCount =
|
|
player.Inventory
|
|
|> List.countBy (fun i -> i.Id)
|
|
|> List.tryFind (fst >> ((=) item.Id))
|
|
|> Option.map snd
|
|
match item.Attributes , itemCount with
|
|
| CanStack max , Some count ->
|
|
if count >= max
|
|
then Error $"You own the maximum allowed amount {item.Name}!"
|
|
else Ok player
|
|
| _ , Some _ -> Error $"You already own this item"
|
|
| _ -> Ok player
|
|
|
|
let checkSoldItemAlready (item : Item) player =
|
|
if player.Inventory |> List.exists (fun i -> item.Id = i.Id)
|
|
then Ok player
|
|
else Error $"{item.Name} not found in your inventory! Looks like you sold it already."
|
|
|
|
let checkHasItemsInArsenal itemType items player =
|
|
if List.isEmpty items |> not
|
|
then Ok player
|
|
else Error $"You currently have no {itemType} in your arsenal to sell!"
|
|
|
|
let buy itemType (ctx : IDiscordContext) =
|
|
executePlayerAction ctx (fun player -> async {
|
|
let playerItems = Inventory.getItemsByType itemType player.Inventory
|
|
try
|
|
let! armoryItems = DbService.getStoreItems (ctx.GetChannel().Id)
|
|
if armoryItems.Length > 0 then
|
|
let itemStore = getBuyItemsEmbed playerItems armoryItems
|
|
do! ctx.FollowUp itemStore |> Async.AwaitTask
|
|
do! Analytics.buyWeaponCommand (ctx.GetDiscordMember()) itemType
|
|
else
|
|
do! Messaging.sendFollowUpMessage ctx "This channel doesn't have anything to sell"
|
|
with ex -> printfn $"{ex.Message}"
|
|
})
|
|
|
|
let sell itemType getItems (ctx : IDiscordContext) =
|
|
executePlayerAction ctx (fun player -> async {
|
|
let items = getItems player.Inventory
|
|
match checkHasItemsInArsenal itemType items player with
|
|
| Ok _ -> let itemStore = getSellEmbed items
|
|
do! ctx.FollowUp(itemStore) |> Async.AwaitTask
|
|
| Error e -> do! sendFollowUpMessage ctx e
|
|
do! Analytics.sellWeaponCommand (ctx.GetDiscordMember()) itemType
|
|
})
|
|
|
|
// TODO: When you buy a shield, prompt the user to activate it
|
|
let handleBuyItem (ctx : IDiscordContext) itemId =
|
|
executePlayerAction ctx (fun player -> async {
|
|
let! storeInventory = DbService.getStoreItems (ctx.GetChannel().Id)
|
|
let item = storeInventory |> Inventory.findItemById itemId
|
|
do! player
|
|
|> checkHasSufficientFunds item
|
|
>>= checkDoesntExceedStackCap item
|
|
|> handleResultWithResponse ctx (fun player -> async {
|
|
let price = match item.Attributes with CanBuy price -> price | _ -> 0<GBT>
|
|
do! DbService.updatePlayerCurrency -price player |> Async.Ignore
|
|
do! DbService.addToPlayerInventory player.DiscordId item |> Async.Ignore
|
|
do! sendFollowUpMessage ctx $"Successfully purchased {item.Name}! You now have {player.Bank - price} 💰$GBT remaining"
|
|
do! Analytics.buyWeaponButton (ctx.GetDiscordMember()) item.Name price
|
|
})
|
|
})
|
|
|
|
let handleSell (ctx : IDiscordContext) itemId =
|
|
executePlayerAction ctx (fun player -> async {
|
|
let item = Armory.weapons |> Inventory.findItemById itemId
|
|
do!
|
|
player
|
|
|> checkSoldItemAlready item
|
|
|> handleResultWithResponse ctx (fun player -> async {
|
|
match item.Attributes with
|
|
| CanSell price ->
|
|
let updatedPlayer = {
|
|
player with
|
|
Bank = player.Bank + price
|
|
Inventory = player.Inventory |> List.filter (fun i -> i.Id <> itemId)
|
|
}
|
|
do!
|
|
[ DbService.updatePlayer updatedPlayer |> Async.Ignore
|
|
DbService.removeShieldEvent updatedPlayer.DiscordId itemId |> Async.Ignore
|
|
sendFollowUpMessage ctx $"Sold {item.Name} for {price}! Current Balance: {updatedPlayer.Bank}"
|
|
Analytics.sellWeaponButton (ctx.GetDiscordMember()) item price ]
|
|
|> Async.Parallel
|
|
|> Async.Ignore
|
|
| _ -> ()
|
|
})
|
|
})
|
|
|
|
let consume (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
|
|
match player.Inventory |> Inventory.getFoods with
|
|
| [] -> do! Messaging.sendFollowUpMessage ctx "You do not have any items to consume"
|
|
| items ->
|
|
let embeds = getItemEmbeds true items
|
|
let builder = DiscordFollowupMessageBuilder().AddEmbeds(embeds).AsEphemeral(true)
|
|
do! ctx.FollowUp builder |> Async.AwaitTask
|
|
})
|
|
|
|
let showInventoryEmbed (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
|
|
let embeds = getItemEmbeds true player.Inventory
|
|
let builder = DiscordFollowupMessageBuilder().AddEmbeds(embeds).AsEphemeral(true)
|
|
do! ctx.FollowUp builder |> Async.AwaitTask
|
|
})
|
|
|
|
let showStats (ctx : IDiscordContext) = PlayerInteractions.executePlayerAction ctx (fun player -> async {
|
|
let embed = DiscordEmbedBuilder()
|
|
PlayerStats.stats
|
|
|> List.iter (fun statConfig ->
|
|
let playerStat = PlayerStats.getPlayerStat statConfig player
|
|
let min =
|
|
match statConfig.BaseRange.Min = playerStat.ModRange.Min with
|
|
| true -> $"{statConfig.BaseRange.Min}"
|
|
| false -> $"{statConfig.BaseRange.Min} (+{playerStat.ModRange.Min}) "
|
|
let max =
|
|
match statConfig.BaseRange.Max = playerStat.ModRange.Max with
|
|
| true -> $"{statConfig.BaseRange.Max}"
|
|
| false -> $"{statConfig.BaseRange.Max} (+{playerStat.ModRange.Max}) "
|
|
let field = $"{min} |---------------| {max}"
|
|
embed.AddField(string statConfig.Id , field) |> ignore)
|
|
let builder =
|
|
DiscordFollowupMessageBuilder()
|
|
.AddEmbed(embed)
|
|
.AsEphemeral(true)
|
|
do! ctx.FollowUp builder |> Async.AwaitTask
|
|
})
|
|
|
|
let handleStoreEvents (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
|
|
let ctx = DiscordEventContext event :> IDiscordContext
|
|
let id = ctx.GetInteractionId()
|
|
let itemId = int <| id.Split("-").[1]
|
|
match id with
|
|
| id when id.StartsWith("Buy") -> handleBuyItem ctx itemId
|
|
| id when id.StartsWith("Sell") -> handleSell ctx itemId
|
|
| _ ->
|
|
task {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Incorrect Action identifier {id}"
|
|
do! ctx.Respond(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask
|
|
}
|
|
|
|
type Store() =
|
|
inherit ApplicationCommandModule ()
|
|
|
|
let enforceChannel (ctx : IDiscordContext) (storeFn : IDiscordContext -> Task) =
|
|
match ctx.GetChannel().Id with
|
|
| id when id = GuildEnvironment.channelArmory -> storeFn ctx
|
|
| _ ->
|
|
task {
|
|
let msg = $"You must go to <#{GuildEnvironment.channelArmory}> channel to buy or sell weapons"
|
|
do! Messaging.sendSimpleResponse ctx msg
|
|
}
|
|
|
|
// let checkChannel (ctx : IDiscordContext) (storeFn : IDiscordContext -> Task) =
|
|
let checkChannel (ctx : IDiscordContext) =
|
|
match ctx.GetChannel().Id with
|
|
| id when id = GuildEnvironment.channelBackAlley -> buy ItemType.Hack ctx
|
|
| id when id = GuildEnvironment.channelArmory -> buy ItemType.Shield ctx
|
|
| id when id = GuildEnvironment.channelMarket -> buy ItemType.Food ctx
|
|
| id when id = GuildEnvironment.channelAccessoryShop -> buy ItemType.Accessory ctx
|
|
| _ ->
|
|
task {
|
|
let msg = $"This channel doesn't have any items to sell. Try <#{GuildEnvironment.channelArmory}>"
|
|
do! Messaging.sendSimpleResponse ctx msg
|
|
}
|
|
|
|
[<SlashCommand("buy-item", "Purchase an item")>]
|
|
member _.BuyItem (ctx : InteractionContext) = checkChannel (DiscordInteractionContext ctx)
|
|
|
|
[<SlashCommand("buy-hack", "Purchase a hack so you can take money from other Degenz")>]
|
|
member _.BuyHack (ctx : InteractionContext) =
|
|
enforceChannel (DiscordInteractionContext(ctx)) (buy ItemType.Hack)
|
|
|
|
[<SlashCommand("buy-shield", "Purchase a hack shield so you can protect your GBT")>]
|
|
member this.BuyShield (ctx : InteractionContext) =
|
|
enforceChannel (DiscordInteractionContext(ctx)) (buy ItemType.Shield)
|
|
|
|
[<SlashCommand("sell-hack", "Sell a hack for GoodBoyTokenz")>]
|
|
member this.SellHack (ctx : InteractionContext) = enforceChannel (DiscordInteractionContext(ctx)) (sell "Hacks" (Inventory.getItemsByType ItemType.Hack))
|
|
|
|
[<SlashCommand("sell-shield", "Sell a shield for GoodBoyTokenz")>]
|
|
member this.SellShield (ctx : InteractionContext) = enforceChannel (DiscordInteractionContext(ctx)) (sell "Shields" (Inventory.getItemsByType ItemType.Shield))
|
|
|
|
[<SlashCommand("consume", "Consume a food item")>]
|
|
member this.Consume (ctx : InteractionContext) = consume (DiscordInteractionContext ctx)
|
|
|
|
[<SlashCommand("inventory", "Check your inventory")>]
|
|
member this.Inventory (ctx : InteractionContext) =
|
|
showInventoryEmbed (DiscordInteractionContext ctx)
|
|
|
|
[<SlashCommand("stats", "Check your stats")>]
|
|
member this.Stats (ctx : InteractionContext) =
|
|
showStats (DiscordInteractionContext ctx)
|
|
|