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

Just read the stats from the user table. Remove dbconnectione everywhere

Browse Source
This commit is contained in:
Joseph Ferano 2022-03-01 13:14:32 +07:00
parent 53f60bcf86
commit 05cdb98bee
10 changed files with 156 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
Bot/DbService.fs
View File

@ -4,27 +4,23 @@ open System
open Npgsql.FSharp
open Degenz
let connStr = GuildEnvironment.connectionString
type User = {
Name : string
DiscordId : uint64
Bank : int<GBT>
Strength : int
Inventory : int list
Strength : int
Focus : int
Charisma : int
Luck : int
}
let mapBack user : PlayerData =
{ DiscordId = user.DiscordId
Name = user.Name
Inventory = user.Inventory |> List.choose (fun id -> Armory.weapons |> List.tryFind (fun item -> item.Id = id))
Events = [||]
Stats = { Stats.empty with Strength = { Id = StatId.Strength ; ModMinMax = Range(0, 100) ; Amount = user.Strength; LastRead = DateTime.UtcNow } }
Bank = user.Bank
}
let getPlayerEvents connStr (player : PlayerData) =
let getPlayerEvents (did : uint64) =
connStr
|> Sql.connect
|> Sql.parameters [ "did", Sql.string (string player.DiscordId) ]
|> Sql.parameters [ "did", Sql.string (string did) ]
|> Sql.query """
WITH usr AS (SELECT id FROM "user" WHERE discord_id = @did)
SELECT event_type, success, is_instigator, item_id, cooldown, adversary_id, adversary_name, created_at
@ -48,59 +44,92 @@ let getPlayerEvents connStr (player : PlayerData) =
)
|> Async.AwaitTask
let tryFindPlayer connStr (discordId : uint64) =
async {
try
let! user =
// use cert = new X509Certificate2("~/Downloads/ca-certificate.crt")
// (Uri connStr)
// |> Sql.fromUriToConfig
// |> Sql.requireSslMode
// |> Sql.formatConnectionString
// |> Sql.clientCertificate cert
connStr
|> Sql.connect
|> Sql.parameters [ "did", Sql.string (string discordId) ]
|> Sql.query """
SELECT discord_id, display_name, gbt, strength, inventory FROM "user" WHERE discord_id = @did
"""
|> Sql.executeAsync (fun read ->
{
DiscordId = read.string "discord_id" |> uint64
Name = read.string "display_name"
Bank = read.int "gbt" * 1<GBT>
Strength = read.int "strength"
Inventory = read.intArray "inventory" |> Array.toList
})
|> Async.AwaitTask
match List.tryHead user with
| None -> return None
| Some u ->
let player = mapBack u
let! events = getPlayerEvents connStr player
return Some { player with Events = events |> List.toArray }
with e ->
printfn $"Got an error{e.Message}"
return None
}
let updatePlayerStats (player : PlayerData) =
connStr
|> Sql.connect
|> Sql.parameters
[ ( "did" , Sql.string (string player.DiscordId) )
( "strength", Sql.int player.Stats.Strength.Amount )
( "focus", Sql.int player.Stats.Focus.Amount )
( "charisma", Sql.int player.Stats.Charisma.Amount )
( "luck", Sql.int player.Stats.Luck.Amount ) ]
|> Sql.query """
WITH usr AS (SELECT id FROM "user" WHERE discord_id = @did)
UPDATE player_stat SET strength = @strength, focus = @focus, charisma = @charisma, luck = @luck,
updated_at = now() at time zone 'utc'
FROM usr WHERE usr.id = user_id;
"""
|> Sql.executeNonQueryAsync
|> Async.AwaitTask
let updatePlayer connStr (player : PlayerData) =
let tryFindPlayer (discordId : uint64) = async {
try
let! user =
// use cert = new X509Certificate2("~/Downloads/ca-certificate.crt")
// (Uri connStr)
// |> Sql.fromUriToConfig
// |> Sql.requireSslMode
// |> Sql.formatConnectionString
// |> Sql.clientCertificate cert
connStr
|> Sql.connect
|> Sql.parameters [ "did", Sql.string (string discordId) ]
|> Sql.query """
SELECT discord_id, display_name, gbt, inventory, strength, focus, charisma, luck FROM "user"
WHERE discord_id = @did
"""
|> Sql.executeAsync (fun read -> {
DiscordId = read.string "discord_id" |> uint64
Name = read.string "display_name"
Bank = read.int "gbt" * 1<GBT>
Inventory = read.intArray "inventory" |> Array.toList
Strength = read.int "strength"
Focus = read.int "focus"
Charisma = read.int "charm"
Luck = read.int "luck"
})
|> Async.AwaitTask
match List.tryHead user with
| None -> return None
| Some u ->
let! events = getPlayerEvents u.DiscordId
let inventory = u.Inventory |> List.choose (fun id -> Armory.weapons |> List.tryFind (fun item -> item.Id = id))
let strength = PlayerStats.calculateActiveStat StatId.Strength u.Strength inventory
let focus = PlayerStats.calculateActiveStat StatId.Focus u.Focus inventory
let charisma = PlayerStats.calculateActiveStat StatId.Charisma u.Charisma inventory
let luck = PlayerStats.calculateActiveStat StatId.Luck u.Luck inventory
return Some
{ DiscordId = u.DiscordId
Name = u.Name
Inventory = inventory
Events = events
Stats = { Strength = strength ; Focus = focus ; Charisma = charisma ; Luck = luck }
Bank = u.Bank }
with e ->
printfn $"Got an error{e.Message}"
return None
}
let updatePlayer (player : PlayerData) =
connStr
|> Sql.connect
|> Sql.parameters [
"did", Sql.string (string player.DiscordId)
"gbt", Sql.int (int player.Bank)
"str", Sql.int (player.Stats.Strength.Amount |> int)
"inv", Sql.intArray (player.Inventory |> Array.ofList |> Array.map (fun item -> item.Id))
]
|> Sql.query """
UPDATE "user" SET gbt = @gbt, strength = @str, inventory = @inv
"strength", Sql.int player.Stats.Strength.Amount
"focus", Sql.int player.Stats.Focus.Amount
"charisma", Sql.int player.Stats.Charisma.Amount
"luck", Sql.int player.Stats.Luck.Amount
] |> Sql.query """
UPDATE "user" SET gbt = @gbt, inventory = @inv,
strength = @strength, focus = @focus, charisma = @charisma, luck = @luck
WHERE discord_id = @did
"""
|> Sql.executeNonQueryAsync
|> Async.AwaitTask
let addAchievement connStr (did : uint64) (achievement : string) =
let addAchievement (did : uint64) (achievement : string) =
connStr
|> Sql.connect
|> Sql.parameters
@ -114,7 +143,7 @@ let addAchievement connStr (did : uint64) (achievement : string) =
|> Sql.executeNonQueryAsync
|> Async.AwaitTask
let checkHasAchievement connStr (did : uint64) (achievement : string) = async {
let checkHasAchievement (did : uint64) (achievement : string) = async {
let! result =
connStr
|> Sql.connect
@ -131,7 +160,7 @@ let checkHasAchievement connStr (did : uint64) (achievement : string) = async {
return List.isEmpty result |> not
}
let removeShieldEvent connStr (did : uint64) shieldId =
let removeShieldEvent (did : uint64) shieldId =
connStr
|> Sql.connect
|> Sql.parameters
@ -144,7 +173,7 @@ let removeShieldEvent connStr (did : uint64) shieldId =
|> Sql.executeNonQueryAsync
|> Async.AwaitTask
let addPlayerEvent connStr (did : uint64) (playerEvent : PlayerEvent) =
let addPlayerEvent (did : uint64) (playerEvent : PlayerEvent) =
let sqlParams , query =
match playerEvent.Type with
| Hacking h ->

45
Bot/GameHelpers.fs
View File

@ -91,15 +91,15 @@ module WeaponClass =
module Player =
let getHackEvents player =
player.Events
|> Array.filter (fun act -> match act.Type with PlayerEventType.Hacking h -> h.IsInstigator | _ -> false)
|> List.filter (fun act -> match act.Type with PlayerEventType.Hacking h -> h.IsInstigator | _ -> false)
let getShieldEvents player =
player.Events
|> Array.filter (fun act -> match act.Type with PlayerEventType.Shielding _ -> true | _ -> false)
|> List.filter (fun act -> match act.Type with PlayerEventType.Shielding _ -> true | _ -> false)
let removeExpiredActions player =
let actions =
player.Events
|> Array.filter (fun (act : PlayerEvent) ->
|> List.filter (fun (act : PlayerEvent) ->
let cooldown = System.TimeSpan.FromMinutes(int act.Cooldown)
System.DateTime.UtcNow - act.Timestamp < cooldown)
{ player with Events = actions }
@ -108,24 +108,23 @@ module Player =
module PlayerStats =
// 4.17f would go from 100 to 0 in roughly 24 hours
let Strength = { Id = StatId.Strength ; BaseDecayRate = 4.17 ; BaseMinMax = Range(0, 100) }
let Focus = { Id = StatId.Focus ; BaseDecayRate = 4.17 ; BaseMinMax = Range(0, 100) }
let Luck = { Id = StatId.Luck ; BaseDecayRate = 4.17 ; BaseMinMax = Range(0, 100) }
let Charisma = { Id = StatId.Charisma ; BaseDecayRate = 4.17 ; BaseMinMax = Range(0, 100) }
let Strength = { Id = StatId.Strength ; BaseDecayRate = 4.17 ; BaseRange = Range.normalized }
let Focus = { Id = StatId.Focus ; BaseDecayRate = 4.17 ; BaseRange = Range.normalized }
let Luck = { Id = StatId.Luck ; BaseDecayRate = 4.17 ; BaseRange = Range.normalized }
let Charisma = { Id = StatId.Charisma ; BaseDecayRate = 4.17 ; BaseRange = Range.normalized }
let stats = [ Strength ; Focus ; Luck ; Charisma ]
let calculateStatDecay (stat : PlayerStat) =
let statConfig = stats |> List.find (fun s -> s.Id = stat.Id)
let hoursElapsed = (DateTime.UtcNow - stat.LastRead).Hours
let totalDecay = float hoursElapsed * statConfig.BaseDecayRate
{ stat with Amount = max stat.ModMinMax.Start.Value (stat.Amount - int totalDecay) ; LastRead = DateTime.UtcNow }
let statConsumableMap =
[ ( StatId.Strength , 12 )
( StatId.Focus , 13 )
( StatId.Luck , 14 )
( StatId.Charisma , 15 ) ]
let calculateActiveStat statId amount items =
let statConfig = stats |> List.find (fun s -> s.Id = statId)
// let hoursElapsed = (DateTime.UtcNow - lastRead).Hours
// let totalDecay = float hoursElapsed * statConfig.BaseDecayRate
let modMinMax =
let min = items |> List.sumBy (fun item -> match item.Type with | Accessory(_,floorBoost,_) -> floorBoost | _ -> 0)
let max = items |> List.sumBy (fun item -> match item.Type with | Accessory(_,_,ceilBoost) -> ceilBoost | _ -> 0)
Range.create (statConfig.BaseRange.Min + min) (statConfig.BaseRange.Max + max)
let amountAfterDecay = modMinMax |> Range.constrain amount
{ Id = statId ; Amount = amountAfterDecay ; ModRange = modMinMax ; LastRead = DateTime.UtcNow }
module Arsenal =
let battleItemFormat (items : Item list) =
@ -133,12 +132,12 @@ module Arsenal =
| [] -> "None"
| _ -> items |> List.map (fun item -> item.Name) |> String.concat ", "
let actionFormat (actions : PlayerEvent array) =
let actionFormat (actions : PlayerEvent List) =
match actions with
| [||] -> "None"
| [] -> "None"
| acts ->
acts
|> Array.map (fun act ->
|> List.map (fun act ->
match act.Type with
| Hacking h ->
let item = Armory.weapons |> Inventory.findHackById h.HackId
@ -149,12 +148,12 @@ module Arsenal =
let cooldown = Messaging.getTimeText true (System.TimeSpan.FromMinutes(int act.Cooldown)) act.Timestamp
$"{item.Name} Shield active for {cooldown}"
| _ -> "")
|> Array.filter (System.String.IsNullOrWhiteSpace >> not)
|> List.filter (System.String.IsNullOrWhiteSpace >> not)
|> String.concat "\n"
let statusFormat p =
let hacks = Player.getHackEvents p
$"**Hacks:** {Inventory.filterByHacks p.Inventory |> battleItemFormat}\n
**Shields:** {Inventory.filterByShields p.Inventory |> battleItemFormat}\n
**Hack Attacks:**\n{ hacks |> Array.take (min hacks.Length 10) |> actionFormat}\n
**Hack Attacks:**\n{ hacks |> List.take (min hacks.Length 10) |> actionFormat}\n
**Active Shields:**\n{Player.getShieldEvents p |> actionFormat}"

24
Bot/GameTypes.fs
View File

@ -10,6 +10,13 @@ type mins
[<Measure>]
type GBT
type Range = { Min : int ; Max : int }
module Range =
let normalized = { Min = 0 ; Max = 100 }
let create min max = { Min = min ; Max = max }
let constrain value range = if value < range.Min then range.Min elif value > range.Max then range.Max else value
type ItemId =
| Virus = 0
| RemoteAccess = 1
@ -27,16 +34,16 @@ type StatId =
type StatConfig = {
Id : StatId
BaseDecayRate : float
BaseMinMax : Range
BaseRange : Range
}
type PlayerStat = {
Id : StatId
Amount : int
ModMinMax : Range
ModRange : Range
LastRead : DateTime
}
with static member empty = { Id = StatId.Strength ; Amount = 0 ; ModMinMax = Range(0, 100) ; LastRead = DateTime.UtcNow}
with static member empty = { Id = StatId.Strength ; Amount = 0 ; ModRange = Range.normalized ; LastRead = DateTime.UtcNow}
type Stats = {
Strength : PlayerStat
@ -101,14 +108,15 @@ type AccessoryItem = {
Name : string
Price : int<GBT>
TargetStat : StatId
PassiveBoost : int
FloorBoost : int
CeilBoost : int
}
type ItemType =
| Hack of power : int * hackClass : int * cooldown : int<mins>
| Shield of shieldClass : int * cooldown : int<mins>
| Food of targetStat : StatId * boostAmount : int
| Accessory of targetStat : StatId * passiveBoost : int
| Accessory of targetStat : StatId * floorBoost : int * ceilBoost : int
and Item = {
Id : int
Name : string
@ -120,18 +128,18 @@ and PlayerData = {
DiscordId : uint64
Name : string
Inventory : Inventory
Events : PlayerEvent array
Events : PlayerEvent list
Stats : Stats
Bank : int<GBT>
}
// Achievements : string array
// XP : int
with member this.basicPlayer = { Id = this.DiscordId ; Name = this.Name }
with member this.toDiscordPlayer = { Id = this.DiscordId ; Name = this.Name }
static member empty =
{ DiscordId = 0uL
Name = "None"
Inventory = []
Events = [||]
Events = []
Stats = Stats.empty
// Achievements = [||]
// XP = 0

18
Bot/Games/HackerBattle.fs
View File

@ -85,7 +85,7 @@ let updateCombatants successfulHack (attacker : PlayerData) (defender : PlayerDa
let event isDefenderEvent =
let hackEvent = {
HackId = hack.Id
Adversary = if isDefenderEvent then attacker.basicPlayer else defender.basicPlayer
Adversary = if isDefenderEvent then attacker.toDiscordPlayer else defender.toDiscordPlayer
IsInstigator = not isDefenderEvent
Success = successfulHack
}
@ -93,10 +93,10 @@ let updateCombatants successfulHack (attacker : PlayerData) (defender : PlayerDa
Timestamp = DateTime.UtcNow
Cooldown = if isDefenderEvent then int WeaponClass.SameTargetAttackCooldown.TotalMinutes * 1<mins> else hack.Cooldown }
[ DbService.updatePlayer GuildEnvironment.pgDb <| updatePlayer prize (event false) attacker
DbService.updatePlayer GuildEnvironment.pgDb <| updatePlayer -prize (event true) defender
DbService.addPlayerEvent GuildEnvironment.pgDb attacker.DiscordId (event false)
DbService.addPlayerEvent GuildEnvironment.pgDb defender.DiscordId (event true) ]
[ DbService.updatePlayer <| updatePlayer prize (event false) attacker
DbService.updatePlayer <| updatePlayer -prize (event true) defender
DbService.addPlayerEvent attacker.DiscordId (event false)
DbService.addPlayerEvent defender.DiscordId (event true) ]
|> Async.Parallel
|> Async.Ignore
@ -153,7 +153,7 @@ let handleAttack (ctx : IDiscordContext) =
let hack = Armory.weapons |> Inventory.findHackById hackId
let hackAsItem = Inventory.hackToItem hack
let resultId , targetId = UInt64.TryParse tokens.[2]
let! resultTarget = DbService.tryFindPlayer GuildEnvironment.pgDb targetId
let! resultTarget = DbService.tryFindPlayer targetId
match resultTarget , true , resultId with
| Some defender , true , true ->
@ -202,9 +202,9 @@ let handleDefense (ctx : IDiscordContext) =
Cooldown = shield.Cooldown
Timestamp = DateTime.UtcNow
}
do! DbService.updatePlayer GuildEnvironment.pgDb p
do! DbService.updatePlayer p
|> Async.Ignore
do! DbService.addPlayerEvent GuildEnvironment.pgDb p.DiscordId defense
do! DbService.addPlayerEvent p.DiscordId defense
|> Async.Ignore
let builder = DiscordMessageBuilder()
builder.WithContent($"{ctx.GetDiscordMember().Username} has protected their system!") |> ignore
@ -224,7 +224,7 @@ let arsenal (ctx : IDiscordContext) =
builder.AddEmbed(embed) |> ignore
builder.IsEphemeral <- true
do! ctx.FollowUp(builder) |> Async.AwaitTask
do! DbService.updatePlayer GuildEnvironment.pgDb updatedPlayer
do! DbService.updatePlayer updatedPlayer
|> Async.Ignore
})

4
Bot/Games/SlotMachine.fs
View File

@ -23,10 +23,10 @@ type SlotMachine() =
|| (results.[0] <> results.[1] && results.[1] <> results.[2] && results.[0] <> results.[2])
if winConditions then
do! DbService.updatePlayer GuildEnvironment.pgDb { player with Bank = player.Bank + 10<GBT> }
do! DbService.updatePlayer { player with Bank = player.Bank + 10<GBT> }
|> Async.Ignore
else
do! DbService.updatePlayer GuildEnvironment.pgDb { player with Bank = max (player.Bank - 1<GBT>) 0<GBT> }
do! DbService.updatePlayer { player with Bank = max (player.Bank - 1<GBT>) 0<GBT> }
|> Async.Ignore

6
Bot/Games/Store.fs
View File

@ -107,7 +107,7 @@ let handleBuyItem (ctx : IDiscordContext) itemId =
|> handleResultWithResponse ctx (fun player -> async {
let newBalance = player.Bank - item.Price
let p = { player with Bank = newBalance ; Inventory = item::player.Inventory }
do! DbService.updatePlayer GuildEnvironment.pgDb p |> Async.Ignore
do! DbService.updatePlayer p |> Async.Ignore
do! sendFollowUpMessage ctx $"Successfully purchased {item.Name}! You now have {newBalance} 💰$GBT remaining"
})
})
@ -125,8 +125,8 @@ let handleSell (ctx : IDiscordContext) itemId =
Inventory = player.Inventory |> List.filter (fun i -> i.Id <> itemId)
}
do!
[ DbService.updatePlayer GuildEnvironment.pgDb updatedPlayer |> Async.Ignore
DbService.removeShieldEvent GuildEnvironment.pgDb updatedPlayer.DiscordId itemId |> Async.Ignore
[ DbService.updatePlayer updatedPlayer |> Async.Ignore
DbService.removeShieldEvent updatedPlayer.DiscordId itemId |> Async.Ignore
sendFollowUpMessage ctx $"Sold {item.Type} {item.Name} for {item.Price}! Current Balance: {updatedPlayer.Bank}" ]
|> Async.Parallel
|> Async.Ignore

14
Bot/Games/Thief.fs
View File

@ -175,15 +175,15 @@ let handleSteal (ctx : IDiscordContext) =
| true ->
let embed = getResultEmbed' Success
do! Messaging.sendFollowUpEmbed ctx (embed.Build())
match! DbService.tryFindPlayer GuildEnvironment.pgDb targetId with
match! DbService.tryFindPlayer targetId with
| Some t ->
let mugged = {
Type = Stealing ( false , thief.basicPlayer )
Type = Stealing ( false , thief.toDiscordPlayer )
Timestamp = DateTime.UtcNow
Cooldown = VictimRecovery.Minutes * 1<mins>
}
do! DbService.updatePlayer GuildEnvironment.pgDb { t with Bank = max (t.Bank - prize) 0<GBT> } |> Async.Ignore
do! DbService.addPlayerEvent GuildEnvironment.pgDb victim.DiscordId mugged |> Async.Ignore
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 = {
@ -191,8 +191,8 @@ let handleSteal (ctx : IDiscordContext) =
Cooldown = ThiefCooldown.Minutes * 1<mins>
Timestamp = DateTime.UtcNow
}
do! DbService.updatePlayer GuildEnvironment.pgDb { thief with Bank = thief.Bank + prize } |> Async.Ignore
do! DbService.addPlayerEvent GuildEnvironment.pgDb victim.DiscordId stole |> Async.Ignore
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)
@ -206,7 +206,7 @@ let handleSteal (ctx : IDiscordContext) =
Cooldown = ThiefCooldown.Minutes * 1<mins>
Timestamp = DateTime.UtcNow
}
do! DbService.addPlayerEvent GuildEnvironment.pgDb victim.DiscordId imprisoned |> Async.Ignore
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)

