JosephFerano/discord-bot-game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use classes for actions, damage calculations, random weapons, Status command

Browse Source
This commit is contained in:
Joseph Ferano 2022-01-11 13:15:25 +07:00
parent 2f3a9fd1f9
commit d4e7170be1
1 changed files with 259 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

395
Program.fs
View File

@ -6,21 +6,65 @@ open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands open DSharpPlus.SlashCommands
open Emzi0767.Utilities open Emzi0767.Utilities
type Hack = type ActionClass =
| Virus = 0 | Network
| Ransom = 1 | Exploit
| DDos = 2 | Penetration
| Worm = 3
| Crack = 4 type IClass = abstract GetClass : unit -> ActionClass
| Injection = 5
type Weapon =
| Virus
| Ransom
| Worm
| DDos
| Crack
| Injection
interface IClass with
member this.GetClass () =
match this with
| Virus | Ransom -> Exploit
| DDos | Worm -> Network
| Crack | Injection -> Penetration
static member TryParse weapon =
match weapon with
| "Virus" -> Some Virus
| "Ransom" -> Some Ransom
| "Worm" -> Some Worm
| "DDos" -> Some DDos
| "Crack" -> Some Crack
| "Injection" -> Some Injection
| _ -> None
type Shield =
| Firewall
| PortScan
| Encryption
| Cypher
| Hardening
| Sanitation
interface IClass with
member this.GetClass () =
match this with
| Firewall | PortScan -> Exploit
| Encryption | Cypher -> Network
| Hardening | Sanitation -> Penetration
static member TryParse shield =
match shield with
| "Firewall" -> Some Firewall
| "PortScan" -> Some PortScan
| "Encryption" -> Some Encryption
| "Cypher" -> Some Cypher
| "Hardening" -> Some Hardening
| "Sanitation" -> Some Sanitation
| _ -> None
type HackResult =
| Strong
| Weak
type Protection =
| Firewall = 0
| PortScan = 1
| Encryption = 2
| Cypher = 3
| Hardening = 4
| Sanitation = 5
type DiscordPlayer = { type DiscordPlayer = {
Id : uint64 Id : uint64
@ -28,44 +72,47 @@ type DiscordPlayer = {
} }
type Attack = { type Attack = {
HackType : Hack HackType : Weapon
Target : DiscordPlayer Target : DiscordPlayer
Timestamp : DateTime Timestamp : DateTime
} }
type Defense = { type Defense = {
DefenseType : Protection DefenseType : Shield
Timestamp : DateTime Timestamp : DateTime
} }
type Player = { type Player = {
DiscordId : uint64 DiscordId : uint64
Hacks : Hack list Weapons : Weapon list
Protections : Protection list Shields : Shield list
Attacks : Attack list Attacks : Attack list
Defenses : Defense list Defenses : Defense list
Bank : int64 Bank : single
} }
let mutable players : Player list = [] let mutable players : Player list = []
type EmptyGlobalCommandToAvoidFamousDuplicateSlashCommandsBug() = inherit ApplicationCommandModule ()
let newPlayer (membr : uint64) = let newPlayer (membr : uint64) =
// let rand = System.Random(System.Guid.NewGuid().GetHashCode()) let h1 = [| Virus ; Ransom |]
// let hacks = let h2 = [| DDos ; Worm |]
// [0..2] let h3 = [| Crack ; Injection |]
// |> Set.map (fun _ -> enum<HackType>(rand.Next(0, 6))) let d1 = [| Firewall ; PortScan |]
// let defns = let d2 = [| Encryption ; Cypher |]
// [0..2] let d3 = [| Hardening ; Sanitation |]
// |> Set.map (fun _ -> enum<DefenseType>(rand.Next(0, 6)))
let rand = System.Random(System.Guid.NewGuid().GetHashCode())
let getRandom (actions : 'a array) = actions.[rand.Next(0,2)]
let weapons = [ getRandom h1 ; getRandom h2 ; getRandom h3 ]
let shields = [ getRandom d1 ; getRandom d2 ; getRandom d3 ]
{ DiscordId = membr { DiscordId = membr
Hacks = [ Hack.Virus ; Hack.Worm ; Hack.Injection ] Weapons = weapons
Protections = [ Protection.Cypher ; Protection.Sanitation ; Protection.Firewall ] Shields = shields
Attacks = [] Attacks = []
Bank = 0L Defenses = []
Defenses = [] } Bank = 0f }
let constructButtons (actionType : string) (playerInfo : string) (weapons : 'a list) = let constructButtons (actionType : string) (playerInfo : string) (weapons : 'a list) =
weapons weapons
@ -75,19 +122,18 @@ let constructButtons (actionType : string) (playerInfo : string) (weapons : 'a l
$"{actionType}-{hack}-{playerInfo}", $"{actionType}-{hack}-{playerInfo}",
$"{hack}")) $"{hack}"))
let notRegisteredYetMessage (ctx : InteractionContext) = let createSimpleResponseAsync msg (ctx : InteractionContext) =
async { async {
let builder = DiscordInteractionResponseBuilder() let builder = DiscordInteractionResponseBuilder()
builder.Content <- $"You are not currently a hacker, first use the /redpill command to become one" builder.Content <- msg
builder.AsEphemeral true |> ignore builder.AsEphemeral true |> ignore
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask |> Async.AwaitTask
} |> Async.StartAsTask } |> Async.StartAsTask
:> Task :> Task
let notYetAHackerMsg = createSimpleResponseAsync "You are not currently a hacker, first use the /redpill command to become one"
let removeExpiredActions timespan (timestamp : 'a -> DateTime) actions = let removeExpiredActions timespan (timestamp : 'a -> DateTime) actions =
actions actions
|> List.filter (fun act -> |> List.filter (fun act ->
@ -101,11 +147,13 @@ let constructEmbed message =
builder.Description <- message builder.Description <- message
let author = DiscordEmbedBuilder.EmbedAuthor() let author = DiscordEmbedBuilder.EmbedAuthor()
author.Name <- "Joebot Pro" author.Name <- "Joebot Pro"
author.Url <- "https://ferano.io" author.Url <- "https://twitter.com/degenzgame"
author.IconUrl <- "https://i.kym-cdn.com/entries/icons/original/000/028/861/cover3.jpg" author.IconUrl <- "https://pbs.twimg.com/profile_images/1473192843359309825/cqjm0VQ4_400x400.jpg"
builder.Author <- author builder.Author <- author
builder.Build() builder.Build()
type EmptyGlobalCommandToAvoidFamousDuplicateSlashCommandsBug() = inherit ApplicationCommandModule ()
type JoeBot() = type JoeBot() =
inherit ApplicationCommandModule () inherit ApplicationCommandModule ()
@ -141,6 +189,7 @@ type JoeBot() =
if role.Name = "Hacker" then if role.Name = "Hacker" then
do! ctx.Member.RevokeRoleAsync(role) do! ctx.Member.RevokeRoleAsync(role)
|> Async.AwaitTask |> Async.AwaitTask
players <- players |> List.filter (fun p -> p.DiscordId <> ctx.User.Id)
do! ctx.CreateResponseAsync("You are now lame", true) do! ctx.CreateResponseAsync("You are now lame", true)
|> Async.AwaitTask |> Async.AwaitTask
} |> Async.StartAsTask } |> Async.StartAsTask
@ -148,47 +197,48 @@ type JoeBot() =
[<SlashCommand("hack", "Send a hack attack to another player")>] [<SlashCommand("hack", "Send a hack attack to another player")>]
member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) = member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) =
// TODO: We need to check if the player has any active hacks going, if not they can cheat // TODO: We need to check if the player has any active embed hacks going, if not they can cheat
players let attacker = players |> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id)
|> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id) let defender = players |> List.tryFind (fun p -> p.DiscordId = target.Id)
|> function match attacker , defender with
| Some player -> | Some attacker , Some defender ->
let updatedAttacks = removeExpiredActions (TimeSpan.FromMinutes(15)) (fun (atk : Attack) -> atk.Timestamp) player.Attacks let updatedAttacks = removeExpiredActions (TimeSpan.FromMinutes(15)) (fun (atk : Attack) -> atk.Timestamp) attacker.Attacks
players <- players <-
players players
|> List.map (fun p -> if p.DiscordId = player.DiscordId then { p with Attacks = updatedAttacks } else p) |> List.map (fun p -> if p.DiscordId = attacker.DiscordId then { p with Attacks = updatedAttacks } else p)
if updatedAttacks.Length < 1 then if updatedAttacks.Length < 2 then
async { async {
let builder = DiscordInteractionResponseBuilder() let builder = DiscordInteractionResponseBuilder()
builder.AddEmbed (constructEmbed "Pick the hack you wish to use.") |> ignore builder.AddEmbed (constructEmbed "Pick the hack you wish to use.") |> ignore
let targetInfo = $"{target.Id}-{target.Username}" let defenderInfo = $"{defender.DiscordId}-{target.Username}"
constructButtons "Attack" targetInfo player.Hacks constructButtons "Attack" defenderInfo attacker.Weapons
|> Seq.cast<DiscordComponent> |> Seq.cast<DiscordComponent>
|> builder.AddComponents |> builder.AddComponents
|> ignore |> ignore
builder.AsEphemeral true |> ignore builder.AsEphemeral true |> ignore
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask |> Async.AwaitTask
} |> Async.StartAsTask } |> Async.StartAsTask
:> Task :> Task
else else
async { async {
let builder = DiscordInteractionResponseBuilder() let builder = DiscordInteractionResponseBuilder()
let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - updatedAttacks.Head.Timestamp) let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - updatedAttacks.Head.Timestamp)
builder.Content <- $"You already hacked, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to attempt another hack" builder.Content <- $"You already hacked, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to attempt another hack"
builder.AsEphemeral true |> ignore builder.AsEphemeral true |> ignore
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask |> Async.AwaitTask
} |> Async.StartAsTask } |> Async.StartAsTask
:> Task :> Task
| None -> notRegisteredYetMessage ctx | None , _ -> notYetAHackerMsg ctx
| _ , None -> createSimpleResponseAsync "Your target is not connected to the network, they must join first by using the /redpill command" ctx
[<SlashCommand("defend", "Create a passive defense that will last a certain amount of time")>] [<SlashCommand("defend", "Create a passive defense that will last a certain amount of time")>]
@ -205,7 +255,7 @@ type JoeBot() =
let builder = DiscordInteractionResponseBuilder() let builder = DiscordInteractionResponseBuilder()
builder.AddEmbed (constructEmbed "Pick a defense to mount for a duration of time") |> ignore builder.AddEmbed (constructEmbed "Pick a defense to mount for a duration of time") |> ignore
constructButtons "Defense" (string player.DiscordId) player.Protections constructButtons "Defend" (string player.DiscordId) player.Shields
|> Seq.cast<DiscordComponent> |> Seq.cast<DiscordComponent>
|> builder.AddComponents |> builder.AddComponents
|> ignore |> ignore
@ -217,71 +267,137 @@ type JoeBot() =
} |> Async.StartAsTask } |> Async.StartAsTask
:> Task :> Task
| None -> notRegisteredYetMessage ctx | None -> notYetAHackerMsg ctx
[<SlashCommand("status", "Get your current status like bank account, and active hacks and defenses")>]
member this.Status (ctx : InteractionContext) =
async {
return!
match players |> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id) with
| Some player ->
async {
let builder = DiscordInteractionResponseBuilder()
builder.IsEphemeral <- true
builder.Content <- $"%A{player}"
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask
}
| None -> notYetAHackerMsg ctx |> Async.AwaitTask
} |> Async.StartAsTask
:> Task
let calculateDamage (hack : IClass) (protection : IClass) =
let hackClass = hack.GetClass()
let protectionClass = protection.GetClass()
match hackClass , protectionClass with
| h , p when h = p -> Weak
| _ -> Strong
let handleAttack (event : ComponentInteractionCreateEventArgs) = let handleAttack (event : ComponentInteractionCreateEventArgs) =
let updatePlayer amount attack p = {
p with Attacks = attack::p.Attacks
Bank = MathF.Max(p.Bank + amount, 0f)
}
async { async {
let split = event.Id.Split("-") let split = event.Id.Split("-")
let ( resultHack , hackType ) = Enum.TryParse(typedefof<Hack>, split.[1]) let resultHack = Weapon.TryParse(split.[1])
let ( resultId , targetId ) = UInt64.TryParse split.[2] let ( resultId , targetId ) = UInt64.TryParse split.[2]
match resultHack , resultId with return!
| true , true -> match resultHack , resultId with
let hackType = hackType :?> Hack | Some weapon , true ->
let builder = DiscordInteractionResponseBuilder() let hackType = weapon
builder.IsEphemeral <- true
builder.Content <- $"Sent {hackType} to {split.[3]}!"
do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
|> Async.AwaitTask
let attack = { HackType = hackType ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
players <-
players players
|> List.map (fun p -> if p.DiscordId = event.User.Id then { p with Attacks = attack::p.Attacks } else p) |> List.find (fun p -> p.DiscordId = targetId)
|> fun p -> p.Defenses
let builder = DiscordMessageBuilder() |> List.map (fun dfn -> dfn.DefenseType)
builder.WithContent($"{event.User.Username} has sent a hack to <@{targetId}>") |> ignore |> List.map (calculateDamage hackType)
let battleChannel = (event.Guild.GetChannel(927449884204867664uL)) |> List.contains Weak
do! battleChannel.SendMessageAsync(builder) |> function
|> Async.AwaitTask | false ->
|> Async.Ignore async {
| _ -> let prize = 0.1726f
let builder = DiscordInteractionResponseBuilder() let attack = { HackType = hackType ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
builder.IsEphemeral <- true players <-
builder.Content <- "Error parsing Button Id" players
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> List.map (fun p -> if p.DiscordId = event.User.Id then updatePlayer prize attack p else p)
|> Async.AwaitTask
let builder = DiscordInteractionResponseBuilder()
builder.IsEphemeral <- true
builder.Content <- $"Successfully hacked {split.[3]} using {hackType}! 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 battleChannel = (event.Guild.GetChannel(927449884204867664uL))
do! battleChannel.SendMessageAsync(builder)
|> Async.AwaitTask
|> Async.Ignore
}
| true ->
async {
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 = hackType ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
players <-
players
|> List.map (fun p -> if p.DiscordId = event.User.Id then updatePlayer loss attack p else p)
let builder = DiscordMessageBuilder()
builder.WithContent($"{event.User.Username} failed to hack <@{targetId}>!") |> ignore
let battleChannel = (event.Guild.GetChannel(927449884204867664uL))
do! battleChannel.SendMessageAsync(builder)
|> Async.AwaitTask
|> Async.Ignore
}
| _ ->
async {
let builder = DiscordInteractionResponseBuilder()
builder.IsEphemeral <- true
builder.Content <- "Error parsing Button Id"
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask
}
} }
let handleDefense (event : ComponentInteractionCreateEventArgs) = let handleDefense (event : ComponentInteractionCreateEventArgs) =
async { async {
let split = event.Id.Split("-") let split = event.Id.Split("-")
let ( resultHack , protectionType ) = Enum.TryParse(typedefof<Protection>, split.[1]) return!
match resultHack with match Shield.TryParse(split.[1]) with
| true -> | Some shield ->
let protectionType = protectionType :?> Protection async {
let builder = DiscordInteractionResponseBuilder() let builder = DiscordInteractionResponseBuilder()
builder.IsEphemeral <- true builder.IsEphemeral <- true
builder.Content <- $"Mounted a {protectionType} defense for 1 hour" builder.Content <- $"Mounted a {shield} defense for 1 hour"
do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder) do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
|> Async.AwaitTask |> Async.AwaitTask
let defense = { DefenseType = protectionType ; Timestamp = DateTime.UtcNow } let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow }
players <- players <-
players players
|> List.map (fun p -> { p with Defenses = defense::p.Defenses }) |> List.map (fun p -> { p with Defenses = defense::p.Defenses })
let builder = DiscordMessageBuilder() let builder = DiscordMessageBuilder()
builder.WithContent($"{event.User.Username} has protected their system!") |> ignore builder.WithContent($"{event.User.Username} has protected their system!") |> ignore
let battleChannel = (event.Guild.GetChannel(927449884204867664uL)) let battleChannel = (event.Guild.GetChannel(927449884204867664uL))
do! battleChannel.SendMessageAsync(builder) do! battleChannel.SendMessageAsync(builder)
|> Async.AwaitTask |> Async.AwaitTask
|> Async.Ignore |> Async.Ignore
| _ -> }
let builder = DiscordInteractionResponseBuilder() | _ ->
builder.IsEphemeral <- true async {
builder.Content <- "Error parsing Button Id" let builder = DiscordInteractionResponseBuilder()
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) builder.IsEphemeral <- true
|> Async.AwaitTask builder.Content <- "Error parsing Button Id"
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|> Async.AwaitTask
}
} }
let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCreateEventArgs) = let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
@ -289,7 +405,14 @@ let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCrea
return! match event.Id with return! match event.Id with
| id when id.StartsWith("Attack") -> handleAttack event | id when id.StartsWith("Attack") -> handleAttack event
| id when id.StartsWith("Defend") -> handleDefense event | id when id.StartsWith("Defend") -> handleDefense event
| _ -> async { return () } | _ ->
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 } |> Async.StartAsTask
:> Task :> Task