291 lines
14 KiB
Forth
291 lines
14 KiB
Forth
module DegenzGame.Commands
|
|
|
|
open System
|
|
open System.Threading.Tasks
|
|
open DSharpPlus
|
|
open DSharpPlus.Entities
|
|
open DSharpPlus.EventArgs
|
|
open DSharpPlus.SlashCommands
|
|
open DegenzGame.Types
|
|
open DegenzGame.Functions
|
|
open MongoDB.Driver
|
|
|
|
[<Literal>]
|
|
// Degenz Server
|
|
//let battleChannel = 930363007781978142uL
|
|
// My server
|
|
let battleChannel = 927449884204867664uL
|
|
|
|
let mongo = MongoClient("mongodb://localhost:27017")
|
|
let db = mongo.GetDatabase("degenz-game")
|
|
let players = db.GetCollection<Player>("players")
|
|
|
|
let tryFindPlayer (id : uint64) : Async<Player option> =
|
|
async {
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), id)
|
|
let! player = players.FindAsync<Player>(filter) |> Async.AwaitTask
|
|
return match player.ToEnumerable() |> Seq.toList with
|
|
| [] -> None
|
|
| p::_ -> Some p
|
|
}
|
|
|
|
let addHackerRole (ctx : InteractionContext) =
|
|
async {
|
|
let! player = tryFindPlayer ctx.Member.Id
|
|
let! newPlayer =
|
|
match player with
|
|
| Some _ -> async.Return false
|
|
| None ->
|
|
async {
|
|
let p = (newPlayer ctx.Member.Username ctx.Member.Id)
|
|
do! players.InsertOneAsync p |> Async.AwaitTask
|
|
|
|
for role in ctx.Guild.Roles do
|
|
if role.Value.Name = "Hacker" then
|
|
do! ctx.Member.GrantRoleAsync(role.Value)
|
|
|> Async.AwaitTask
|
|
|
|
return true
|
|
}
|
|
|
|
if newPlayer then
|
|
do! ctx.CreateResponseAsync("You are now an elite haxxor", true)
|
|
|> Async.AwaitTask
|
|
else
|
|
do! ctx.CreateResponseAsync("Already registered as an elite haxxor", true)
|
|
|> Async.AwaitTask
|
|
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let removeHackerRole (ctx : InteractionContext) =
|
|
async {
|
|
for role in ctx.Member.Roles do
|
|
if role.Name = "Hacker" then
|
|
do! ctx.Member.RevokeRoleAsync(role)
|
|
|> Async.AwaitTask
|
|
// TODO: Check the result of this delete operation
|
|
let! _ = players.DeleteOneAsync (fun p -> p.DiscordId = ctx.Member.Id) |> Async.AwaitTask
|
|
do! ctx.CreateResponseAsync("You are now lame", true)
|
|
|> Async.AwaitTask
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let attack (ctx : InteractionContext) (target : DiscordUser) =
|
|
async {
|
|
// TODO: We need to check if the player has any active embed hacks going, if not they can cheat
|
|
let! attacker = tryFindPlayer ctx.Member.Id
|
|
let! defender = tryFindPlayer target.Id
|
|
match attacker , defender with
|
|
| Some attacker , Some defender ->
|
|
let updatedAttacks = removeExpiredActions (TimeSpan.FromMinutes(5)) (fun (atk : Attack) -> atk.Timestamp) attacker.Attacks
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), attacker.DiscordId)
|
|
let update = Builders<Player>.Update.Set((fun p -> p.Attacks), updatedAttacks)
|
|
let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask
|
|
if updatedAttacks.Length < 2 then
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.AddEmbed (constructEmbed "Pick the hack you wish to use.") |> ignore
|
|
|
|
let defenderInfo = $"{defender.DiscordId}-{target.Username}"
|
|
constructButtons "Attack" defenderInfo attacker.Weapons
|
|
|> Seq.cast<DiscordComponent>
|
|
|> builder.AddComponents
|
|
|> ignore
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
|
|
else
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let timestamp = updatedAttacks |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
|
|
let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
|
|
builder.Content <- $"No more hacks available, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to attempt another hack"
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
|
|
| None , _ -> do! notYetAHackerMsg ctx
|
|
| _ , None -> do! createSimpleResponseAsync "Your target is not connected to the network, they must join first by using the /redpill command" ctx
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let defend (ctx : InteractionContext) =
|
|
async {
|
|
let! player = tryFindPlayer ctx.Member.Id
|
|
match player with
|
|
| Some player ->
|
|
let updatedDefenses = removeExpiredActions (TimeSpan.FromMinutes(60)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
|
|
let update = Builders<Player>.Update.Set((fun p -> p.Defenses), updatedDefenses)
|
|
let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask
|
|
if updatedDefenses.Length < 2 then
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.AddEmbed (constructEmbed "Pick a defense to mount for a duration of time") |> ignore
|
|
|
|
constructButtons "Defend" (string player.DiscordId) player.Shields
|
|
|> Seq.cast<DiscordComponent>
|
|
|> builder.AddComponents
|
|
|> ignore
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
else
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let timestamp = updatedDefenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
|
|
let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
|
|
builder.Content <- $"Cannot add new defense, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to add another defense"
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
| None -> do! notYetAHackerMsg ctx
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let status (ctx : InteractionContext) =
|
|
async {
|
|
let! player = tryFindPlayer ctx.Member.Id
|
|
match player with
|
|
| Some p ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- Functions.statusFormat p
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
| None -> do! notYetAHackerMsg ctx
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let leaderboard (ctx : InteractionContext) =
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
|
|
let! leaders = players.Find(fun _ -> true).SortBy(fun p -> p.Bank).Limit(10).ToListAsync() |> Async.AwaitTask
|
|
let content =
|
|
leaders.ToArray()
|
|
|> Array.mapi (fun i p -> $"{i + 1}. {p.Bank} {p.Name}")
|
|
|> String.concat "\n"
|
|
builder.Content <- if not <| String.IsNullOrEmpty content then content else "There are no active hackers"
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
let handleAttack (event : ComponentInteractionCreateEventArgs) =
|
|
let updatePlayer amount attack p =
|
|
{ p with Attacks = Array.append [| attack |] p.Attacks ; Bank = MathF.Max(p.Bank + amount, 0f) }
|
|
async {
|
|
let split = event.Id.Split("-")
|
|
let ( resultHack , weapon ) = Weapon.TryParse(split.[1])
|
|
let ( resultId , targetId ) = UInt64.TryParse split.[2]
|
|
let! resultPlayer = tryFindPlayer event.User.Id
|
|
let! resultTarget = tryFindPlayer targetId
|
|
match resultPlayer , resultTarget , resultHack , resultId with
|
|
| Some player , Some target , true , true ->
|
|
let wasSuccessfulHack =
|
|
target.Defenses
|
|
|> Seq.toArray
|
|
|> Array.map (fun dfn -> int dfn.DefenseType)
|
|
|> Array.map (calculateDamage weapon)
|
|
|> Array.contains Weak
|
|
match wasSuccessfulHack with
|
|
| false ->
|
|
let prize = 0.1726f
|
|
let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
|
|
let! _ = players.ReplaceOneAsync(filter, updatePlayer prize attack player) |> Async.AwaitTask
|
|
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Successfully hacked {split.[3]} using {weapon}! You just won {prize} genz!"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
|
|
|> Async.AwaitTask
|
|
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{event.User.Username} successfully hacked <@{targetId}>!") |> ignore
|
|
let channel = (event.Guild.GetChannel(battleChannel))
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| true ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let loss = -0.0623f
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Hack failed! {split.[3]} was able to mount a successful defense! You lost {loss} genz!"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
|
|
|> Async.AwaitTask
|
|
|
|
let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
|
|
let! _ = players.ReplaceOneAsync(filter, updatePlayer loss attack player) |> Async.AwaitTask
|
|
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{event.User.Username} failed to hack <@{targetId}>!") |> ignore
|
|
let channel = (event.Guild.GetChannel(battleChannel))
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| _ ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- "Error occurred processing attack"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
}
|
|
|
|
let handleDefense (event : ComponentInteractionCreateEventArgs) =
|
|
async {
|
|
let split = event.Id.Split("-")
|
|
let ( shieldResult , shield ) = Shield.TryParse(split.[1])
|
|
let! playerResult = tryFindPlayer event.User.Id
|
|
match playerResult , shieldResult with
|
|
| Some player , true ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Mounted a {shield} defense for 1 hour"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
|
|
|> Async.AwaitTask
|
|
|
|
let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow }
|
|
let filter = Builders<Player>.Filter.Eq((fun p -> p.DiscordId), player.DiscordId)
|
|
let update = Builders<Player>.Update.Set((fun p -> p.Defenses), Array.append [| defense |] player.Defenses )
|
|
let! _ = players.UpdateOneAsync(filter, update) |> Async.AwaitTask
|
|
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{event.User.Username} has protected their system!") |> ignore
|
|
let channel = event.Guild.Channels.Values |> Seq.find (fun c -> c.Name = "battle-1")
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| _ ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- "Error parsing Button Id"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
}
|
|
|
|
let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
|
|
async {
|
|
return! match event.Id with
|
|
| id when id.StartsWith("Attack") -> handleAttack event
|
|
| id when id.StartsWith("Defend") -> handleDefense event
|
|
| _ ->
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Incorrect Action identifier {event.Id}"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
}
|
|
} |> Async.StartAsTask
|
|
:> Task
|