12
Bot/Games/Trainer.fs
View File

@ -146,9 +146,9 @@ let handleHack (ctx : IDiscordContext) =
let sb = StringBuilder("Here, ")
let! completed = DbService.checkHasAchievement GuildEnvironment.pgDb player.DiscordId trainerAchievement
let! completed = DbService.checkHasAchievement player.DiscordId trainerAchievement
if not completed then
do! DbService.addAchievement GuildEnvironment.pgDb player.DiscordId trainerAchievement
do! DbService.addAchievement player.DiscordId trainerAchievement
|> Async.Ignore
sb.Append($"I'm going to gift you a hack,`{defaultHack.Name}` and a shield, `{defaultShield.Name}`") |> ignore
@ -180,15 +180,15 @@ let handleArsenal (ctx : IDiscordContext) =
Player.removeExpiredActions player
if not hasStockWeapons then
do!
[ DbService.addPlayerEvent GuildEnvironment.pgDb player.DiscordId TrainerEvents.[0]
DbService.addPlayerEvent GuildEnvironment.pgDb player.DiscordId TrainerEvents.[1]
DbService.updatePlayer GuildEnvironment.pgDb updatedPlayer ]
[ DbService.addPlayerEvent player.DiscordId TrainerEvents.[0]
DbService.addPlayerEvent player.DiscordId TrainerEvents.[1]
DbService.updatePlayer updatedPlayer ]
|> Async.Parallel
|> Async.Ignore
let embed = Embeds.getArsenalEmbed updatedPlayer
do! ctx.FollowUp(embed) |> Async.AwaitTask
let! completed = DbService.checkHasAchievement GuildEnvironment.pgDb player.DiscordId trainerAchievement
let! completed = DbService.checkHasAchievement player.DiscordId trainerAchievement
if not completed then
do! Async.Sleep 3000
let rewards = [ $"{defaultHack.Name} Hack" ; $"{defaultShield.Name} Shield" ]

