261 lines
12 KiB
Forth
261 lines
12 KiB
Forth
module Degenz.Thief
|
|
|
|
open System
|
|
open System.Threading.Tasks
|
|
open DSharpPlus
|
|
open DSharpPlus.Entities
|
|
open DSharpPlus.EventArgs
|
|
open DSharpPlus.SlashCommands
|
|
open Degenz.Messaging
|
|
open Degenz.PlayerInteractions
|
|
|
|
let ThiefCooldown = TimeSpan.FromMinutes(1)
|
|
let VictimRecovery = TimeSpan.FromHours(1)
|
|
|
|
type StealResult =
|
|
| Success
|
|
| WentToPrison
|
|
|
|
//let getRandomStealBtnLabels () =
|
|
// let rand = Random(Guid.NewGuid().GetHashCode())
|
|
// let affirmative = [| "LFG" ; "YOLO" ; "IDGAF" |]
|
|
// let negative = [| "NOPE" ; "IM OUT" ; "BAIL" |]
|
|
// ( affirmative.[rand.Next(0, 3)] , negative.[rand.Next(0, 3)] )
|
|
|
|
//let chanceOfSuccessMsg = function
|
|
// | amt when amt < 0.20 -> "Looking bad"
|
|
// | amt when amt < 0.50 -> "I mean, maybe"
|
|
// | amt when amt < 0.80 -> "I think you got this"
|
|
// | _ -> "Totally worth it"
|
|
|
|
//let targetEvaluationMsg = function
|
|
// | amt when amt < 0.20 -> "but man, they look swole"
|
|
// | amt when amt < 0.50 -> "but they look a little confident"
|
|
// | amt when amt < 0.80 -> "and they're looking a little nervous"
|
|
// | _ -> "and they look weak af man"
|
|
|
|
let payout defenderBank chance =
|
|
let rand = Random(Guid.NewGuid().GetHashCode())
|
|
let baseAmount = defenderBank * 0.1 * (1.0 - chance)
|
|
let randomBonus = baseAmount * rand.NextDouble() * chance |> ceil
|
|
let randomAmount = baseAmount + randomBonus |> int
|
|
max 1 randomAmount
|
|
|
|
let getResultEmbed chance prize (bank : int<GBT>) thief (victim : DiscordPlayer) result =
|
|
let embed =
|
|
DiscordEmbedBuilder()
|
|
.AddField("Thief", $"<@{thief.DiscordId}>")
|
|
.AddField("Victim", $"<@{victim.Id}>")
|
|
.AddField("Chance of Success" , $"{chance * 100.0 |> int}%%", true)
|
|
let msg , img , color =
|
|
match result with
|
|
| Success ->
|
|
embed.AddField("Loot" , $"{prize}", true)
|
|
.AddField("New GoodBoyTokenⒸ Balance", $"`{bank}` => 💰 `{bank + prize}` (+{prize}) ") |> ignore
|
|
($"\n\n You **STOLE** `{prize} $GBT` 🎉\n\n"
|
|
+ "Your mean ugly face and athletic physique intimidated your poor victim into giving you their money")
|
|
, "https://f8n-production-collection-assets.imgix.net/0x3B3ee1931Dc30C1957379FAc9aba94D1C48a5405/127502/QmPLPg1CLovKzS7mP8QkrMoHws1D4VZTzpfbZBALLwKZ5b/nft.png"
|
|
, DiscordColor.Green
|
|
| WentToPrison ->
|
|
embed.AddField("Result" , $"Imprisoned", true) |> ignore
|
|
$"You're going to **PRISON**...\n\n{victim.Name} knows Karate and elbowed you in the nose. While unconscious, they called the cops."
|
|
, "https://thumbs.dreamstime.com/b/vector-pixel-art-prisoner-isolated-cartoon-vector-pixel-art-prisoner-129807237.jpg"
|
|
, DiscordColor.Red
|
|
|
|
embed.WithTitle($"Steal Results")
|
|
.WithColor(color)
|
|
.WithDescription(msg)
|
|
// .WithImageUrl(img)
|
|
|
|
// TODO: See if we are going to keep this
|
|
let checkVictimStealingCooldown defender attacker =
|
|
defender
|
|
|> Player.removeExpiredActions
|
|
|> fun p -> p.Events
|
|
|> List.tryFind (fun e ->
|
|
match e.Type with Stealing _ -> true | _ -> false)
|
|
|> function
|
|
| Some act ->
|
|
let cooldown = VictimRecovery - (DateTime.UtcNow - act.Timestamp)
|
|
let hours = if cooldown.Hours = 0 then "hour" else $"{cooldown.Hours} hours"
|
|
Error $"{defender.Name} was robbed recently so they won't be going out for at least another {hours}."
|
|
| None -> Ok attacker
|
|
|
|
let checkTargetHasFunds target player =
|
|
match target.Bank <= 0<GBT> with
|
|
| true -> Error $"Looks like the poor bastard has no $GBT... pick a different victim."
|
|
| false -> Ok player
|
|
|
|
let checkPrizeRequestZero request player =
|
|
match request <= 0 with
|
|
| true -> Error $"You don't want to steal anything? Were you dropped on your head as a kid? Pick a different amount"
|
|
| false -> Ok player
|
|
|
|
let checkThiefCooldown attacker =
|
|
attacker
|
|
|> Player.removeExpiredActions
|
|
|> fun p -> p.Events
|
|
|> List.tryFind (fun pe -> match pe.Type with Stealing(instigator, _) -> instigator | _ -> false)
|
|
|> function
|
|
| Some act ->
|
|
let cooldown = ThiefCooldown - (DateTime.UtcNow - act.Timestamp)
|
|
let minutes = if cooldown.Minutes = 0 then "minute" else $"{cooldown.Minutes} minutes"
|
|
Error $"Whoa there you clepto, wait at least another {minutes} before you try stealing again."
|
|
| None -> Ok attacker
|
|
|
|
let checkPlayerIsAttackingThemselves defender attacker =
|
|
match attacker.DiscordId = defender.DiscordId with
|
|
| true -> Error "You think you're clever? You can't steal your own money, you dingleberry."
|
|
| false -> Ok attacker
|
|
|
|
let calculateWinPercentage amountRequested bank attackerStrength defenderStrength =
|
|
let powerPercentage = float (attackerStrength - defenderStrength) * 0.005 + 0.1
|
|
// let cappedAmount = float bank * 0.5
|
|
let cappedAmount = float bank
|
|
let cappedRequest , wasCapped = if amountRequested > cappedAmount then ( cappedAmount , true ) else ( amountRequested , false )
|
|
let wagerPercentage = 1.0 - (cappedRequest / cappedAmount)
|
|
// Max chance of success is 90.0%
|
|
( int cappedRequest , max 0.0 (wagerPercentage * 0.7 + powerPercentage * 1.3 ) / 2.0 , wasCapped )
|
|
|
|
//calculateWinPercentage 50 200 100 85
|
|
|
|
let steal target amount (ctx : IDiscordContext) =
|
|
executePlayerActionWithTarget target ctx (fun thief victim -> async { do!
|
|
thief
|
|
|> checkPlayerIsAttackingThemselves victim
|
|
// |> checkVictimStealingCooldown victim
|
|
>>= checkTargetHasFunds victim
|
|
>>= checkPrizeRequestZero amount
|
|
|> handleResultWithResponse ctx (fun _ -> async {
|
|
let cappedPrize , winPercentage , wasCapped =
|
|
calculateWinPercentage amount (int victim.Bank) thief.Stats.Strength.Amount victim.Stats.Strength.Amount
|
|
|
|
let chance = int (winPercentage * 100.0)
|
|
let buttons =
|
|
let btnId = $"Steal-yes-{victim.DiscordId}-{victim.Name}-{cappedPrize}"
|
|
[ DiscordButtonComponent(ButtonStyle.Success, btnId, $"Steal {cappedPrize} $GBT") ]
|
|
|> Seq.cast<DiscordComponent>
|
|
|
|
let cappedMsg = if wasCapped then $"They only have {cappedPrize} $GBT though... " else ""
|
|
let strengthMsg =
|
|
match thief.Stats.Strength.Amount - victim.Stats.Strength.Amount with
|
|
| diff when diff < -50 -> "much stronger"
|
|
| diff when diff < 0 -> "stronger"
|
|
| diff when diff < 50 -> "weaker"
|
|
| _ -> "much weaker"
|
|
let msg =
|
|
DiscordFollowupMessageBuilder()
|
|
.WithContent($"Want to steal from <@{victim.DiscordId}>? They look {strengthMsg} than us so we have a **{chance}%% of success**. {cappedMsg}What do you say?")
|
|
.AddComponents(buttons)
|
|
.AsEphemeral(true)
|
|
|
|
do! ctx.FollowUp(msg) |> Async.AwaitTask
|
|
})
|
|
})
|
|
|
|
let handleSteal (ctx : IDiscordContext) =
|
|
let tokens = ctx.GetInteractionId().Split("-")
|
|
let answer = tokens.[1]
|
|
|
|
let handleYes (victim : PlayerData) (thief : PlayerData) = async {
|
|
let targetId = uint64 tokens.[2]
|
|
let targetName = tokens.[3]
|
|
let amount = int tokens.[4]
|
|
let prize , winPercentage , _ = calculateWinPercentage amount (int victim.Bank) thief.Stats.Strength.Amount victim.Stats.Strength.Amount
|
|
let prize = int prize * 1<GBT>
|
|
|
|
let rand = Random(Guid.NewGuid().GetHashCode())
|
|
|
|
let num = rand.NextDouble()
|
|
let dp = { DiscordPlayer.Id = targetId ; DiscordPlayer.Name = targetName }
|
|
let getResultEmbed' = getResultEmbed winPercentage prize thief.Bank thief dp
|
|
// TODO: Send event to the hall of privacy
|
|
// TODO: We need to check if the player is on cooldown
|
|
match winPercentage >= num with
|
|
| true ->
|
|
let embed = getResultEmbed' Success
|
|
do! Messaging.sendFollowUpEmbed ctx (embed.Build())
|
|
match! DbService.tryFindPlayer targetId with
|
|
| Some t ->
|
|
let mugged = {
|
|
Type = Stealing ( false , thief.toDiscordPlayer )
|
|
Timestamp = DateTime.UtcNow
|
|
Cooldown = VictimRecovery.Minutes * 1<mins>
|
|
}
|
|
do! DbService.updatePlayer { t with Bank = max (t.Bank - prize) 0<GBT> } |> Async.Ignore
|
|
do! DbService.addPlayerEvent victim.DiscordId mugged |> Async.Ignore
|
|
| None -> ()
|
|
|
|
let stole = {
|
|
Type = Stealing ( true , dp )
|
|
Cooldown = ThiefCooldown.Minutes * 1<mins>
|
|
Timestamp = DateTime.UtcNow
|
|
}
|
|
do! DbService.updatePlayer { thief with Bank = thief.Bank + prize } |> Async.Ignore
|
|
do! DbService.addPlayerEvent victim.DiscordId stole |> Async.Ignore
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{thief.Name} stole {prize} from <@{victim.DiscordId}>!") |> ignore
|
|
let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| false ->
|
|
let embed = getResultEmbed' WentToPrison
|
|
let imprisoned = {
|
|
Type = Imprison
|
|
Cooldown = ThiefCooldown.Minutes * 1<mins>
|
|
Timestamp = DateTime.UtcNow
|
|
}
|
|
do! DbService.addPlayerEvent victim.DiscordId imprisoned |> Async.Ignore
|
|
do! Messaging.sendFollowUpEmbed ctx (embed.Build())
|
|
do! Async.Sleep 2000
|
|
let role = ctx.GetGuild().GetRole(GuildEnvironment.rolePrisoner)
|
|
do! ctx.GetDiscordMember().GrantRoleAsync(role) |> Async.AwaitTask
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{thief.Name} went to prison for trying to steal from {victim.Name}!") |> ignore
|
|
let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
}
|
|
if answer = "yes" then
|
|
let targetId = uint64 tokens.[2]
|
|
executePlayerActionWithTargetId true targetId ctx (fun attacker defender -> async {
|
|
do! attacker
|
|
|> Player.removeExpiredActions
|
|
// |> checkVictimStealingCooldown defender
|
|
|> checkThiefCooldown
|
|
>>= checkTargetHasFunds defender
|
|
|> handleResultWithResponse ctx (handleYes defender )
|
|
})
|
|
else
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.Content <- "I thought better of it"
|
|
do! ctx.Respond(InteractionResponseType.UpdateMessage, builder) |> Async.AwaitTask
|
|
} |> Async.StartAsTask :> Task
|
|
|
|
let handleStealButton _ (event : ComponentInteractionCreateEventArgs) =
|
|
let eventCtx = DiscordEventContext event :> IDiscordContext
|
|
match event.Id with
|
|
| id when id.StartsWith("Steal") -> handleSteal eventCtx
|
|
| _ ->
|
|
task {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Incorrect Action identifier {eventCtx.GetInteractionId()}"
|
|
do! eventCtx.Respond(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask
|
|
}
|
|
|
|
type StealGame() =
|
|
inherit ApplicationCommandModule ()
|
|
|
|
[<SlashCommand("steal", "Steal some money from another player, but you might go to prison if caught")>]
|
|
member this.Steal (ctx : InteractionContext,
|
|
[<Option("amount", "How much you would like to steal")>] amount : int64,
|
|
[<Option("target", "Who do you want to steal from?")>] target : DiscordUser) =
|
|
// enforceChannel (DiscordInteractionContext ctx) (steal target amount)
|
|
steal target (int amount) (DiscordInteractionContext ctx)
|
|
|
|
|