2
Bot/GuildEnvironment.fs
View File

@ -11,7 +11,7 @@ DotEnv.Load(DotEnvOptions(envFilePaths = [ "../../../../.dev.env" ], overwriteEx
let getVar str = Environment.GetEnvironmentVariable(str)
let getId str = getVar str |> uint64
let pgDb = (getVar "DATABASE_URL").Replace("postgresql://", "postgres://").Replace("?sslmode=require", "")
let connectionString = (getVar "DATABASE_URL").Replace("postgresql://", "postgres://").Replace("?sslmode=require", "")
let guildId = getId "DISCORD_GUILD"
let tokenPlayerInteractions = getVar "TOKEN_PLAYER_INTERACTIONS"

10
Bot/PlayerInteractions.fs
View File

@ -10,7 +10,7 @@ let executePlayerAction (ctx : IDiscordContext) (dispatch : PlayerData -> Async<
async {
let builder = DiscordInteractionResponseBuilder().AsEphemeral(true)
do! ctx.Respond(InteractionResponseType.DeferredChannelMessageWithSource, builder) |> Async.AwaitTask
let! playerResult = tryFindPlayer GuildEnvironment.pgDb (ctx.GetDiscordMember().Id)
let! playerResult = tryFindPlayer (ctx.GetDiscordMember().Id)
match playerResult with
| Some player -> do! dispatch player
| None -> do! Messaging.sendFollowUpMessage ctx "You are currently not a hacker, first use the /redpill command to become one"
@ -23,8 +23,8 @@ let executePlayerActionWithTarget (targetPlayer : DiscordUser) (ctx : IDiscordCo
builder.Content <- "Content"
do! ctx.Respond(InteractionResponseType.DeferredChannelMessageWithSource, builder) |> Async.AwaitTask
let! players =
[ tryFindPlayer GuildEnvironment.pgDb (ctx.GetDiscordMember().Id)
tryFindPlayer GuildEnvironment.pgDb targetPlayer.Id ]
[ tryFindPlayer (ctx.GetDiscordMember().Id)
tryFindPlayer targetPlayer.Id ]
|> Async.Parallel
match players.[0] , players.[1] with
| Some player , Some target -> do! dispatch player target
@ -43,8 +43,8 @@ let executePlayerActionWithTargetId defer (targetId : uint64) (ctx : IDiscordCon
if defer then
do! ctx.Respond(InteractionResponseType.DeferredChannelMessageWithSource, builder) |> Async.AwaitTask
let! players =
[ tryFindPlayer GuildEnvironment.pgDb (ctx.GetDiscordMember().Id)
tryFindPlayer GuildEnvironment.pgDb targetId ]
[ tryFindPlayer (ctx.GetDiscordMember().Id)
tryFindPlayer targetId ]
|> Async.Parallel
match players.[0] , players.[1] with
| Some player , Some target -> do! dispatch player target