diff --git a/.gitignore b/.gitignore index 8df737a2..3b3780b5 100644 --- a/.gitignore +++ b/.gitignore @@ -30,6 +30,9 @@ bld/ [Oo]bj/ [Ll]og/ +# Rider specific +.idea + # Visual Studio 2015/2017 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot diff --git a/.idea/.idea.server-csharp/.idea/.gitignore b/.idea/.idea.server-csharp/.idea/.gitignore deleted file mode 100644 index be6be836..00000000 --- a/.idea/.idea.server-csharp/.idea/.gitignore +++ /dev/null @@ -1,13 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml -# Rider ignored files -/.idea.server-csharp.iml -/modules.xml -/projectSettingsUpdater.xml -/contentModel.xml -# Editor-based HTTP Client requests -/httpRequests/ -# Datasource local storage ignored files -/dataSources/ -/dataSources.local.xml diff --git a/.idea/.idea.server-csharp/.idea/encodings.xml b/.idea/.idea.server-csharp/.idea/encodings.xml deleted file mode 100644 index df87cf95..00000000 --- a/.idea/.idea.server-csharp/.idea/encodings.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/.idea.server-csharp/.idea/indexLayout.xml b/.idea/.idea.server-csharp/.idea/indexLayout.xml deleted file mode 100644 index 7b08163c..00000000 --- a/.idea/.idea.server-csharp/.idea/indexLayout.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/.idea.server-csharp/.idea/vcs.xml b/.idea/.idea.server-csharp/.idea/vcs.xml deleted file mode 100644 index 35eb1ddf..00000000 --- a/.idea/.idea.server-csharp/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/BotCallbacks.cs b/Core/Models/Spt/Callbacks/BotCallbacks.cs new file mode 100644 index 00000000..dda5ab92 --- /dev/null +++ b/Core/Models/Spt/Callbacks/BotCallbacks.cs @@ -0,0 +1,26 @@ +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Callbacks; + +public class BotCallbacks +{ + public string GetBotLimit(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetBotDifficulty(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> GenerateBots(string url, GenerateBotsRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetBotCap() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/BundleCallbacks.cs b/Core/Models/Spt/Callbacks/BundleCallbacks.cs new file mode 100644 index 00000000..17b23487 --- /dev/null +++ b/Core/Models/Spt/Callbacks/BundleCallbacks.cs @@ -0,0 +1,19 @@ +namespace Core.Models.Spt.Callbacks; + +public class BundleCallbacks +{ + public object SendBundle(string sessionID, object req, object res, object body) + { + throw new NotImplementedException(); + } + + public string GetBundles(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetBundle(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/CustomizationCallbacks.cs b/Core/Models/Spt/Callbacks/CustomizationCallbacks.cs new file mode 100644 index 00000000..cb33b642 --- /dev/null +++ b/Core/Models/Spt/Callbacks/CustomizationCallbacks.cs @@ -0,0 +1,24 @@ +namespace Core.Models.Spt.Callbacks; + +public class CustomizationCallbacks +{ + public GetBodyResponseData GetSuits(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> GetTraderSuits(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse WearClothing(PmcData pmcData, WearClothingRequestData body, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse BuyClothing(PmcData pmcData, BuyClothingRequestData body, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/DialogCallbacks.cs b/Core/Models/Spt/Callbacks/DialogCallbacks.cs new file mode 100644 index 00000000..1e2bd458 --- /dev/null +++ b/Core/Models/Spt/Callbacks/DialogCallbacks.cs @@ -0,0 +1,79 @@ +namespace Core.Models.Spt.Callbacks; + +public class DialogCallbacks +{ + public GetBodyResponseData GetFriendList(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> GetChatServerList(string url, GetChatServerListRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> GetMailDialogList(string url, GetMailDialogListRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetMailDialogView(string url, GetMailDialogViewRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetMailDialogInfo(string url, GetMailDialogInfoRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> RemoveDialog(string url, RemoveDialogRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> PinDialog(string url, PinDialogRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> UnpinDialog(string url, PinDialogRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> SetRead(string url, SetDialogReadRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetAllAttachments(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> ListOutbox(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> ListInbox(string url, EmptyRequestData info, string sessionID) + { + + } + + public NullResponseData SendFriendRequest(string url, FriendRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData SendMessage(string url, SendMessageRequest info, string sessionID) + { + throw new NotImplementedException(); + } + + public bool Update() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/GameCallbacks.cs b/Core/Models/Spt/Callbacks/GameCallbacks.cs new file mode 100644 index 00000000..36754b2c --- /dev/null +++ b/Core/Models/Spt/Callbacks/GameCallbacks.cs @@ -0,0 +1,44 @@ +namespace Core.Models.Spt.Callbacks; + +public class GameCallbacks +{ + public NullResponseData VersionValidata(string url, VersionValidaterequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GameStart(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GameLogout(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetGameConfig(string url, GameEmptyCrcRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetServer(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData ValidateGameVersion(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GameKeepalive(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetVersion(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/HandbookCallbacks.cs b/Core/Models/Spt/Callbacks/HandbookCallbacks.cs new file mode 100644 index 00000000..f58bb0a9 --- /dev/null +++ b/Core/Models/Spt/Callbacks/HandbookCallbacks.cs @@ -0,0 +1,9 @@ +namespace Core.Models.Spt.Callbacks; + +public class HandbookCallbacks +{ + public void Load() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/HealthCallbacks.cs b/Core/Models/Spt/Callbacks/HealthCallbacks.cs new file mode 100644 index 00000000..15ec2ded --- /dev/null +++ b/Core/Models/Spt/Callbacks/HealthCallbacks.cs @@ -0,0 +1,29 @@ +namespace Core.Models.Spt.Callbacks; + +public class HealthCallbacks +{ + public SptProfile OnLoad(string sessionID) + { + throw new NotImplementedException(); + } + + public object SyncHealth(string url, SyncHealthRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public object OffraidEat(PmcData pmcData, OffraidEatRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public object OffraidHeal(PmcData pmcData, OffraidHealRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public object HealthTreatment(PmcData pmcData, HealthTreatmentRequestData info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/HideoutCallbacks.cs b/Core/Models/Spt/Callbacks/HideoutCallbacks.cs new file mode 100644 index 00000000..d95efcd6 --- /dev/null +++ b/Core/Models/Spt/Callbacks/HideoutCallbacks.cs @@ -0,0 +1,54 @@ +namespace Core.Models.Spt.Callbacks; + +public class HideoutCallbacks +{ + public ItemEventRouterRepsonse Upgrade(PmcData pmcData, HideoutUpgraderequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse UpgradeComplete(PmcData pmcData, HideoutUpgradeCompleterequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse PutItemsInAreaSlots(PmcData pmcData, HideoutPutItemInRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse TakeItemsFromAreaSlots(PmcData pmcData, HideoutTakeItemOutRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse ToggleArea(PmcData pmcData, HideoutToggleAreaRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse SingleProductionStart(PmcData pmcData, HideoutSingleProductionStartRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse ScavCaseProductionStart(PmcData pmcData, HideoutScavCaseStartRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse ContinuousProductionStart(PmcData pmcData, HideoutContinuousProductionRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterRepsonse TakeProduction(PmcData pmcData, HideoutTakeProductionRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public bool Update(int timeSinceLastRun) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/HttpCallbacks.cs b/Core/Models/Spt/Callbacks/HttpCallbacks.cs new file mode 100644 index 00000000..42e2076a --- /dev/null +++ b/Core/Models/Spt/Callbacks/HttpCallbacks.cs @@ -0,0 +1,19 @@ +namespace Core.Models.Spt.Callbacks; + +public class HttpCallbacks +{ + public void Load() + { + throw new NotImplementedException(); + } + + public void SendImage(string sessionID, object req, object resp, object body) + { + throw new NotImplementedException(); + } + + public string GetImage() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/InsuranceCallbacks.cs b/Core/Models/Spt/Callbacks/InsuranceCallbacks.cs new file mode 100644 index 00000000..d8225f76 --- /dev/null +++ b/Core/Models/Spt/Callbacks/InsuranceCallbacks.cs @@ -0,0 +1,24 @@ +namespace Core.Models.Spt.Callbacks; + +public class InsuranceCallbacks +{ + public SptProfile OnLoad(string sessionID) + { + throw new NotImplementedException(); + } + + public object GetInsuranceCost(string url, GetInsuranceCostRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public object Insure(PmcData pmcData, InsureRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public bool Update(int secondsSinceLastRun) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/InventoryCallbacks.cs b/Core/Models/Spt/Callbacks/InventoryCallbacks.cs new file mode 100644 index 00000000..ce8d6f0d --- /dev/null +++ b/Core/Models/Spt/Callbacks/InventoryCallbacks.cs @@ -0,0 +1,84 @@ +namespace Core.Models.Spt.Callbacks; + +public class InventoryCallbacks +{ + public ItemEventRouterResponse MoveItem(PmcData pmcData, InventoryMoveRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse RemoveItem(PmcData pmcData, InventoryRemoveRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse SplitItem(PmcData pmcData, InventorySplitRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse MergeItem(PmcData pmcData, InventoryMergeRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse TransferItem(PmcData pmcData, InventoryTransferRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse SwapItem(PmcData pmcData, InventorySwapRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse FoldItem(PmcData pmcData, InventoryFoldRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse ToggleItem(PmcData pmcData, InventoryToggleRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse TagItem(PmcData pmcData, InventoryTagRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse BindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse ExamineItem(PmcData pmcData, InventoryExamineRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse ReadEncyclopedia(PmcData pmcData, InventoryReadEncyclopediaRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse SortInventory(PmcData pmcData, InventorySortRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse CreateMapMarker(PmcData pmcData, InventoryCreateMarkerRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse DeleteMapMarker(PmcData pmcData, InventoryDeleteMarkerRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse EditMapMarker(PmcData pmcData, InventoryEditMarkerRequestData info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/ItemEventCallbacks.cs b/Core/Models/Spt/Callbacks/ItemEventCallbacks.cs new file mode 100644 index 00000000..49549a5d --- /dev/null +++ b/Core/Models/Spt/Callbacks/ItemEventCallbacks.cs @@ -0,0 +1,9 @@ +namespace Core.Models.Spt.Callbacks; + +public class ItemEventCallbacks +{ + public GetBodyResponseData HandleEvents(string url, ItemEventRouterRequest info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/LauncherCallbacks.cs b/Core/Models/Spt/Callbacks/LauncherCallbacks.cs new file mode 100644 index 00000000..f7aac738 --- /dev/null +++ b/Core/Models/Spt/Callbacks/LauncherCallbacks.cs @@ -0,0 +1,69 @@ +namespace Core.Models.Spt.Callbacks; + +public class LauncherCallbacks +{ + public string Connect() + { + throw new NotImplementedException(); + } + + public string Login(string url, LoginRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string Register(string url, RegisterData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string Get(string url, LoginRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string ChangeUsername(string url, ChangeRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string ChangePassword(string url, ChangeRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string Wipe(string url, RegisterData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetMiniProfile(string url, GetMiniProfileRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetAllMiniProfiles(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetServerVersion() + { + throw new NotImplementedException(); + } + + public string Ping(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public string RemoveProfile(string url, RemoveProfileData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetCompatibleTarkovVersion() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/LocationCallbacks.cs b/Core/Models/Spt/Callbacks/LocationCallbacks.cs new file mode 100644 index 00000000..803df66d --- /dev/null +++ b/Core/Models/Spt/Callbacks/LocationCallbacks.cs @@ -0,0 +1,16 @@ +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Callbacks; + +public class LocationCallbacks +{ + public GetBodyResponseData GetLocationData(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData GetLocation(string url, GetLocationRequestData info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/ModCallbacks.cs b/Core/Models/Spt/Callbacks/ModCallbacks.cs new file mode 100644 index 00000000..211906f6 --- /dev/null +++ b/Core/Models/Spt/Callbacks/ModCallbacks.cs @@ -0,0 +1,24 @@ +namespace Core.Models.Spt.Callbacks; + +public class ModCallbacks +{ + public void Load() + { + throw new NotImplementedException(); + } + + public void SendBundle(string sessionID, object req, object resp, object body) + { + throw new NotImplementedException(); + } + + public string GetBundles(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public string GetBundle(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/NoteCallbacks.cs b/Core/Models/Spt/Callbacks/NoteCallbacks.cs new file mode 100644 index 00000000..920a0cde --- /dev/null +++ b/Core/Models/Spt/Callbacks/NoteCallbacks.cs @@ -0,0 +1,19 @@ +namespace Core.Models.Spt.Callbacks; + +public class NoteCallbacks +{ + public ItemEventRouterResponse AddNote(PmcData pmcData, NoteActionData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse EditNote(PmcData pmcData, NoteActionData info, string sessionID) + { + throw new NotImplementedException(); + } + + public ItemEventRouterResponse DeleteNote(PmcData pmcData, NoteActionData info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/NotifierCallbacks.cs b/Core/Models/Spt/Callbacks/NotifierCallbacks.cs new file mode 100644 index 00000000..d910aa65 --- /dev/null +++ b/Core/Models/Spt/Callbacks/NotifierCallbacks.cs @@ -0,0 +1,35 @@ +namespace Core.Models.Spt.Callbacks; + +public class NotifierCallbacks +{ + /** + * If we don't have anything to send, it's ok to not send anything back + * because notification requests can be long-polling. In fact, we SHOULD wait + * until we actually have something to send because otherwise we'd spam the client + * and the client would abort the connection due to spam. + */ + public void SendNotification(string sessionID, object req, object resp, object data) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData> GetNotifier(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData CreateNotifierChannel(string url, EmptyRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public GetBodyResponseData SelectProfile(string url, UIDRequestData info, string sessionID) + { + throw new NotImplementedException(); + } + + public string Notify(string url, object info, string sessionID) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/PresetBuildCallbacks.cs b/Core/Models/Spt/Callbacks/PresetBuildCallbacks.cs new file mode 100644 index 00000000..159679c1 --- /dev/null +++ b/Core/Models/Spt/Callbacks/PresetBuildCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class PresetBuildCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/PresetCallbacks.cs b/Core/Models/Spt/Callbacks/PresetCallbacks.cs new file mode 100644 index 00000000..2c211242 --- /dev/null +++ b/Core/Models/Spt/Callbacks/PresetCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class PresetCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/ProfileCallbacks.cs b/Core/Models/Spt/Callbacks/ProfileCallbacks.cs new file mode 100644 index 00000000..e6697cf9 --- /dev/null +++ b/Core/Models/Spt/Callbacks/ProfileCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class ProfileCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/QuestCallbacks.cs b/Core/Models/Spt/Callbacks/QuestCallbacks.cs new file mode 100644 index 00000000..5f15f1b9 --- /dev/null +++ b/Core/Models/Spt/Callbacks/QuestCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class QuestCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/RagfairCallbacks.cs b/Core/Models/Spt/Callbacks/RagfairCallbacks.cs new file mode 100644 index 00000000..4e66d22a --- /dev/null +++ b/Core/Models/Spt/Callbacks/RagfairCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class RagfairCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/RepairCallbacks.cs b/Core/Models/Spt/Callbacks/RepairCallbacks.cs new file mode 100644 index 00000000..fec72c83 --- /dev/null +++ b/Core/Models/Spt/Callbacks/RepairCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class RepairCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/SaveCallbacks.cs b/Core/Models/Spt/Callbacks/SaveCallbacks.cs new file mode 100644 index 00000000..4393c0ce --- /dev/null +++ b/Core/Models/Spt/Callbacks/SaveCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class SaveCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/TradeCallbacks.cs b/Core/Models/Spt/Callbacks/TradeCallbacks.cs new file mode 100644 index 00000000..e2b64f97 --- /dev/null +++ b/Core/Models/Spt/Callbacks/TradeCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class TradeCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/TraderCallbacks.cs b/Core/Models/Spt/Callbacks/TraderCallbacks.cs new file mode 100644 index 00000000..6ac98d74 --- /dev/null +++ b/Core/Models/Spt/Callbacks/TraderCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class TraderCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Callbacks/WeatherCallbacks.cs b/Core/Models/Spt/Callbacks/WeatherCallbacks.cs new file mode 100644 index 00000000..fabf3385 --- /dev/null +++ b/Core/Models/Spt/Callbacks/WeatherCallbacks.cs @@ -0,0 +1,6 @@ +namespace Core.Models.Spt.Callbacks; + +public class WeatherCallbacks +{ + +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/AirdropConfig.cs b/Core/Models/Spt/Config/AirdropConfig.cs new file mode 100644 index 00000000..51d95197 --- /dev/null +++ b/Core/Models/Spt/Config/AirdropConfig.cs @@ -0,0 +1,128 @@ +using System.Collections.Generic; +using System.Text.Json.Serialization; +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +public class AirdropConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-airdrop"; + + [JsonPropertyName("airdropTypeWeightings")] + public Dictionary AirdropTypeWeightings { get; set; } + + /// + /// What rewards will the loot crate contain, keyed by drop type e.g. mixed/weaponArmor/foodMedical/barter + /// + [JsonPropertyName("loot")] + public Dictionary Loot { get; set; } + + [JsonPropertyName("customAirdropMapping")] + public Dictionary CustomAirdropMapping { get; set; } +} + +/// +/// Chance map will have an airdrop occur out of 100 - locations not included count as 0% +/// +public class AirdropChancePercent +{ + [JsonPropertyName("bigmap")] + public double Bigmap { get; set; } + + [JsonPropertyName("woods")] + public double Woods { get; set; } + + [JsonPropertyName("lighthouse")] + public double Lighthouse { get; set; } + + [JsonPropertyName("shoreline")] + public double Shoreline { get; set; } + + [JsonPropertyName("interchange")] + public double Interchange { get; set; } + + [JsonPropertyName("reserve")] + public double Reserve { get; set; } + + [JsonPropertyName("tarkovStreets")] + public double TarkovStreets { get; set; } + + [JsonPropertyName("sandbox")] + public double Sandbox { get; set; } +} + +/// +/// Loot inside crate +/// +public class AirdropLoot +{ + [JsonPropertyName("Icon")] + public AirdropTypeEnum Icon { get; set; } + + /// + /// Min/max of weapons inside crate + /// + [JsonPropertyName("weaponPresetCount")] + public MinMax? WeaponPresetCount { get; set; } + + /// + /// Min/max of armors (head/chest/rig) inside crate + /// + [JsonPropertyName("armorPresetCount")] + public MinMax? ArmorPresetCount { get; set; } + + /// + /// Min/max of items inside crate + /// + [JsonPropertyName("itemCount")] + public MinMax ItemCount { get; set; } + + /// + /// Min/max of sealed weapon boxes inside crate + /// + [JsonPropertyName("weaponCrateCount")] + public MinMax WeaponCrateCount { get; set; } + + /// + /// Items to never allow - tpls + /// + [JsonPropertyName("itemBlacklist")] + public List ItemBlacklist { get; set; } + + /// + /// Item type (parentId) to allow inside crate + /// + [JsonPropertyName("itemTypeWhitelist")] + public List ItemTypeWhitelist { get; set; } + + /// + /// Item type/ item tpls to limit count of inside crate - key: item base type: value: max count + /// + [JsonPropertyName("itemLimits")] + public Dictionary ItemLimits { get; set; } + + /// + /// Items to limit stack size of key: item tpl value: min/max stack size + /// + [JsonPropertyName("itemStackLimits")] + public Dictionary ItemStackLimits { get; set; } + + /// + /// Armor levels to allow inside crate e.g. [4,5,6] + /// + [JsonPropertyName("armorLevelWhitelist")] + public List? ArmorLevelWhitelist { get; set; } + + /// + /// Should boss items be added to airdrop crate + /// + [JsonPropertyName("allowBossItems")] + public bool AllowBossItems { get; set; } + + [JsonPropertyName("useForcedLoot")] + public bool? UseForcedLoot { get; set; } + + [JsonPropertyName("forcedLoot")] + public Dictionary? ForcedLoot { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/BackupConfig.cs b/Core/Models/Spt/Config/BackupConfig.cs new file mode 100644 index 00000000..7bd6b324 --- /dev/null +++ b/Core/Models/Spt/Config/BackupConfig.cs @@ -0,0 +1,30 @@ +namespace Core.Models.Spt.Config; + +using System.Text.Json.Serialization; + +public class BackupConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-backup"; + + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("maxBackups")] + public int MaxBackups { get; set; } + + [JsonPropertyName("directory")] + public string Directory { get; set; } + + [JsonPropertyName("backupInterval")] + public BackupConfigInterval BackupInterval { get; set; } +} + +public class BackupConfigInterval +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("intervalMinutes")] + public int IntervalMinutes { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/BaseConfig.cs b/Core/Models/Spt/Config/BaseConfig.cs new file mode 100644 index 00000000..b5138c9a --- /dev/null +++ b/Core/Models/Spt/Config/BaseConfig.cs @@ -0,0 +1,18 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } +} + +public class RunIntervalValues +{ + [JsonPropertyName("inRaid")] + public int InRaid { get; set; } + + [JsonPropertyName("outOfRaid")] + public int OutOfRaid { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/BotConfig.cs b/Core/Models/Spt/Config/BotConfig.cs new file mode 100644 index 00000000..45a9e31d --- /dev/null +++ b/Core/Models/Spt/Config/BotConfig.cs @@ -0,0 +1,525 @@ +using System.Collections.Generic; +using System.Text.Json.Serialization; +using Core.Models.Common; +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Config; + +public class BotConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-bot"; + + /** How many variants of each bot should be generated on raid start */ + [JsonPropertyName("presetBatch")] + public PresetBatch PresetBatch { get; set; } + + /** Bot roles that should not have PMC types (pmcBEAR/pmcUSEC) added as enemies to */ + [JsonPropertyName("botsToNotAddPMCsAsEnemiesTo")] + public List BotsToNotAddPMCsAsEnemiesTo { get; set; } + + /** What bot types should be classified as bosses */ + [JsonPropertyName("bosses")] + public List Bosses { get; set; } + + /** Control weapon/armor durability min/max values for each bot type */ + [JsonPropertyName("durability")] + public BotDurability Durability { get; set; } + + /** Controls the percentage values of randomization item resources */ + [JsonPropertyName("lootItemResourceRandomization")] + public Dictionary LootItemResourceRandomization { get; set; } + + /** Control what bots are added to a bots revenge list key: bottype, value: bottypes to revenge on seeing their death */ + [JsonPropertyName("revenge")] + public Dictionary> Revenge { get; set; } + + /** Control how many items are allowed to spawn on a bot + * key: bottype, value: */ + [JsonPropertyName("itemSpawnLimits")] + public Dictionary> ItemSpawnLimits { get; set; } + + /** Blacklist/whitelist items on a bot */ + [JsonPropertyName("equipment")] + public Dictionary Equipment { get; set; } + + /** Show a bots botType value after their name */ + [JsonPropertyName("showTypeInNickname")] + public bool ShowTypeInNickname { get; set; } + + /** What ai brain should a normal scav use per map */ + [JsonPropertyName("assaultBrainType")] + public Dictionary> AssaultBrainType { get; set; } + + /** What ai brain should a player scav use per map */ + [JsonPropertyName("playerScavBrainType")] + public Dictionary> PlayerScavBrainType { get; set; } + + /** Max number of bots that can be spawned in a raid at any one time */ + [JsonPropertyName("maxBotCap")] + public Dictionary MaxBotCap { get; set; } + + /** Chance scav has fake pscav name e.g. Scav name (player name) */ + [JsonPropertyName("chanceAssaultScavHasPlayerScavName")] + public int ChanceAssaultScavHasPlayerScavName { get; set; } + + /** How many stacks of secret ammo should a bot have in its bot secure container */ + [JsonPropertyName("secureContainerAmmoStackCount")] + public int SecureContainerAmmoStackCount { get; set; } + + /** Bot roles in this array will be given a dog tag on generation */ + [JsonPropertyName("botRolesWithDogTags")] + public List BotRolesWithDogTags { get; set; } + + /** Settings to control the items that get added into wallets on bots */ + [JsonPropertyName("walletLoot")] + public WalletLootSettings WalletLoot { get; set; } + + /** Currency weights, Keyed by botrole / currency */ + [JsonPropertyName("currencyStackSize")] + public Dictionary>> CurrencyStackSize { get; set; } + + /** Tpls for low profile gas blocks */ + [JsonPropertyName("lowProfileGasBlockTpls")] + public List LowProfileGasBlockTpls { get; set; } + + /** What bottypes should be excluded from having loot generated on them (backpack/pocket/vest) does not disable food/drink/special/ */ + [JsonPropertyName("disableLootOnBotTypes")] + public List DisableLootOnBotTypes { get; set; } + + [JsonPropertyName("assaultToBossConversion")] + public AssaultToBossConversion AssaultToBossConversion { get; set; } + + /** Max length a bots name can be */ + [JsonPropertyName("botNameLengthLimit")] + public int BotNameLengthLimit { get; set; } + + /** Bot roles that must have a unique name when generated vs other bots in raid */ + [JsonPropertyName("botRolesThatMustHaveUniqueName")] + public List BotRolesThatMustHaveUniqueName { get; set; } +} + +public class AssaultToBossConversion +{ + [JsonPropertyName("bossConvertEnabled")] + public bool BossConvertEnabled { get; set; } + + [JsonPropertyName("bossesToConvertToWeights")] + public Dictionary BossesToConvertToWeights { get; set; } + + [JsonPropertyName("bossConvertMinMax")] + public Dictionary BossConvertMinMax { get; set; } +} + +/** Number of bots to generate and store in cache on raid start per bot type */ +public class PresetBatch +{ + [JsonPropertyName("assault")] + public int Assault { get; set; } + + [JsonPropertyName("bossBully")] + public int BossBully { get; set; } + + [JsonPropertyName("bossGluhar")] + public int BossGluhar { get; set; } + + [JsonPropertyName("bossKilla")] + public int BossKilla { get; set; } + + [JsonPropertyName("bossKojaniy")] + public int BossKojaniy { get; set; } + + [JsonPropertyName("bossSanitar")] + public int BossSanitar { get; set; } + + [JsonPropertyName("bossTagilla")] + public int BossTagilla { get; set; } + + [JsonPropertyName("bossKnight")] + public int BossKnight { get; set; } + + [JsonPropertyName("bossTest")] + public int BossTest { get; set; } + + [JsonPropertyName("cursedAssault")] + public int CursedAssault { get; set; } + + [JsonPropertyName("followerBully")] + public int FollowerBully { get; set; } + + [JsonPropertyName("followerGluharAssault")] + public int FollowerGluharAssault { get; set; } + + [JsonPropertyName("followerGluharScout")] + public int FollowerGluharScout { get; set; } + + [JsonPropertyName("followerGluharSecurity")] + public int FollowerGluharSecurity { get; set; } + + [JsonPropertyName("followerGluharSnipe")] + public int FollowerGluharSnipe { get; set; } + + [JsonPropertyName("followerKojaniy")] + public int FollowerKojaniy { get; set; } + + [JsonPropertyName("followerSanitar")] + public int FollowerSanitar { get; set; } + + [JsonPropertyName("followerTagilla")] + public int FollowerTagilla { get; set; } + + [JsonPropertyName("followerBirdEye")] + public int FollowerBirdEye { get; set; } + + [JsonPropertyName("followerBigPipe")] + public int FollowerBigPipe { get; set; } + + [JsonPropertyName("followerTest")] + public int FollowerTest { get; set; } + + [JsonPropertyName("followerBoar")] + public int FollowerBoar { get; set; } + + [JsonPropertyName("marksman")] + public int Marksman { get; set; } + + [JsonPropertyName("pmcBot")] + public int PmcBot { get; set; } + + [JsonPropertyName("sectantPriest")] + public int SectantPriest { get; set; } + + [JsonPropertyName("sectantWarrior")] + public int SectantWarrior { get; set; } + + [JsonPropertyName("gifter")] + public int Gifter { get; set; } + + [JsonPropertyName("test")] + public int Test { get; set; } + + [JsonPropertyName("exUsec")] + public int ExUsec { get; set; } + + [JsonPropertyName("arenaFighterEvent")] + public int ArenaFighterEvent { get; set; } + + [JsonPropertyName("arenaFighter")] + public int ArenaFighter { get; set; } + + [JsonPropertyName("crazyAssaultEvent")] + public int CrazyAssaultEvent { get; set; } + + [JsonPropertyName("bossBoar")] + public int BossBoar { get; set; } + + [JsonPropertyName("bossBoarSniper")] + public int BossBoarSniper { get; set; } + + [JsonPropertyName("pmcUSEC")] + public int PmcUSEC { get; set; } + + [JsonPropertyName("pmcBEAR")] + public int PmcBEAR { get; set; } +} + +public class WalletLootSettings +{ + /// + /// Chance wallets have loot in them + /// + [JsonPropertyName("chancePercent")] + public float ChancePercent { get; set; } + + [JsonPropertyName("itemCount")] + public MinMax ItemCount { get; set; } + + [JsonPropertyName("stackSizeWeight")] + public Dictionary StackSizeWeight { get; set; } + + [JsonPropertyName("currencyWeight")] + public Dictionary CurrencyWeight { get; set; } + + /// + /// What wallets will have money in them + /// + [JsonPropertyName("walletTplPool")] + public List WalletTplPool { get; set; } +} + +public class EquipmentFilters +{ + /// + /// Limits for mod types per weapon .e.g. scopes + /// + [JsonPropertyName("weaponModLimits")] + public ModLimits WeaponModLimits { get; set; } + + /// + /// Whitelist for weapon sight types allowed per gun + /// + [JsonPropertyName("weaponSightWhitelist")] + public Dictionary> WeaponSightWhitelist { get; set; } + + /// + /// Chance face shield is down/active + /// + [JsonPropertyName("faceShieldIsActiveChancePercent")] + public float? FaceShieldIsActiveChancePercent { get; set; } + + /// + /// Chance gun flashlight is active during the day + /// + [JsonPropertyName("lightIsActiveDayChancePercent")] + public float? LightIsActiveDayChancePercent { get; set; } + + /// + /// Chance gun flashlight is active during the night + /// + [JsonPropertyName("lightIsActiveNightChancePercent")] + public float? LightIsActiveNightChancePercent { get; set; } + + /// + /// Chance gun laser is active during the day + /// + [JsonPropertyName("laserIsActiveChancePercent")] + public float? LaserIsActiveChancePercent { get; set; } + + /// + /// Chance NODS are down/active during the day + /// + [JsonPropertyName("NvgIsActiveChanceDayPercent")] + public float? NvgIsActiveChanceDayPercent { get; set; } + + /// + /// Chance NODS are down/active during the night + /// + [JsonPropertyName("nvgIsActiveChanceNightPercent")] + public float? NvgIsActiveChanceNightPercent { get; set; } + + [JsonPropertyName("forceOnlyArmoredRigWhenNoArmor")] + public bool? ForceOnlyArmoredRigWhenNoArmor { get; set; } + + /// + /// Should plates be filtered by level + /// + [JsonPropertyName("filterPlatesByLevel")] + public bool? FilterPlatesByLevel { get; set; } + + /// + /// What additional slot ids should be seen as required when choosing a mod to add to a weapon + /// + [JsonPropertyName("weaponSlotIdsToMakeRequired")] + public List? WeaponSlotIdsToMakeRequired { get; set; } + + /// + /// Adjust weighting/chances of items on bot by level of bot + /// + [JsonPropertyName("randomisation")] + public List Randomisation { get; set; } + + /// + /// Blacklist equipment by level of bot + /// + [JsonPropertyName("blacklist")] + public List Blacklist { get; set; } + + /// + /// Whitelist equipment by level of bot + /// + [JsonPropertyName("whitelist")] + public List Whitelist { get; set; } + + /// + /// Adjust equipment/ammo + /// + [JsonPropertyName("weightingAdjustmentsByBotLevel")] + public List WeightingAdjustmentsByBotLevel { get; set; } + + /// + /// Same as weightingAdjustments but based on player level instead of bot level + /// + [JsonPropertyName("weightingAdjustmentsByPlayerLevel")] + public List? WeightingAdjustmentsByPlayerLevel { get; set; } + + /// + /// Should the stock mod be forced to spawn on bot + /// + [JsonPropertyName("forceStock")] + public bool? ForceStock { get; set; } + + [JsonPropertyName("armorPlateWeighting")] + public List? ArmorPlateWeighting { get; set; } + + [JsonPropertyName("forceRigWhenNoVest")] + public bool? ForceRigWhenNoVest { get; set; } +} + +public class ModLimits +{ + /// + /// How many scopes are allowed on a weapon - hard coded to work with OPTIC_SCOPE, ASSAULT_SCOPE, COLLIMATOR, COMPACT_COLLIMATOR + /// + [JsonPropertyName("scopeLimit")] + public int? ScopeLimit { get; set; } + + /// + /// How many lasers or lights are allowed on a weapon - hard coded to work with TACTICAL_COMBO, and FLASHLIGHT + /// + [JsonPropertyName("lightLaserLimit")] + public int? LightLaserLimit { get; set; } +} + +public class RandomisationDetails +{ + /// + /// Between what levels do these randomisation setting apply to + /// + [JsonPropertyName("levelRange")] + public MinMax LevelRange { get; set; } + + [JsonPropertyName("generation")] + public Dictionary? Generation { get; set; } + + /// + /// Mod slots that should be fully randomised -ignores mods from bottype.json and instead creates a pool using items.json + /// + [JsonPropertyName("randomisedWeaponModSlots")] + public List? RandomisedWeaponModSlots { get; set; } + + /// + /// Armor slots that should be randomised e.g. 'Headwear, Armband' + /// + [JsonPropertyName("randomisedArmorSlots")] + public List? RandomisedArmorSlots { get; set; } + + /// + /// Equipment chances + /// + [JsonPropertyName("equipment")] + public Dictionary? Equipment { get; set; } + + /// + /// Weapon mod chances + /// + [JsonPropertyName("weaponMods")] + public Dictionary? WeaponMods { get; set; } + + /// + /// Equipment mod chances + /// + [JsonPropertyName("equipmentMods")] + public Dictionary? EquipmentMods { get; set; } + + [JsonPropertyName("nighttimeChanges")] + public NighttimeChanges? NighttimeChanges { get; set; } + + /// + /// Key = weapon tpl, value = min size of magazine allowed + /// + [JsonPropertyName("minimumMagazineSize")] + public Dictionary? MinimumMagazineSize { get; set; } +} + +public class NighttimeChanges +{ + /// + /// Applies changes to values stored in equipmentMods + /// + [JsonPropertyName("equipmentModsModifiers")] + public Dictionary EquipmentModsModifiers { get; set; } + //public Dictionary WeaponModsModifiers { get; set; } //TODO +} + +public class EquipmentFilterDetails +{ + /// + /// Between what levels do these equipment filter setting apply to + /// + [JsonPropertyName("levelRange")] + public MinMax LevelRange { get; set; } + + /// + /// Key: mod slot name e.g. mod_magazine, value: item tpls + /// + [JsonPropertyName("equipment")] + public Dictionary>? Equipment { get; set; } + + /// + /// Key: equipment slot name e.g. FirstPrimaryWeapon, value: item tpls + /// + [JsonPropertyName("gear")] + public Dictionary>? Gear { get; set; } + + /// + /// Key: cartridge type e.g. Caliber23x75, value: item tpls + /// + [JsonPropertyName("cartridge")] + public Dictionary>? Cartridge { get; set; } +} + +public class WeightingAdjustmentDetails +{ + /// + /// Between what levels do these weight settings apply to + /// + [JsonPropertyName("levelRange")] + public MinMax LevelRange { get; set; } + + /// + /// Key: ammo type e.g. Caliber556x45NATO, value: item tpl + weight + /// + [JsonPropertyName("ammo")] + public AdjustmentDetails? Ammo { get; set; } + + /// + /// Key: equipment slot e.g. TacticalVest, value: item tpl + weight + /// + [JsonPropertyName("equipment")] + public AdjustmentDetails? Equipment { get; set; } + + /// + /// Key: clothing slot e.g. feet, value: item tpl + weight + /// + [JsonPropertyName("clothing")] + public AdjustmentDetails? Clothing { get; set; } +} + +public class AdjustmentDetails +{ + [JsonPropertyName("add")] + public Dictionary> Add { get; set; } + + [JsonPropertyName("edit")] + public Dictionary> Edit { get; set; } +} + +public class ArmorPlateWeights : Dictionary +{ + [JsonPropertyName("levelRange")] + public MinMax LevelRange { get; set; } +} + +public class RandomisedResourceDetails +{ + [JsonPropertyName("food")] + public RandomisedResourceValues Food { get; set; } + + [JsonPropertyName("meds")] + public RandomisedResourceValues Meds { get; set; } +} + +public class RandomisedResourceValues +{ + /// + /// Minimum percent of item to randomized between min and max resource + /// + [JsonPropertyName("resourcePercent")] + public float ResourcePercent { get; set; } + + /// + /// Chance for randomization to not occur + /// + [JsonPropertyName("chanceMaxResourcePercent")] + public float ChanceMaxResourcePercent { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/BotDurability.cs b/Core/Models/Spt/Config/BotDurability.cs new file mode 100644 index 00000000..f6c06dd8 --- /dev/null +++ b/Core/Models/Spt/Config/BotDurability.cs @@ -0,0 +1,115 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class BotDurability +{ + [JsonPropertyName("default")] + public DefaultDurability Default { get; set; } + + [JsonPropertyName("pmc")] + public PmcDurability Pmc { get; set; } + + [JsonPropertyName("boss")] + public BotDurability Boss { get; set; } + + [JsonPropertyName("follower")] + public BotDurability Follower { get; set; } + + [JsonPropertyName("assault")] + public BotDurability Assault { get; set; } + + [JsonPropertyName("cursedassault")] + public BotDurability CursedAssault { get; set; } + + [JsonPropertyName("marksman")] + public BotDurability Marksman { get; set; } + + [JsonPropertyName("pmcbot")] + public BotDurability PmcBot { get; set; } + + [JsonPropertyName("arenafighterevent")] + public BotDurability ArenaFighterEvent { get; set; } + + [JsonPropertyName("arenafighter")] + public BotDurability ArenaFighter { get; set; } + + [JsonPropertyName("crazyassaultevent")] + public BotDurability CrazyAssaultEvent { get; set; } + + [JsonPropertyName("exusec")] + public BotDurability Exusec { get; set; } + + [JsonPropertyName("gifter")] + public BotDurability Gifter { get; set; } + + [JsonPropertyName("sectantpriest")] + public BotDurability SectantPriest { get; set; } + + [JsonPropertyName("sectantwarrior")] + public BotDurability SectantWarrior { get; set; } +} + +/** Durability values to be used when a more specific bot type can't be found */ +public class DefaultDurability +{ + [JsonPropertyName("armor")] + public ArmorDurability Armor { get; set; } + + [JsonPropertyName("weapon")] + public WeaponDurability Weapon { get; set; } +} + +public class PmcDurability +{ + [JsonPropertyName("armor")] + public PmcDurabilityArmor Armor { get; set; } + + [JsonPropertyName("weapon")] + public WeaponDurability Weapon { get; set; } +} + +public class PmcDurabilityArmor +{ + [JsonPropertyName("lowestMaxPercent")] + public double LowestMaxPercent { get; set; } + + [JsonPropertyName("highestMaxPercent")] + public double HighestMaxPercent { get; set; } + + [JsonPropertyName("maxDelta")] + public double MaxDelta { get; set; } + + [JsonPropertyName("minDelta")] + public double MinDelta { get; set; } +} + +public class ArmorDurability +{ + [JsonPropertyName("maxDelta")] + public double MaxDelta { get; set; } + + [JsonPropertyName("minDelta")] + public double MinDelta { get; set; } + + [JsonPropertyName("minLimitPercent")] + public double MinLimitPercent { get; set; } +} + +public class WeaponDurability +{ + [JsonPropertyName("lowestMax")] + public double LowestMax { get; set; } + + [JsonPropertyName("highestMax")] + public double HighestMax { get; set; } + + [JsonPropertyName("maxDelta")] + public double MaxDelta { get; set; } + + [JsonPropertyName("minDelta")] + public double MinDelta { get; set; } + + [JsonPropertyName("minLimitPercent")] + public double MinLimitPercent { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/CoreConfig.cs b/Core/Models/Spt/Config/CoreConfig.cs new file mode 100644 index 00000000..44b3531f --- /dev/null +++ b/Core/Models/Spt/Config/CoreConfig.cs @@ -0,0 +1,197 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class CoreConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-core"; + + [JsonPropertyName("sptVersion")] + public string SptVersion { get; set; } + + [JsonPropertyName("projectName")] + public string ProjectName { get; set; } + + [JsonPropertyName("compatibleTarkovVersion")] + public string CompatibleTarkovVersion { get; set; } + + [JsonPropertyName("serverName")] + public string ServerName { get; set; } + + [JsonPropertyName("profileSaveIntervalSeconds")] + public int ProfileSaveIntervalInSeconds { get; set; } + + [JsonPropertyName("sptFriendNickname")] + public string SptFriendNickname { get; set; } + + [JsonPropertyName("allowProfileWipe")] + public bool AllowProfileWipe { get; set; } + + [JsonPropertyName("bsgLogging")] + public BsgLogging BsgLogging { get; set; } + + [JsonPropertyName("release")] + public Release Release { get; set; } + + [JsonPropertyName("fixes")] + public GameFixes Fixes { get; set; } + + [JsonPropertyName("survey")] + public SurveyResponseData Survey { get; set; } + + [JsonPropertyName("features")] + public ServerFeatures Features { get; set; } + + /** Commit hash build server was created from */ + [JsonPropertyName("commit")] + public string? Commit { get; set; } + + /** Timestamp of server build */ + [JsonPropertyName("buildTime")] + public string? BuildTime { get; set; } + + /** Server locale keys that will be added to the bottom of the startup watermark */ + [JsonPropertyName("customWatermarkLocaleKeys")] + public List? CustomWatermarkLocaleKeys { get; set; } +} + +public class BsgLogging +{ + /** + * verbosity of what to log, yes I know this is backwards, but its how nlog deals with ordinals. + * complain to them about it! In all cases, better exceptions will be logged. + * WARNING: trace-info logging will quickly create log files in the megabytes. + * 0 - trace + * 1 - debug + * 2 - info + * 3 - warn + * 4 - error + * 5 - fatal + * 6 - off + */ + [JsonPropertyName("verbosity")] + public int Verbosity { get; set; } + + // Should we send the logging to the server + [JsonPropertyName("sendToServer")] + public bool SendToServer { get; set; } +} + +public class Release +{ + // Disclaimer outlining the intended usage of bleeding edge + [JsonPropertyName("betaDisclaimerText")] + public string? BetaDisclaimerText { get; set; } + + // Text logged when users agreed to terms + [JsonPropertyName("betaDisclaimerAcceptText")] + public string BetaDisclaimerAcceptText { get; set; } + + // Server mods loaded message + [JsonPropertyName("serverModsLoadedText")] + public string ServerModsLoadedText { get; set; } + + // Server mods loaded debug message text + [JsonPropertyName("serverModsLoadedDebugText")] + public string ServerModsLoadedDebugText { get; set; } + + // Client mods loaded message + [JsonPropertyName("clientModsLoadedText")] + public string ClientModsLoadedText { get; set; } + + // Client mods loaded debug message text + [JsonPropertyName("clientModsLoadedDebugText")] + public string ClientModsLoadedDebugText { get; set; } + + // Illegal plugins log message + [JsonPropertyName("illegalPluginsLoadedText")] + public string IllegalPluginsLoadedText { get; set; } + + // Illegal plugins exception + [JsonPropertyName("illegalPluginsExceptionText")] + public string IllegalPluginsExceptionText { get; set; } + + // Summary of release changes + [JsonPropertyName("releaseSummaryText")] + public string? ReleaseSummaryText { get; set; } + + // Enables the cool watermark in-game + [JsonPropertyName("isBeta")] + public bool? IsBeta { get; set; } + + // Whether mods are enabled + [JsonPropertyName("isModdable")] + public bool? IsModdable { get; set; } + + // Are mods loaded on the server? + [JsonPropertyName("isModded")] + public bool IsModded { get; set; } + + // How long before the messagebox times out and closes the game + [JsonPropertyName("betaDisclaimerTimeoutDelay")] + public int BetaDisclaimerTimeoutDelay { get; set; } +} + +public class GameFixes +{ + /** Shotguns use a different value than normal guns causing huge pellet dispersion */ + [JsonPropertyName("fixShotgunDispersion")] + public bool FixShotgunDispersion { get; set; } + + /** Remove items added by mods when the mod no longer exists - can fix dead profiles stuck at game load */ + [JsonPropertyName("removeModItemsFromProfile")] + public bool RemoveModItemsFromProfile { get; set; } + + /** Remove invalid traders from profile - trader data can be leftover when player removes trader mod */ + [JsonPropertyName("removeInvalidTradersFromProfile")] + public bool RemoveInvalidTradersFromProfile { get; set; } + + /** Fix issues that cause the game to not start due to inventory item issues */ + [JsonPropertyName("fixProfileBreakingInventoryItemIssues")] + public bool FixProfileBreakingInventoryItemIssues { get; set; } +} + +public class ServerFeatures +{ + /* Controls whether or not the server attempts to download mod dependencies not included in the server's executable */ + [JsonPropertyName("autoInstallModDependencies")] + public bool AutoInstallModDependencies { get; set; } + + [JsonPropertyName("compressProfile")] + public bool CompressProfile { get; set; } + + [JsonPropertyName("chatbotFeatures")] + public ChatbotFeatures ChatbotFeatures { get; set; } + + /** Keyed to profile type e.g. "Standard" or "SPT Developer" */ + [JsonPropertyName("createNewProfileTypesBlacklist")] + public List CreateNewProfileTypesBlacklist { get; set; } +} + +public class ChatbotFeatures +{ + [JsonPropertyName("sptFriendEnabled")] + public bool SptFriendEnabled { get; set; } + + [JsonPropertyName("sptFriendGiftsEnabled")] + public bool SptFriendGiftsEnabled { get; set; } + + [JsonPropertyName("commandoEnabled")] + public bool CommandoEnabled { get; set; } + + [JsonPropertyName("commandoFeatures")] + public CommandoFeatures CommandoFeatures { get; set; } + + [JsonPropertyName("commandUseLimits")] + public Dictionary CommandUseLimits { get; set; } + + [JsonPropertyName("ids")] + public Dictionary Ids { get; set; } +} + +public class CommandoFeatures +{ + [JsonPropertyName("giveCommandEnabled")] + public bool GiveCommandEnabled { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/GiftsConfig.cs b/Core/Models/Spt/Config/GiftsConfig.cs new file mode 100644 index 00000000..5a0d300d --- /dev/null +++ b/Core/Models/Spt/Config/GiftsConfig.cs @@ -0,0 +1,65 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common.Tables; +using Core.Models.Spt.Dialog; + +namespace Core.Models.Spt.Config; + +public class Gift +{ + /// + /// Items to send to player + /// + [JsonPropertyName("items")] + public List Items { get; set; } + + /// + /// Who is sending the gift to player + /// + [JsonPropertyName("sender")] + public GiftSenderType Sender { get; set; } + + /// + /// Optional - supply a users id to send from, not necessary when sending from SYSTEM or TRADER + /// + [JsonPropertyName("senderId")] + public string? SenderId { get; set; } + + [JsonPropertyName("senderDetails")] + public UserDialogInfo SenderDetails { get; set; } + + /// + /// Optional - supply a trader type to send from, not necessary when sending from SYSTEM or USER + /// + [JsonPropertyName("trader")] + public Traders? Trader { get; set; } + + [JsonPropertyName("messageText")] + public string MessageText { get; set; } + + /// + /// Optional - if sending text from the client locale file + /// + [JsonPropertyName("localeTextId")] + public string? LocaleTextId { get; set; } + + /// + /// Optional - Used by Seasonal events to send on specific day + /// + [JsonPropertyName("timestampToSend")] + public long? TimestampToSend { get; set; } + + [JsonPropertyName("associatedEvent")] + public SeasonalEventType AssociatedEvent { get; set; } + + [JsonPropertyName("collectionTimeHours")] + public int CollectionTimeHours { get; set; } + + /// + /// Optional, can be used to change profile settings like level/skills + /// + [JsonPropertyName("profileChangeEvents")] + public List? ProfileChangeEvents { get; set; } + + [JsonPropertyName("maxToSendPlayer")] + public int? MaxToSendPlayer { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/HealthConfig.cs b/Core/Models/Spt/Config/HealthConfig.cs new file mode 100644 index 00000000..7088a1a3 --- /dev/null +++ b/Core/Models/Spt/Config/HealthConfig.cs @@ -0,0 +1,33 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class HealthConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-health"; + + [JsonPropertyName("healthMultipliers")] + public HealthMultipliers HealthMultipliers { get; set; } + + [JsonPropertyName("save")] + public HealthSave Save { get; set; } +} + +public class HealthMultipliers +{ + [JsonPropertyName("death")] + public double Death { get; set; } + + [JsonPropertyName("blacked")] + public double Blacked { get; set; } +} + +public class HealthSave +{ + [JsonPropertyName("health")] + public bool Health { get; set; } + + [JsonPropertyName("effects")] + public bool Effects { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/HideoutConfig.cs b/Core/Models/Spt/Config/HideoutConfig.cs new file mode 100644 index 00000000..29c1ab78 --- /dev/null +++ b/Core/Models/Spt/Config/HideoutConfig.cs @@ -0,0 +1,142 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +public class HideoutConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-hideout"; + + /// + /// How many seconds should pass before hideout crafts / fuel usage is checked and processed + /// + [JsonPropertyName("runIntervalSeconds")] + public int RunIntervalSeconds { get; set; } + + /// + /// Default values used to hydrate `RunIntervalSeconds` with + /// + [JsonPropertyName("runIntervalValues")] + public RunIntervalValues RunIntervalValues { get; set; } + + [JsonPropertyName("hoursForSkillCrafting")] + public int HoursForSkillCrafting { get; set; } + + [JsonPropertyName("expCraftAmount")] + public int ExpCraftAmount { get; set; } + + [JsonPropertyName("overrideCraftTimeSeconds")] + public int OverrideCraftTimeSeconds { get; set; } + + [JsonPropertyName("overrideBuildTimeSeconds")] + public int OverrideBuildTimeSeconds { get; set; } + + /// + /// Only process a profile's hideout crafts when it has been active in the last x minutes + /// + [JsonPropertyName("updateProfileHideoutWhenActiveWithinMinutes")] + public int UpdateProfileHideoutWhenActiveWithinMinutes { get; set; } + + [JsonPropertyName("cultistCircle")] + public CultistCircleSettings CultistCircle { get; set; } +} + +public class CultistCircleSettings +{ + [JsonPropertyName("maxRewardItemCount")] + public int MaxRewardItemCount { get; set; } + + [JsonPropertyName("maxAttemptsToPickRewardsWithinBudget")] + public int MaxAttemptsToPickRewardsWithinBudget { get; set; } + + [JsonPropertyName("rewardPriceMultiplerMinMax")] + public MinMax RewardPriceMultiplerMinMax { get; set; } + + /// + /// The odds that meeting the highest threshold gives you a bonus to crafting time + /// + [JsonPropertyName("bonusAmountMultiplier")] + public double BonusAmountMultiplier { get; set; } + + [JsonPropertyName("bonusChanceMultiplier")] + public double BonusChanceMultiplier { get; set; } + + /// + /// What is considered a "high-value" item + /// + [JsonPropertyName("highValueThresholdRub")] + public int HighValueThresholdRub { get; set; } + + /// + /// Hideout/task reward crafts have a unique craft time + /// + [JsonPropertyName("hideoutTaskRewardTimeSeconds")] + public int HideoutTaskRewardTimeSeconds { get; set; } + + /// + /// Rouble amount player needs to sacrifice to get chance of hideout/task rewards + /// + [JsonPropertyName("hideoutCraftSacrificeThresholdRub")] + public int HideoutCraftSacrificeThresholdRub { get; set; } + + [JsonPropertyName("craftTimeThreshholds")] + public List CraftTimeThreshholds { get; set; } + + /// + /// -1 means no override, value in seconds + /// + [JsonPropertyName("craftTimeOverride")] + public int CraftTimeOverride { get; set; } + + /// + /// Specific reward pool when player sacrifices specific item(s) + /// + [JsonPropertyName("directRewards")] + public List DirectRewards { get; set; } + + /// + /// Overrides for reward stack sizes, keyed by item tpl + /// + [JsonPropertyName("directRewardStackSize")] + public Dictionary DirectRewardStackSize { get; set; } + + /// + /// Item tpls to exclude from the reward pool + /// + [JsonPropertyName("rewardItemBlacklist")] + public List RewardItemBlacklist { get; set; } + + /// + /// Item tpls to include in the reward pool + /// + [JsonPropertyName("additionalRewardItemPool")] + public List AdditionalRewardItemPool { get; set; } + + [JsonPropertyName("currencyRewards")] + public Dictionary CurrencyRewards { get; set; } +} + +public class CraftTimeThreshhold : MinMax +{ + [JsonPropertyName("craftTimeSeconds")] + public int CraftTimeSeconds { get; set; } +} + +public class DirectRewardSettings +{ + [JsonPropertyName("reward")] + public List Reward { get; set; } + + [JsonPropertyName("requiredItems")] + public List RequiredItems { get; set; } + + [JsonPropertyName("craftTimeSeconds")] + public int CraftTimeSeconds { get; set; } + + /// + /// Is the reward a one time reward or can it be given multiple times + /// + [JsonPropertyName("repeatable")] + public bool Repeatable { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/HttpConfig.cs b/Core/Models/Spt/Config/HttpConfig.cs new file mode 100644 index 00000000..d465daa5 --- /dev/null +++ b/Core/Models/Spt/Config/HttpConfig.cs @@ -0,0 +1,39 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class HttpConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-http"; + + /// + /// Address used by webserver + /// + [JsonPropertyName("ip")] + public string Ip { get; set; } + + [JsonPropertyName("port")] + public int Port { get; set; } + + /// + /// Address used by game client to connect to + /// + [JsonPropertyName("backendIp")] + public string BackendIp { get; set; } + + [JsonPropertyName("backendPort")] + public string BackendPort { get; set; } + + [JsonPropertyName("webSocketPingDelayMs")] + public int WebSocketPingDelayMs { get; set; } + + [JsonPropertyName("logRequests")] + public bool LogRequests { get; set; } + + /// + /// e.g. "SPT_Data/Server/images/traders/579dc571d53a0658a154fbec.png": "SPT_Data/Server/images/traders/NewTraderImage.png" + /// + [JsonPropertyName("serverImagePathOverride")] + public Dictionary ServerImagePathOverride { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/InRaidConfig.cs b/Core/Models/Spt/Config/InRaidConfig.cs new file mode 100644 index 00000000..c46f8eb2 --- /dev/null +++ b/Core/Models/Spt/Config/InRaidConfig.cs @@ -0,0 +1,87 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class InRaidConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-inraid"; + + /** Overrides to apply to the pre-raid settings screen */ + [JsonPropertyName("raidMenuSettings")] + public RaidMenuSettings RaidMenuSettings { get; set; } + + /** What effects should be saved post-raid */ + [JsonPropertyName("save")] + public RaidSave Save { get; set; } + + /** Names of car extracts */ + [JsonPropertyName("carExtracts")] + public List CarExtracts { get; set; } + + /** Names of coop extracts */ + [JsonPropertyName("coopExtracts")] + public List CoopExtracts { get; set; } + + /** Fence rep gain from a single car extract */ + [JsonPropertyName("carExtractBaseStandingGain")] + public double CarExtractBaseStandingGain { get; set; } + + /** Fence rep gain from a single coop extract */ + [JsonPropertyName("coopExtractBaseStandingGain")] + public double CoopExtractBaseStandingGain { get; set; } + + /** Fence rep gain when successfully extracting as pscav */ + [JsonPropertyName("scavExtractStandingGain")] + public double ScavExtractStandingGain { get; set; } + + /** The likelihood of PMC eliminating a minimum of 2 scavs while you engage them as a pscav. */ + [JsonPropertyName("pmcKillProbabilityForScavGain")] + public double PmcKillProbabilityForScavGain { get; set; } + + /** On death should items in your secure keep their Find in raid status regardless of how you finished the raid */ + [JsonPropertyName("keepFiRSecureContainerOnDeath")] + public bool KeepFiRSecureContainerOnDeath { get; set; } + + /** If enabled always keep found in raid status on items */ + [JsonPropertyName("alwaysKeepFoundInRaidonRaidEnd")] + public bool AlwaysKeepFoundInRaidOnRaidEnd { get; set; } + + /** Percentage chance a player scav hot is hostile to the player when scavving */ + [JsonPropertyName("playerScavHostileChancePercent")] + public double PlayerScavHostileChancePercent { get; set; } +} + +public class RaidMenuSettings +{ + [JsonPropertyName("aiAmount")] + public string AiAmount { get; set; } + + [JsonPropertyName("aiDifficulty")] + public string AiDifficulty { get; set; } + + [JsonPropertyName("bossEnabled")] + public bool BossEnabled { get; set; } + + [JsonPropertyName("scavWars")] + public bool ScavWars { get; set; } + + [JsonPropertyName("taggedAndCursed")] + public bool TaggedAndCursed { get; set; } + + [JsonPropertyName("enablePve")] + public bool EnablePve { get; set; } + + [JsonPropertyName("randomWeather")] + public bool RandomWeather { get; set; } + + [JsonPropertyName("randomTime")] + public bool RandomTime { get; set; } +} + +public class RaidSave +{ + /** Should loot gained from raid be saved */ + [JsonPropertyName("loot")] + public bool Loot { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/InsuranceConfig.cs b/Core/Models/Spt/Config/InsuranceConfig.cs new file mode 100644 index 00000000..4a8fd62b --- /dev/null +++ b/Core/Models/Spt/Config/InsuranceConfig.cs @@ -0,0 +1,56 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class InsuranceConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-insurance"; + + /// + /// Chance item is returned as insurance, keyed by trader id + /// + [JsonPropertyName("returnChancePercent")] + public Dictionary ReturnChancePercent { get; set; } + + /// + /// Item slots that should never be returned as insurance + /// + [JsonPropertyName("blacklistedEquipment")] + public List BlacklistedEquipment { get; set; } + + /// + /// Some slots should always be removed, e.g. 'cartridges' + /// + [JsonPropertyName("slotIdsToAlwaysRemove")] + public List SlotIdsToAlwaysRemove { get; set; } + + /// + /// Override to control how quickly insurance is processed/returned in seconds + /// + [JsonPropertyName("returnTimeOverrideSeconds")] + public double ReturnTimeOverrideSeconds { get; set; } + + /// + /// Override to control how long insurance returns stay in mail before expiring - in seconds + /// + [JsonPropertyName("storageTimeOverrideSeconds")] + public double StorageTimeOverrideSeconds { get; set; } + + /// + /// How often server should process insurance in seconds + /// + [JsonPropertyName("runIntervalSeconds")] + public double RunIntervalSeconds { get; set; } + + // Lowest rouble price for an attachment to be allowed to be taken + [JsonPropertyName("minAttachmentRoublePriceToBeTaken")] + public double MinAttachmentRoublePriceToBeTaken { get; set; } + + // Chance out of 100% no attachments from a parent are taken + [JsonPropertyName("chanceNoAttachmentsTakenPercent")] + public double ChanceNoAttachmentsTakenPercent { get; set; } + + [JsonPropertyName("simulateItemsBeingTaken")] + public bool SimulateItemsBeingTaken { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/InventoryConfig.cs b/Core/Models/Spt/Config/InventoryConfig.cs new file mode 100644 index 00000000..58ae9cb4 --- /dev/null +++ b/Core/Models/Spt/Config/InventoryConfig.cs @@ -0,0 +1,72 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +public class InventoryConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-inventory"; + + /** Should new items purchased by flagged as found in raid */ + [JsonPropertyName("newItemsMarkedFound")] + public bool NewItemsMarkedFound { get; set; } + + [JsonPropertyName("randomLootContainers")] + public Dictionary RandomLootContainers { get; set; } + + [JsonPropertyName("sealedAirdropContainer")] + public SealedAirdropContainerSettings SealedAirdropContainer { get; set; } + + /** Contains item tpls that the server should consider money and treat the same as roubles/euros/dollars */ + [JsonPropertyName("customMoneyTpls")] + public List CustomMoneyTpls { get; set; } + + /** Multipliers for skill gain when inside menus, NOT in-game */ + [JsonPropertyName("skillGainMultiplers")] + public Dictionary SkillGainMultipliers { get; set; } + + /** Container Tpls that should be deprioritised when choosing where to take money from for payments */ + [JsonPropertyName("deprioritisedMoneyContainers")] + public List DeprioritisedMoneyContainers { get; set; } +} + +public class RewardDetails +{ + [JsonPropertyName("rewardCount")] + public int RewardCount { get; set; } + + [JsonPropertyName("foundInRaid")] + public bool FoundInRaid { get; set; } + + [JsonPropertyName("rewardTplPool")] + public Dictionary? RewardTplPool { get; set; } + + [JsonPropertyName("rewardTypePool")] + public List? RewardTypePool { get; set; } +} + +public class SealedAirdropContainerSettings +{ + [JsonPropertyName("weaponRewardWeight")] + public Dictionary WeaponRewardWeight { get; set; } + + [JsonPropertyName("defaultPresetsOnly")] + public bool DefaultPresetsOnly { get; set; } + + /** Should contents be flagged as found in raid when opened */ + [JsonPropertyName("foundInRaid")] + public bool FoundInRaid { get; set; } + + [JsonPropertyName("weaponModRewardLimits")] + public Dictionary WeaponModRewardLimits { get; set; } + + [JsonPropertyName("rewardTypeLimits")] + public Dictionary RewardTypeLimits { get; set; } + + [JsonPropertyName("ammoBoxWhitelist")] + public List AmmoBoxWhitelist { get; set; } + + [JsonPropertyName("allowBossItems")] + public bool AllowBossItems { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/ItemConfig.cs b/Core/Models/Spt/Config/ItemConfig.cs new file mode 100644 index 00000000..f51537fe --- /dev/null +++ b/Core/Models/Spt/Config/ItemConfig.cs @@ -0,0 +1,47 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class ItemConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-item"; + + /** Items that should be globally blacklisted */ + [JsonPropertyName("blacklist")] + public List Blacklist { get; set; } + + /** Items that should not be lootable from any location */ + [JsonPropertyName("lootableItemBlacklist")] + public List LootableItemBlacklist { get; set; } + + /** items that should not be given as rewards */ + [JsonPropertyName("rewardItemBlacklist")] + public List RewardItemBlacklist { get; set; } + + /** Item base types that should not be given as rewards */ + [JsonPropertyName("rewardItemTypeBlacklist")] + public List RewardItemTypeBlacklist { get; set; } + + /** Items that can only be found on bosses */ + [JsonPropertyName("bossItems")] + public List BossItems { get; set; } + + [JsonPropertyName("handbookPriceOverride")] + public Dictionary HandbookPriceOverride { get; set; } + + /** Presets to add to the globals.json `ItemPresets` dictionary on server start */ + [JsonPropertyName("customItemGlobalPresets")] + public List CustomItemGlobalPresets { get; set; } +} + +public class HandbookPriceOverride +{ + /** Price in roubles */ + [JsonPropertyName("price")] + public decimal Price { get; set; } + + /** NOT parentId from items.json, but handbook.json */ + [JsonPropertyName("parentId")] + public string ParentId { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/LocaleConfig.cs b/Core/Models/Spt/Config/LocaleConfig.cs new file mode 100644 index 00000000..9e6bc230 --- /dev/null +++ b/Core/Models/Spt/Config/LocaleConfig.cs @@ -0,0 +1,24 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class LocaleConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-locale"; + + /** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */ + [JsonPropertyName("gameLocale")] + public string GameLocale { get; set; } + + /** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */ + [JsonPropertyName("serverLocale")] + public string ServerLocale { get; set; } + + /** Languages server can be translated into */ + [JsonPropertyName("serverSupportedLocales")] + public List ServerSupportedLocales { get; set; } + + [JsonPropertyName("fallbacks")] + public Dictionary Fallbacks { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/LocationConfig.cs b/Core/Models/Spt/Config/LocationConfig.cs new file mode 100644 index 00000000..05effbec --- /dev/null +++ b/Core/Models/Spt/Config/LocationConfig.cs @@ -0,0 +1,319 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Config; + +public class LocationConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-location"; + + /// + /// Rogues are classified as bosses and spawn immediately, this can result in no scavs spawning, delay rogues spawning to allow scavs to spawn first + /// + [JsonPropertyName("rogueLighthouseSpawnTimeSettings")] + public RogueLighthouseSpawnTimeSettings RogueLighthouseSpawnTimeSettings { get; set; } + + /// + /// When a map has hit max alive bots, any wave that should spawn will be reduced to 1 bot in size and placed in a spawn queue, this splits waves into smaller sizes to reduce the impact of this behaviour + /// + [JsonPropertyName("splitWaveIntoSingleSpawnsSettings")] + public SplitWaveSettings SplitWaveIntoSingleSpawnsSettings { get; set; } + + [JsonPropertyName("looseLootMultiplier")] + public LootMultiplier LooseLootMultiplier { get; set; } + + [JsonPropertyName("staticLootMultiplier")] + public LootMultiplier StaticLootMultiplier { get; set; } + + /// + /// Custom bot waves to add to a locations base json on game start if addCustomBotWavesToMaps is true + /// + [JsonPropertyName("customWaves")] + public CustomWaves CustomWaves { get; set; } + + /// + /// Open zones to add to map + /// + [JsonPropertyName("openZones")] + public Dictionary> OpenZones { get; set; } + + /// + /// Key = map id, value = item tpls that should only have one forced loot spawn position + /// + [JsonPropertyName("forcedLootSingleSpawnById")] + public Dictionary> ForcedLootSingleSpawnById { get; set; } + + /// + /// How many attempts should be taken to fit an item into a container before giving up + /// + [JsonPropertyName("fitLootIntoContainerAttempts")] + public int FitLootIntoContainerAttempts { get; set; } + + /// + /// Add all possible zones to each maps `OpenZones` property + /// + [JsonPropertyName("addOpenZonesToAllMaps")] + public bool AddOpenZonesToAllMaps { get; set; } + + /// + /// Allow addition of custom bot waves designed by SPT to be added to maps - defined in configs/location.json.customWaves + /// + [JsonPropertyName("addCustomBotWavesToMaps")] + public bool AddCustomBotWavesToMaps { get; set; } + + /// + /// Should the limits defined inside botTypeLimits to be applied to locations on game start + /// + [JsonPropertyName("enableBotTypeLimits")] + public bool EnableBotTypeLimits { get; set; } + + /// + /// Add limits to a locations base.MinMaxBots array if enableBotTypeLimits is true + /// + [JsonPropertyName("botTypeLimits")] + public Dictionary> BotTypeLimits { get; set; } + + /// + /// Container randomisation settings + /// + [JsonPropertyName("containerRandomisationSettings")] + public ContainerRandomisationSettings ContainerRandomisationSettings { get; set; } + + /// + /// How full must a random loose magazine be % + /// + [JsonPropertyName("minFillLooseMagazinePercent")] + public int MinFillLooseMagazinePercent { get; set; } + + /// + /// How full must a random static magazine be % + /// + [JsonPropertyName("minFillStaticMagazinePercent")] + public int MinFillStaticMagazinePercent { get; set; } + + [JsonPropertyName("allowDuplicateItemsInStaticContainers")] + public bool AllowDuplicateItemsInStaticContainers { get; set; } + + /// + /// Chance loose magazines have ammo in them TODO - rename to dynamicMagazineLootHasAmmoChancePercent + /// + [JsonPropertyName("magazineLootHasAmmoChancePercent")] + public int MagazineLootHasAmmoChancePercent { get; set; } + + /// + /// Chance static magazines have ammo in them + /// + [JsonPropertyName("staticMagazineLootHasAmmoChancePercent")] + public int StaticMagazineLootHasAmmoChancePercent { get; set; } + + /// + /// Key: map, value: loose loot ids to ignore + /// + [JsonPropertyName("looseLootBlacklist")] + public Dictionary> LooseLootBlacklist { get; set; } + + /// + /// Key: map, value: settings to control how long scav raids are + /// + [JsonPropertyName("scavRaidTimeSettings")] + public ScavRaidTimeSettings ScavRaidTimeSettings { get; set; } + + /// + /// Settings to adjust mods for lootable equipment in raid + /// + [JsonPropertyName("equipmentLootSettings")] + public EquipmentLootSettings EquipmentLootSettings { get; set; } + + /// + /// Min percentage to set raider spawns at, -1 makes no changes + /// + [JsonPropertyName("reserveRaiderSpawnChanceOverrides")] + public ReserveRaiderSpawnChanceOverrides ReserveRaiderSpawnChanceOverrides { get; set; } + + /// + /// Map ids players cannot visit + /// + [JsonPropertyName("nonMaps")] + public List NonMaps { get; set; } +} + +public class ReserveRaiderSpawnChanceOverrides +{ + [JsonPropertyName("nonTriggered")] + public int NonTriggered { get; set; } + + [JsonPropertyName("triggered")] + public int Triggered { get; set; } +} + +public class EquipmentLootSettings +{ + // Percentage chance item will be added to equipment + [JsonPropertyName("modSpawnChancePercent")] + public Dictionary ModSpawnChancePercent { get; set; } +} + +public class FixEmptyBotWavesSettings +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("ignoreMaps")] + public List IgnoreMaps { get; set; } +} + +public class RogueLighthouseSpawnTimeSettings +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("waitTimeSeconds")] + public int WaitTimeSeconds { get; set; } +} + +public class SplitWaveSettings +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("ignoreMaps")] + public List IgnoreMaps { get; set; } + + [JsonPropertyName("waveSizeThreshold")] + public int WaveSizeThreshold { get; set; } +} + +public class CustomWaves +{ + /** Bosses spawn on raid start */ + [JsonPropertyName("boss")] + public Dictionary> Boss { get; set; } + + [JsonPropertyName("normal")] + public Dictionary> Normal { get; set; } +} + +public class BotTypeLimit : MinMax +{ + [JsonPropertyName("type")] + public string Type { get; set; } +} + +/** Multiplier to apply to the loot count for a given map */ +public class LootMultiplier +{ + [JsonPropertyName("bigmap")] + public int BigMap { get; set; } + + [JsonPropertyName("develop")] + public int Develop { get; set; } + + [JsonPropertyName("factory4_day")] + public int Factory4Day { get; set; } + + [JsonPropertyName("factory4_night")] + public int Factory4Night { get; set; } + + [JsonPropertyName("interchange")] + public int Interchange { get; set; } + + [JsonPropertyName("laboratory")] + public int Laboratory { get; set; } + + [JsonPropertyName("rezervbase")] + public int RezervBase { get; set; } + + [JsonPropertyName("shoreline")] + public int Shoreline { get; set; } + + [JsonPropertyName("woods")] + public int Woods { get; set; } + + [JsonPropertyName("hideout")] + public int Hideout { get; set; } + + [JsonPropertyName("lighthouse")] + public int Lighthouse { get; set; } + + [JsonPropertyName("privatearea")] + public int PrivateArea { get; set; } + + [JsonPropertyName("suburbs")] + public int Suburbs { get; set; } + + [JsonPropertyName("tarkovstreets")] + public int TarkovStreets { get; set; } + + [JsonPropertyName("terminal")] + public int Terminal { get; set; } + + [JsonPropertyName("town")] + public int Town { get; set; } + + [JsonPropertyName("sandbox")] + public int Sandbox { get; set; } +} + +public class ContainerRandomisationSettings +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + /** What maps can use the container randomisation feature */ + [JsonPropertyName("maps")] + public Dictionary Maps { get; set; } + + /** Some container types don't work when randomised */ + [JsonPropertyName("containerTypesToNotRandomise")] + public List ContainerTypesToNotRandomise { get; set; } + + [JsonPropertyName("containerGroupMinSizeMultiplier")] + public double ContainerGroupMinSizeMultiplier { get; set; } + + [JsonPropertyName("containerGroupMaxSizeMultiplier")] + public double ContainerGroupMaxSizeMultiplier { get; set; } +} + +public class ScavRaidTimeSettings +{ + [JsonPropertyName("settings")] + public ScavRaidTimeConfigSettings Settings { get; set; } + + [JsonPropertyName("maps")] + public Dictionary Maps { get; set; } +} + +public class ScavRaidTimeConfigSettings +{ + [JsonPropertyName("trainArrivalDelayObservedSeconds")] + public int TrainArrivalDelayObservedSeconds { get; set; } +} + +public class ScavRaidTimeLocationSettings +{ + /** Should loot be reduced by same percent length of raid is reduced by */ + [JsonPropertyName("reduceLootByPercent")] + public bool ReduceLootByPercent { get; set; } + + /** Smallest % of container loot that should be spawned */ + [JsonPropertyName("minStaticLootPercent")] + public double MinStaticLootPercent { get; set; } + + /** Smallest % of loose loot that should be spawned */ + [JsonPropertyName("minDynamicLootPercent")] + public double MinDynamicLootPercent { get; set; } + + /** Chance raid time is reduced */ + [JsonPropertyName("reducedChancePercent")] + public double ReducedChancePercent { get; set; } + + /** How much should raid time be reduced - weighted */ + [JsonPropertyName("reductionPercentWeights")] + public Dictionary ReductionPercentWeights { get; set; } + + /** Should bot waves be removed / spawn times be adjusted */ + [JsonPropertyName("adjustWaves")] + public bool AdjustWaves { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/LootConfig.cs b/Core/Models/Spt/Config/LootConfig.cs new file mode 100644 index 00000000..5646fbe0 --- /dev/null +++ b/Core/Models/Spt/Config/LootConfig.cs @@ -0,0 +1,18 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Config; + +public class LootConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-loot"; + + /** Spawn positions to add into a map, key=mapid */ + [JsonPropertyName("looseLoot")] + public Dictionary LooseLoot { get; set; } + + /** Loose loot probability adjustments to apply on game start */ + [JsonPropertyName("looseLootSpawnPointAdjustments")] + public Dictionary> LooseLootSpawnPointAdjustments { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/LostOnDeathConfig.cs b/Core/Models/Spt/Config/LostOnDeathConfig.cs new file mode 100644 index 00000000..9803f6ef --- /dev/null +++ b/Core/Models/Spt/Config/LostOnDeathConfig.cs @@ -0,0 +1,63 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class LostOnDeathConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-lostondeath"; + + /** What equipment in each slot should be lost on death */ + [JsonPropertyName("equipment")] + public LostEquipment Equipment { get; set; } + + /** Should special slot items be removed from quest inventory on death e.g. wifi camera/markers */ + [JsonPropertyName("specialSlotItems")] + public bool SpecialSlotItems { get; set; } + + /** Should quest items be removed from quest inventory on death */ + [JsonPropertyName("questItems")] + public bool QuestItems { get; set; } +} + +public class LostEquipment +{ + [JsonPropertyName("ArmBand")] + public bool ArmBand { get; set; } + + [JsonPropertyName("Headwear")] + public bool Headwear { get; set; } + + [JsonPropertyName("Earpiece")] + public bool Earpiece { get; set; } + + [JsonPropertyName("FaceCover")] + public bool FaceCover { get; set; } + + [JsonPropertyName("ArmorVest")] + public bool ArmorVest { get; set; } + + [JsonPropertyName("Eyewear")] + public bool Eyewear { get; set; } + + [JsonPropertyName("TacticalVest")] + public bool TacticalVest { get; set; } + + [JsonPropertyName("PocketItems")] + public bool PocketItems { get; set; } + + [JsonPropertyName("Backpack")] + public bool Backpack { get; set; } + + [JsonPropertyName("Holster")] + public bool Holster { get; set; } + + [JsonPropertyName("FirstPrimaryWeapon")] + public bool FirstPrimaryWeapon { get; set; } + + [JsonPropertyName("SecondPrimaryWeapon")] + public bool SecondPrimaryWeapon { get; set; } + + [JsonPropertyName("Scabbard")] + public bool Scabbard { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/MatchConfig.cs b/Core/Models/Spt/Config/MatchConfig.cs new file mode 100644 index 00000000..2a3a86d0 --- /dev/null +++ b/Core/Models/Spt/Config/MatchConfig.cs @@ -0,0 +1,12 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class MatchConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-match"; + + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/PlayerScavConfig.cs b/Core/Models/Spt/Config/PlayerScavConfig.cs new file mode 100644 index 00000000..bc52102e --- /dev/null +++ b/Core/Models/Spt/Config/PlayerScavConfig.cs @@ -0,0 +1,61 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Config; + +public class PlayerScavConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-playerscav"; + + [JsonPropertyName("karmaLevel")] + public Dictionary KarmaLevel { get; set; } +} + +public class KarmaLevel +{ + [JsonPropertyName("botTypeForLoot")] + public string BotTypeForLoot { get; set; } + + [JsonPropertyName("modifiers")] + public Modifiers Modifiers { get; set; } + + [JsonPropertyName("itemLimits")] + public ItemLimits ItemLimits { get; set; } + + [JsonPropertyName("equipmentBlacklist")] + public Dictionary EquipmentBlacklist { get; set; } + + [JsonPropertyName("lootItemsToAddChancePercent")] + public Dictionary LootItemsToAddChancePercent { get; set; } +} + +public class Modifiers +{ + [JsonPropertyName("equipment")] + public Dictionary Equipment { get; set; } + + [JsonPropertyName("mod")] + public Dictionary Mod { get; set; } +} + +public class ItemLimits +{ + [JsonPropertyName("healing")] + public GenerationData Healing { get; set; } + + [JsonPropertyName("drugs")] + public GenerationData Drugs { get; set; } + + [JsonPropertyName("stims")] + public GenerationData Stims { get; set; } + + [JsonPropertyName("looseLoot")] + public GenerationData LooseLoot { get; set; } + + [JsonPropertyName("magazines")] + public GenerationData Magazines { get; set; } + + [JsonPropertyName("grenades")] + public GenerationData Grenades { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/PmcChatResponse.cs b/Core/Models/Spt/Config/PmcChatResponse.cs new file mode 100644 index 00000000..a10a32ca --- /dev/null +++ b/Core/Models/Spt/Config/PmcChatResponse.cs @@ -0,0 +1,33 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Config; + +public class PmcChatResponse : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-pmcchatresponse"; + + [JsonPropertyName("victim")] + public ResponseSettings Victim { get; set; } + + [JsonPropertyName("killer")] + public ResponseSettings Killer { get; set; } +} + +public class ResponseSettings +{ + [JsonPropertyName("responseChancePercent")] + public double ResponseChancePercent { get; set; } + + [JsonPropertyName("responseTypeWeights")] + public Dictionary ResponseTypeWeights { get; set; } + + [JsonPropertyName("stripCapitalisationChancePercent")] + public double StripCapitalisationChancePercent { get; set; } + + [JsonPropertyName("allCapsChancePercent")] + public double AllCapsChancePercent { get; set; } + + [JsonPropertyName("appendBroToMessageEndChancePercent")] + public double AppendBroToMessageEndChancePercent { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/PmcConfig.cs b/Core/Models/Spt/Config/PmcConfig.cs new file mode 100644 index 00000000..89149ee8 --- /dev/null +++ b/Core/Models/Spt/Config/PmcConfig.cs @@ -0,0 +1,162 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; +using Core.Models.Eft.Common; +using Core.Models.Enums; + +namespace Core.Models.Spt.Config; + +public class PmcConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-pmc"; + + /** What game version should the PMC have */ + [JsonPropertyName("gameVersionWeight")] + public Dictionary GameVersionWeight { get; set; } + + /** What account type should the PMC have */ + [JsonPropertyName("accountTypeWeight")] + public Dictionary AccountTypeWeight { get; set; } + + /** Global whitelist/blacklist of vest loot for PMCs */ + [JsonPropertyName("vestLoot")] + public SlotLootSettings VestLoot { get; set; } + + /** Global whitelist/blacklist of pocket loot for PMCs */ + [JsonPropertyName("pocketLoot")] + public SlotLootSettings PocketLoot { get; set; } + + /** Global whitelist/blacklist of backpack loot for PMCs */ + [JsonPropertyName("backpackLoot")] + public SlotLootSettings BackpackLoot { get; set; } + + [JsonPropertyName("globalLootBlacklist")] + public List GlobalLootBlacklist { get; set; } + + /** Use difficulty defined in config/bot.json/difficulty instead of chosen difficulty dropdown value */ + [JsonPropertyName("useDifficultyOverride")] + public bool UseDifficultyOverride { get; set; } + + /** Difficulty override e.g. "AsOnline/Hard" */ + [JsonPropertyName("difficulty")] + public string Difficulty { get; set; } + + /** Chance out of 100 to have a complete gun in backpack */ + [JsonPropertyName("looseWeaponInBackpackChancePercent")] + public double LooseWeaponInBackpackChancePercent { get; set; } + + /** Chance out of 100 to have an enhancement applied to PMC weapon */ + [JsonPropertyName("weaponHasEnhancementChancePercent")] + public double WeaponHasEnhancementChancePercent { get; set; } + + /** MinMax count of weapons to have in backpack */ + [JsonPropertyName("looseWeaponInBackpackLootMinMax")] + public MinMax LooseWeaponInBackpackLootMinMax { get; set; } + + /** Percentage chance PMC will be USEC */ + [JsonPropertyName("isUsec")] + public double IsUsec { get; set; } + + /** WildSpawnType enum value USEC PMCs use */ + [JsonPropertyName("usecType")] + public string UsecType { get; set; } + + /** WildSpawnType enum value BEAR PMCs use */ + [JsonPropertyName("bearType")] + public string BearType { get; set; } + + /** What 'brain' does a PMC use, keyed by map and side (USEC/BEAR) key: map location, value: type for usec/bear */ + [JsonPropertyName("pmcType")] + public Dictionary>> PmcType { get; set; } + + [JsonPropertyName("maxBackpackLootTotalRub")] + public List MaxBackpackLootTotalRub { get; set; } + + [JsonPropertyName("maxPocketLootTotalRub")] + public double MaxPocketLootTotalRub { get; set; } + + [JsonPropertyName("maxVestLootTotalRub")] + public double MaxVestLootTotalRub { get; set; } + + /** Percentage chance a bot from a wave is converted into a PMC, first key = map, second key = bot wildspawn type (assault/exusec), value: min+max chance to be converted */ + [JsonPropertyName("convertIntoPmcChance")] + public Dictionary> ConvertIntoPmcChance { get; set; } + + /** How many levels above player level can a PMC be */ + [JsonPropertyName("botRelativeLevelDeltaMax")] + public double BotRelativeLevelDeltaMax { get; set; } + + /** How many levels below player level can a PMC be */ + [JsonPropertyName("botRelativeLevelDeltaMin")] + public double BotRelativeLevelDeltaMin { get; set; } + + /** Force a number of healing items into PMCs secure container to ensure they can heal */ + [JsonPropertyName("forceHealingItemsIntoSecure")] + public bool ForceHealingItemsIntoSecure { get; set; } + + [JsonPropertyName("hostilitySettings")] + public Dictionary HostilitySettings { get; set; } + + [JsonPropertyName("allPMCsHavePlayerNameWithRandomPrefixChance")] + public double AllPMCsHavePlayerNameWithRandomPrefixChance { get; set; } + + [JsonPropertyName("locationSpecificPmcLevelOverride")] + public Dictionary LocationSpecificPmcLevelOverride { get; set; } + + /** Should secure container loot from usec.json/bear.json be added to pmc bots secure */ + [JsonPropertyName("addSecureContainerLootFromBotConfig")] + public bool AddSecureContainerLootFromBotConfig { get; set; } +} + +public class HostilitySettings +{ + /** Bot roles that are 100% an enemy */ + [JsonPropertyName("additionalEnemyTypes")] + public List? AdditionalEnemyTypes { get; set; } + + /** Objects that determine the % chance another bot type is an enemy */ + [JsonPropertyName("chancedEnemies")] + public List? ChancedEnemies { get; set; } + + [JsonPropertyName("bearEnemyChance")] + public double? BearEnemyChance { get; set; } + + [JsonPropertyName("usecEnemyChance")] + public double? UsecEnemyChance { get; set; } + + [JsonPropertyName("savageEnemyChance")] + public double? SavageEnemyChance { get; set; } + + /** Bot roles that are 100% a friendly */ + [JsonPropertyName("additionalFriendlyTypes")] + public List? AdditionalFriendlyTypes { get; set; } + + [JsonPropertyName("savagePlayerBehaviour")] + public string? SavagePlayerBehaviour { get; set; } +} + +public class PmcTypes +{ + [JsonPropertyName("usec")] + public string Usec { get; set; } + + [JsonPropertyName("bear")] + public string Bear { get; set; } +} + +public class SlotLootSettings +{ + /** Item Type whitelist */ + [JsonPropertyName("whitelist")] + public List Whitelist { get; set; } + + /** Item tpl blacklist */ + [JsonPropertyName("blacklist")] + public List Blacklist { get; set; } +} + +public class IMinMaxLootValue : MinMax +{ + [JsonPropertyName("value")] + public double Value { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/QuestConfig.cs b/Core/Models/Spt/Config/QuestConfig.cs new file mode 100644 index 00000000..62a17e9a --- /dev/null +++ b/Core/Models/Spt/Config/QuestConfig.cs @@ -0,0 +1,371 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; +using Core.Models.Enums; + +namespace Core.Models.Spt.Config; + +public class QuestConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-quest"; + + // Hours to get/redeem items from quest mail keyed by profile type + [JsonPropertyName("mailRedeemTimeHours")] + public Dictionary MailRedeemTimeHours { get; set; } + + [JsonPropertyName("questTemplateIds")] + public PlayerTypeQuestIds QuestTemplateIds { get; set; } + + /** Show non-seasonal quests be shown to player */ + [JsonPropertyName("showNonSeasonalEventQuests")] + public bool ShowNonSeasonalEventQuests { get; set; } + + [JsonPropertyName("eventQuests")] + public Dictionary EventQuests { get; set; } + + [JsonPropertyName("repeatableQuests")] + public List RepeatableQuests { get; set; } + + [JsonPropertyName("locationIdMap")] + public Dictionary LocationIdMap { get; set; } + + [JsonPropertyName("bearOnlyQuests")] + public List BearOnlyQuests { get; set; } + + [JsonPropertyName("usecOnlyQuests")] + public List UsecOnlyQuests { get; set; } + + /** Quests that the keyed game version do not see/access */ + [JsonPropertyName("profileBlacklist")] + public Dictionary> ProfileBlacklist { get; set; } + + /** key=questid, gameversions that can see/access quest */ + [JsonPropertyName("profileWhitelist")] + public Dictionary> ProfileWhitelist { get; set; } +} + +public class PlayerTypeQuestIds +{ + [JsonPropertyName("pmc")] + public QuestTypeIds Pmc { get; set; } + + [JsonPropertyName("scav")] + public QuestTypeIds Scav { get; set; } +} + +public class QuestTypeIds +{ + [JsonPropertyName("Elimination")] + public string Elimination { get; set; } + + [JsonPropertyName("Completion")] + public string Completion { get; set; } + + [JsonPropertyName("Exploration")] + public string Exploration { get; set; } +} + +public class EventQuestData +{ + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("season")] + public SeasonalEventType Season { get; set; } + + [JsonPropertyName("startTimestamp")] + public long StartTimestamp { get; set; } + + [JsonPropertyName("endTimestamp")] + public long EndTimestamp { get; set; } + + [JsonPropertyName("yearly")] + public bool Yearly { get; set; } +} + +public class RepeatableQuestConfig +{ + [JsonPropertyName("id")] + public string Id { get; set; } + + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("side")] + public string Side { get; set; } + + [JsonPropertyName("types")] + public List Types { get; set; } + + [JsonPropertyName("resetTime")] + public long ResetTime { get; set; } + + [JsonPropertyName("numQuests")] + public int NumQuests { get; set; } + + [JsonPropertyName("minPlayerLevel")] + public int MinPlayerLevel { get; set; } + + [JsonPropertyName("rewardScaling")] + public RewardScaling RewardScaling { get; set; } + + [JsonPropertyName("locations")] + public Dictionary> Locations { get; set; } + + [JsonPropertyName("traderWhitelist")] + public List TraderWhitelist { get; set; } + + [JsonPropertyName("questConfig")] + public RepeatableQuestTypesConfig QuestConfig { get; set; } + + /** Item base types to block when generating rewards */ + [JsonPropertyName("rewardBaseTypeBlacklist")] + public List RewardBaseTypeBlacklist { get; set; } + + /** Item tplIds to ignore when generating rewards */ + [JsonPropertyName("rewardBlacklist")] + public List RewardBlacklist { get; set; } + + [JsonPropertyName("rewardAmmoStackMinSize")] + public int RewardAmmoStackMinSize { get; set; } + + [JsonPropertyName("freeChangesAvailable")] + public int FreeChangesAvailable { get; set; } + + [JsonPropertyName("freeChanges")] + public int FreeChanges { get; set; } + + [JsonPropertyName("keepDailyQuestTypeOnReplacement")] + public bool KeepDailyQuestTypeOnReplacement { get; set; } +} + +public class RewardScaling +{ + [JsonPropertyName("levels")] + public List Levels { get; set; } + + [JsonPropertyName("experience")] + public List Experience { get; set; } + + [JsonPropertyName("roubles")] + public List Roubles { get; set; } + + [JsonPropertyName("gpCoins")] + public List GpCoins { get; set; } + + [JsonPropertyName("items")] + public List Items { get; set; } + + [JsonPropertyName("reputation")] + public List Reputation { get; set; } + + [JsonPropertyName("rewardSpread")] + public int RewardSpread { get; set; } + + [JsonPropertyName("skillRewardChance")] + public List SkillRewardChance { get; set; } + + [JsonPropertyName("skillPointReward")] + public List SkillPointReward { get; set; } +} + +public class TraderWhitelist +{ + [JsonPropertyName("traderId")] + public string TraderId { get; set; } + + [JsonPropertyName("questTypes")] + public List QuestTypes { get; set; } + + [JsonPropertyName("rewardBaseWhitelist")] + public List RewardBaseWhitelist { get; set; } + + [JsonPropertyName("rewardCanBeWeapon")] + public bool RewardCanBeWeapon { get; set; } + + [JsonPropertyName("weaponRewardChancePercent")] + public double WeaponRewardChancePercent { get; set; } +} + +public class RepeatableQuestTypesConfig +{ + [JsonPropertyName("Exploration")] + public Exploration Exploration { get; set; } + + [JsonPropertyName("Completion")] + public Completion Completion { get; set; } + + [JsonPropertyName("Pickup")] + public Pickup Pickup { get; set; } + + [JsonPropertyName("Elimination")] + public List Elimination { get; set; } +} + +public class Exploration : BaseQuestConfig +{ + [JsonPropertyName("maxExtracts")] + public int MaximumExtracts { get; set; } + + [JsonPropertyName("maxExtractsWithSpecificExit")] + public int MaximumExtractsWithSpecificExit { get; set; } + + [JsonPropertyName("specificExits")] + public SpecificExits SpecificExits { get; set; } +} + +public class SpecificExits +{ + [JsonPropertyName("probability")] + public int Probability { get; set; } + + [JsonPropertyName("passageRequirementWhitelist")] + public List PassageRequirementWhitelist { get; set; } +} + +public class Completion : BaseQuestConfig +{ + [JsonPropertyName("minRequestedAmount")] + public int MinimumRequestedAmount { get; set; } + + [JsonPropertyName("maxRequestedAmount")] + public int MaximumRequestedAmount { get; set; } + + [JsonPropertyName("uniqueItemCount")] + public int UniqueItemCount { get; set; } + + [JsonPropertyName("minRequestedBulletAmount")] + public int MinimumRequestedBulletAmount { get; set; } + + [JsonPropertyName("maxRequestedBulletAmount")] + public int MaximumRequestedBulletAmount { get; set; } + + [JsonPropertyName("useWhitelist")] + public bool UseWhitelist { get; set; } + + [JsonPropertyName("useBlacklist")] + public bool UseBlacklist { get; set; } +} + +public class Pickup : BaseQuestConfig +{ + [JsonPropertyName("ItemTypeToFetchWithMaxCount")] + public List ItemTypeToFetchWithMaxCount { get; set; } +} + +public class PickupTypeWithMaxCount +{ + [JsonPropertyName("itemType")] + public string ItemType { get; set; } + + [JsonPropertyName("maxPickupCount")] + public int MaximumPickupCount { get; set; } + + [JsonPropertyName("minPickupCount")] + public int MinimumPickupCount { get; set; } +} + +public class EliminationConfig : BaseQuestConfig +{ + [JsonPropertyName("levelRange")] + public MinMax LevelRange { get; set; } + + [JsonPropertyName("targets")] + public List Targets { get; set; } + + [JsonPropertyName("bodyPartProb")] + public double BodyPartProbability { get; set; } + + [JsonPropertyName("bodyParts")] + public List BodyParts { get; set; } + + [JsonPropertyName("specificLocationProb")] + public double SpecificLocationProbability { get; set; } + + [JsonPropertyName("distLocationBlacklist")] + public List DistLocationBlacklist { get; set; } + + [JsonPropertyName("distProb")] + public double DistanceProbability { get; set; } + + [JsonPropertyName("maxDist")] + public double MaxDistance { get; set; } + + [JsonPropertyName("minDist")] + public double MinDistance { get; set; } + + [JsonPropertyName("maxKills")] + public int MaxKills { get; set; } + + [JsonPropertyName("minKills")] + public int MinKills { get; set; } + + [JsonPropertyName("minBossKills")] + public int MinBossKills { get; set; } + + [JsonPropertyName("maxBossKills")] + public int MaxBossKills { get; set; } + + [JsonPropertyName("minPmcKills")] + public int MinPmcKills { get; set; } + + [JsonPropertyName("maxPmcKills")] + public int MaxPmcKills { get; set; } + + [JsonPropertyName("weaponCategoryRequirementProb")] + public double WeaponCategoryRequirementProbability { get; set; } + + [JsonPropertyName("weaponCategoryRequirements")] + public List WeaponCategoryRequirements { get; set; } + + [JsonPropertyName("weaponRequirementProb")] + public double WeaponRequirementProbability { get; set; } + + [JsonPropertyName("weaponRequirements")] + public List WeaponRequirements { get; set; } +} + +public class BaseQuestConfig +{ + [JsonPropertyName("possibleSkillRewards")] + public List PossibleSkillRewards { get; set; } +} + +public class Target : ProbabilityObject +{ + [JsonPropertyName("data")] + public BossInfo Data { get; set; } +} + +public class BossInfo +{ + [JsonPropertyName("isBoss")] + public bool IsBoss { get; set; } + + [JsonPropertyName("isPmc")] + public bool IsPmc { get; set; } +} + +public class BodyPart : ProbabilityObject +{ + [JsonPropertyName("data")] + public string[] Data { get; set; } +} + +public class WeaponRequirement : ProbabilityObject +{ + [JsonPropertyName("data")] + public string[] Data { get; set; } +} + +public class ProbabilityObject +{ + [JsonPropertyName("key")] + public string Key { get; set; } + + [JsonPropertyName("relativeProbability")] + public double RelativeProbability { get; set; } + + [JsonPropertyName("data")] + public object Data { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/RagfairConfig.cs b/Core/Models/Spt/Config/RagfairConfig.cs new file mode 100644 index 00000000..a1ced8ff --- /dev/null +++ b/Core/Models/Spt/Config/RagfairConfig.cs @@ -0,0 +1,393 @@ +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +using System.Text.Json.Serialization; + +public class RagfairConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-ragfair"; + + /** How many seconds should pass before expired offers and processed + player offers checked if sold */ + [JsonPropertyName("runIntervalSeconds")] + public int RunIntervalSeconds { get; set; } + + /** Default values used to hydrate `runIntervalSeconds` with */ + [JsonPropertyName("runIntervalValues")] + public RunIntervalValues RunIntervalValues { get; set; } + + /** Player listing settings */ + [JsonPropertyName("sell")] + public Sell Sell { get; set; } + + /** Trader ids + should their assorts be listed on flea */ + [JsonPropertyName("traders")] + public Dictionary Traders { get; set; } + + [JsonPropertyName("dynamic")] + public Dynamic Dynamic { get; set; } + + [JsonPropertyName("tieredFlea")] + public TieredFlea TieredFlea { get; set; } +} + +public class Sell +{ + /** Should a fee be deducted from player when listing an item for sale */ + [JsonPropertyName("fees")] + public bool Fees { get; set; } + + /** Settings to control chances of offer being sold */ + [JsonPropertyName("chance")] + public Chance Chance { get; set; } + + /** Settings to control how long it takes for a player offer to sell */ + [JsonPropertyName("time")] + public MinMax Time { get; set; } + + /** Seconds from clicking remove to remove offer from market */ + [JsonPropertyName("expireSeconds")] + public int ExpireSeconds { get; set; } +} + +public class Chance +{ + /** Base chance percent to sell an item */ + [JsonPropertyName("base")] + public int Base { get; set; } + + /** Value to multiply the sell chance by */ + [JsonPropertyName("sellMultiplier")] + public int SellMultiplier { get; set; } + + /** Max possible sell chance % for a player listed offer */ + [JsonPropertyName("maxSellChancePercent")] + public int MaxSellChancePercent { get; set; } + + /** Min possible sell chance % for a player listed offer */ + [JsonPropertyName("minSellChancePercent")] + public int MinSellChancePercent { get; set; } +} + +public class Dynamic +{ + [JsonPropertyName("purchasesAreFoundInRaid")] + // Should a purchased dynamic offers items be flagged as found in raid + public bool PurchasesAreFoundInRaid { get; set; } + + [JsonPropertyName("useTraderPriceForOffersIfHigher")] + /** Use the highest trader price for an offer if its greater than the price in templates/prices.json */ + public bool UseTraderPriceForOffersIfHigher { get; set; } + + [JsonPropertyName("barter")] + /** Barter offer specific settings */ + public BarterDetails Barter { get; set; } + + [JsonPropertyName("pack")] + public PackDetails Pack { get; set; } + + [JsonPropertyName("offerAdjustment")] + /** Dynamic offer price below handbook adjustment values */ + public OfferAdjustment OfferAdjustment { get; set; } + + [JsonPropertyName("expiredOfferThreshold")] + /** How many offers should expire before an offer regeneration occurs */ + public int ExpiredOfferThreshold { get; set; } + + [JsonPropertyName("offerItemCount")] + /** How many offers should be listed */ + public MinMax OfferItemCount { get; set; } + + [JsonPropertyName("priceRanges")] + /** How much should the price of an offer vary by (percent 0.8 = 80%, 1.2 = 120%) */ + public PriceRanges PriceRanges { get; set; } + + [JsonPropertyName("showDefaultPresetsOnly")] + /** Should default presets to listed only or should non-standard presets found in globals.json be listed too */ + public bool ShowDefaultPresetsOnly { get; set; } + + [JsonPropertyName("ignoreQualityPriceVarianceBlacklist")] + /** Tpls that should not use the variable price system when their quality is < 100% (lower dura/uses = lower price) */ + public List IgnoreQualityPriceVarianceBlacklist { get; set; } + + [JsonPropertyName("endTimeSeconds")] + public MinMax EndTimeSeconds { get; set; } + + [JsonPropertyName("condition")] + /** Settings to control the durability range of item items listed on flea */ + public Condition Condition { get; set; } + + [JsonPropertyName("stackablePercent")] + /** Size stackable items should be listed for in percent of max stack size */ + public MinMax StackablePercent { get; set; } + + [JsonPropertyName("nonStackableCount")] + /** Items that cannot be stacked can have multiples sold in one offer, what range of values can be listed */ + public MinMax NonStackableCount { get; set; } + + [JsonPropertyName("rating")] + /** Range of rating offers for items being listed */ + public MinMax Rating { get; set; } + + [JsonPropertyName("armor")] + /** Armor specific flea settings */ + public ArmorSettings Armor { get; set; } + + [JsonPropertyName("itemPriceMultiplier")] + /** A multipler to apply to individual tpls price just prior to item quality adjustment */ + public Dictionary ItemPriceMultiplier { get; set; } + + [JsonPropertyName("currencies")] + /** Percentages to sell offers in each currency */ + public Dictionary Currencies { get; set; } + + [JsonPropertyName("showAsSingleStack")] + /** Item tpls that should be forced to sell as a single item */ + public List ShowAsSingleStack { get; set; } + + [JsonPropertyName("removeSeasonalItemsWhenNotInEvent")] + /** Should christmas/halloween items be removed from flea when not within the seasonal bounds */ + public bool RemoveSeasonalItemsWhenNotInEvent { get; set; } + + [JsonPropertyName("blacklist")] + /** Flea blacklist settings */ + public RagfairBlacklist Blacklist { get; set; } + + [JsonPropertyName("unreasonableModPrices")] + /** Dict of price limits keyed by item type */ + public Dictionary UnreasonableModPrices { get; set; } + + [JsonPropertyName("itemPriceOverrideRouble")] + /** Custom rouble prices for items to override values from prices.json */ + public Dictionary ItemPriceOverrideRouble { get; set; } +} + +public class PriceRanges +{ + [JsonPropertyName("default")] + public MinMax Default { get; set; } + + [JsonPropertyName("preset")] + public MinMax Preset { get; set; } + + [JsonPropertyName("pack")] + public MinMax Pack { get; set; } +} + +public class BarterDetails +{ + /** Percentage change an offer is listed as a barter */ + [JsonPropertyName("chancePercent")] + public double ChancePercent { get; set; } + + /** Min number of required items for a barter requirement */ + [JsonPropertyName("itemCountMin")] + public int ItemCountMin { get; set; } + + /** Max number of required items for a barter requirement */ + [JsonPropertyName("itemCountMax")] + public int ItemCountMax { get; set; } + + /** How much can the total price of requested items vary from the item offered */ + [JsonPropertyName("priceRangeVariancePercent")] + public double PriceRangeVariancePercent { get; set; } + + /** Min rouble price for an offer to be considered for turning into a barter */ + [JsonPropertyName("minRoubleCostToBecomeBarter")] + public double MinRoubleCostToBecomeBarter { get; set; } + + /** Should barter offers only single stack */ + [JsonPropertyName("makeSingleStackOnly")] + public bool MakeSingleStackOnly { get; set; } + + /** Item Tpls to never be turned into a barter */ + [JsonPropertyName("itemTypeBlacklist")] + public List ItemTypeBlacklist { get; set; } +} + +public class PackDetails +{ + /** Percentage change an offer is listed as a pack */ + [JsonPropertyName("chancePercent")] + public double ChancePercent { get; set; } + + /** Min number of required items for a pack */ + [JsonPropertyName("itemCountMin")] + public int ItemCountMin { get; set; } + + /** Max number of required items for a pack */ + [JsonPropertyName("itemCountMax")] + public int ItemCountMax { get; set; } + + /** item types to allow being a pack */ + [JsonPropertyName("itemTypeWhitelist")] + public List ItemTypeWhitelist { get; set; } +} + +public class OfferAdjustment +{ + /// + /// Shuld offer price be adjusted when below handbook price + /// + [JsonPropertyName("adjustPriceWhenBelowHandbookPrice")] + public bool AdjustPriceWhenBelowHandbookPrice { get; set; } + + /// + /// How big a percentage difference does price need to vary from handbook to be considered for adjustment + /// + [JsonPropertyName("maxPriceDifferenceBelowHandbookPercent")] + public double MaxPriceDifferenceBelowHandbookPercent { get; set; } + + /// + /// How much to multiply the handbook price to get the new price + /// + [JsonPropertyName("handbookPriceMultipier")] + public double HandbookPriceMultiplier { get; set; } + + /// + /// What is the minimum rouble price to consider adjusting price of item + /// + [JsonPropertyName("priceThreshholdRub")] + public double PriceThresholdRub { get; set; } +} + +public class Condition +{ + /// + /// Percentage change durability is altered + /// + [JsonPropertyName("conditionChance")] + public double ConditionChance { get; set; } + + [JsonPropertyName("current")] + public MinMax Current { get; set; } + + [JsonPropertyName("max")] + public MinMax Max { get; set; } +} + +public class RagfairBlacklist +{ + /// + /// Damaged ammo packs + /// + [JsonPropertyName("damagedAmmoPacks")] + public bool DamagedAmmoPacks { get; set; } + + /// + /// Custom blacklist for item Tpls + /// + [JsonPropertyName("custom")] + public List Custom { get; set; } + + /// + /// BSG blacklist a large number of items from flea, true = use blacklist + /// + [JsonPropertyName("enableBsgList")] + public bool EnableBsgList { get; set; } + + /// + /// Should quest items be blacklisted from flea + /// + [JsonPropertyName("enableQuestList")] + public bool EnableQuestList { get; set; } + + /// + /// Should trader items that are blacklisted by bsg be listed on flea + /// + [JsonPropertyName("traderItems")] + public bool TraderItems { get; set; } + + /// + /// Maximum level an armor plate can be found in a flea-listed armor item + /// + [JsonPropertyName("armorPlate")] + public ArmorPlateBlacklistSettings ArmorPlate { get; set; } + + /// + /// Should specific categories be blacklisted from the flea, true = use blacklist + /// + [JsonPropertyName("enableCustomItemCategoryList")] + public bool EnableCustomItemCategoryList { get; set; } + + /// + /// Custom category blacklist for parent Ids + /// + [JsonPropertyName("customItemCategoryList")] + public List CustomItemCategoryList { get; set; } +} + +public class ArmorPlateBlacklistSettings +{ + /// + /// Max level of plates an armor can have without being removed + /// + [JsonPropertyName("maxProtectionLevel")] + public int MaxProtectionLevel { get; set; } + + /// + /// Item slots to NOT remove from items on flea + /// + [JsonPropertyName("ignoreSlots")] + public List IgnoreSlots { get; set; } +} + +public class UnreasonableModPrices +{ + /// + /// Enable a system that adjusts very high ragfair prices to be below a max multiple of items the handbook values + /// + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + /// + /// Multipler to start adjusting item values from, e.g. a value of 10 means any value over 10x the handbook price gets adjusted + /// + [JsonPropertyName("handbookPriceOverMultiplier")] + public int HandbookPriceOverMultiplier { get; set; } + + /// + /// The new multiplier for items found using above property, e.g. a value of 4 means set items price to 4x handbook price + /// + [JsonPropertyName("newPriceHandbookMultiplier")] + public int NewPriceHandbookMultiplier { get; set; } +} + +public class ArmorSettings +{ + /// + /// % chance / 100 that armor plates will be removed from an offer before listing + /// + [JsonPropertyName("removeRemovablePlateChance")] + public int RemoveRemovablePlateChance { get; set; } + + /// + /// What slots are to be removed when removeRemovablePlateChance is true + /// + [JsonPropertyName("plateSlotIdToRemovePool")] + public List PlateSlotIdToRemovePool { get; set; } +} + +public class TieredFlea +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + /// + /// key: tpl, value: playerlevel + /// + [JsonPropertyName("unlocksTpl")] + public Dictionary UnlocksTpl { get; set; } + + /// + /// key: item type id, value: playerlevel + /// + [JsonPropertyName("unlocksType")] + public Dictionary UnlocksType { get; set; } + + public bool AmmoTiersEnabled { get; set; } + + [JsonPropertyName("ammoTplUnlocks")] + public Dictionary AmmoTplUnlocks { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/RepairConfig.cs b/Core/Models/Spt/Config/RepairConfig.cs new file mode 100644 index 00000000..a585e591 --- /dev/null +++ b/Core/Models/Spt/Config/RepairConfig.cs @@ -0,0 +1,110 @@ +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +using System.Text.Json.Serialization; + +public class RepairConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-repair"; + + [JsonPropertyName("priceMultiplier")] + public double PriceMultiplier { get; set; } + + [JsonPropertyName("applyRandomizeDurabilityLoss")] + public bool ApplyRandomizeDurabilityLoss { get; set; } + + [JsonPropertyName("weaponSkillRepairGain")] + public double WeaponSkillRepairGain { get; set; } + + [JsonPropertyName("armorKitSkillPointGainPerRepairPointMultiplier")] + public double ArmorKitSkillPointGainPerRepairPointMultiplier { get; set; } + + /** INT gain multiplier per repaired item type */ + [JsonPropertyName("repairKitIntellectGainMultiplier")] + public IntellectGainValues RepairKitIntellectGainMultiplier { get; set; } + + // ** How much INT can be given to player per repair action */ + [JsonPropertyName("maxIntellectGainPerRepair")] + public MaxIntellectGainValues MaxIntellectGainPerRepair { get; set; } + + [JsonPropertyName("weaponTreatment")] + public WeaponTreatmentRepairValues WeaponTreatment { get; set; } + + [JsonPropertyName("repairKit")] + public RepairKit RepairKit { get; set; } +} + +public class IntellectGainValues +{ + [JsonPropertyName("weapon")] + public double Weapon { get; set; } + + [JsonPropertyName("armor")] + public double Armor { get; set; } +} + +public class MaxIntellectGainValues +{ + [JsonPropertyName("kit")] + public double Kit { get; set; } + + [JsonPropertyName("trader")] + public double Trader { get; set; } +} + +public class WeaponTreatmentRepairValues +{ + /** The chance to gain more weapon maintenance skill */ + [JsonPropertyName("critSuccessChance")] + public double CritSuccessChance { get; set; } + + [JsonPropertyName("critSuccessAmount")] + public double CritSuccessAmount { get; set; } + + /** The chance to gain less weapon maintenance skill */ + [JsonPropertyName("critFailureChance")] + public double CritFailureChance { get; set; } + + [JsonPropertyName("critFailureAmount")] + public double CritFailureAmount { get; set; } + + /** The multiplier used for calculating weapon maintenance XP */ + [JsonPropertyName("pointGainMultiplier")] + public double PointGainMultiplier { get; set; } +} + +public class RepairKit +{ + [JsonPropertyName("armor")] + public BonusSettings Armor { get; set; } + + [JsonPropertyName("weapon")] + public BonusSettings Weapon { get; set; } +} + +public class BonusSettings +{ + [JsonPropertyName("rarityWeight")] + public Dictionary RarityWeight { get; set; } + + [JsonPropertyName("bonusTypeWeight")] + public Dictionary BonusTypeWeight { get; set; } + + [JsonPropertyName("common")] + public Dictionary Common { get; set; } + + [JsonPropertyName("rare")] + public Dictionary Rare { get; set; } +} + +public class BonusValues +{ + [JsonPropertyName("valuesMinMax")] + public MinMax ValuesMinMax { get; set; } + + /** What dura is buff active between (min max of current max) */ + [JsonPropertyName("activeDurabilityPercentMinMax")] + public MinMax ActiveDurabilityPercentMinMax { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/ScavCaseConfig.cs b/Core/Models/Spt/Config/ScavCaseConfig.cs new file mode 100644 index 00000000..776f1589 --- /dev/null +++ b/Core/Models/Spt/Config/ScavCaseConfig.cs @@ -0,0 +1,80 @@ +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +using System.Text.Json.Serialization; + +public class ScavCaseConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-scavcase"; + + [JsonPropertyName("rewardItemValueRangeRub")] + public Dictionary RewardItemValueRangeRub { get; set; } + + [JsonPropertyName("moneyRewards")] + public MoneyRewards MoneyRewards { get; set; } + + [JsonPropertyName("ammoRewards")] + public AmmoRewards AmmoRewards { get; set; } + + [JsonPropertyName("rewardItemParentBlacklist")] + public List RewardItemParentBlacklist { get; set; } + + [JsonPropertyName("rewardItemBlacklist")] + public List RewardItemBlacklist { get; set; } + + [JsonPropertyName("allowMultipleMoneyRewardsPerRarity")] + public bool AllowMultipleMoneyRewardsPerRarity { get; set; } + + [JsonPropertyName("allowMultipleAmmoRewardsPerRarity")] + public bool AllowMultipleAmmoRewardsPerRarity { get; set; } + + [JsonPropertyName("allowBossItemsAsRewards")] + public bool AllowBossItemsAsRewards { get; set; } +} + +public class MoneyRewards +{ + [JsonPropertyName("moneyRewardChancePercent")] + public int MoneyRewardChancePercent { get; set; } + + [JsonPropertyName("rubCount")] + public MoneyLevels RubCount { get; set; } + + [JsonPropertyName("usdCount")] + public MoneyLevels UsdCount { get; set; } + + [JsonPropertyName("eurCount")] + public MoneyLevels EurCount { get; set; } + + [JsonPropertyName("gpCount")] + public MoneyLevels GpCount { get; set; } +} + +public class MoneyLevels +{ + [JsonPropertyName("common")] + public MinMax Common { get; set; } + + [JsonPropertyName("rare")] + public MinMax Rare { get; set; } + + [JsonPropertyName("superrare")] + public MinMax SuperRare { get; set; } +} + +public class AmmoRewards +{ + [JsonPropertyName("ammoRewardChancePercent")] + public int AmmoRewardChancePercent { get; set; } + + [JsonPropertyName("ammoRewardBlacklist")] + public Dictionary> AmmoRewardBlacklist { get; set; } + + [JsonPropertyName("ammoRewardValueRangeRub")] + public Dictionary AmmoRewardValueRangeRub { get; set; } + + [JsonPropertyName("minStackSize")] + public int MinStackSize { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/SeasonalEventConfig.cs b/Core/Models/Spt/Config/SeasonalEventConfig.cs new file mode 100644 index 00000000..bd624ae0 --- /dev/null +++ b/Core/Models/Spt/Config/SeasonalEventConfig.cs @@ -0,0 +1,104 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Config; + +public class SeasonalEventConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-seasonalevents"; + + [JsonPropertyName("enableSeasonalEventDetection")] + public bool EnableSeasonalEventDetection { get; set; } + + /** event / botType / equipSlot / itemid */ + [JsonPropertyName("eventGear")] + public Dictionary>>> EventGear { get; set; } + + /** event / bot type / equipSlot / itemid */ + [JsonPropertyName("eventLoot")] + public Dictionary>>> EventLoot { get; set; } + + public List Events { get; set; } + + [JsonPropertyName("eventBotMapping")] + public Dictionary EventBotMapping { get; set; } + + [JsonPropertyName("eventBossSpawns")] + public Dictionary>> EventBossSpawns { get; set; } + + [JsonPropertyName("eventWaves")] + public Dictionary>> EventWaves { get; set; } + + [JsonPropertyName("gifterSettings")] + public List GifterSettings { get; set; } + + /** key = event, second key = map name */ + [JsonPropertyName("hostilitySettingsForEvent")] + public Dictionary>> HostilitySettingsForEvent { get; set; } + + /** Ids of containers on locations that only have christmas loot */ + [JsonPropertyName("christmasContainerIds")] + public List ChristmasContainerIds { get; set; } + + /** Season - botType - location (body/feet/hands/head) */ + [JsonPropertyName("botAppearanceChanges")] + public Dictionary>>> BotAppearanceChanges { get; set; } +} + +public class SeasonalEvent +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } + + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("type")] + public SeasonalEventType Type { get; set; } + + [JsonPropertyName("startDay")] + public int StartDay { get; set; } + + [JsonPropertyName("startMonth")] + public int StartMonth { get; set; } + + [JsonPropertyName("endDay")] + public int EndDay { get; set; } + + [JsonPropertyName("endMonth")] + public int EndMonth { get; set; } + + [JsonPropertyName("settings")] + public Dictionary Settings { get; set; } // TODO: Type was Record +} + +public class SeasonalEventSettings +{ + [JsonPropertyName("enabled")] + public bool Enabled { get; set; } +} + +public class ZombieSettings : SeasonalEventSettings +{ + [JsonPropertyName("mapInfectionAmount")] + public Dictionary MapInfectionAmount { get; set; } + + [JsonPropertyName("disableBosses")] + public List DisableBosses { get; set; } + + [JsonPropertyName("disableWaves")] + public List DisableWaves { get; set; } +} + +public class GifterSetting +{ + [JsonPropertyName("map")] + public string Map { get; set; } + + [JsonPropertyName("zones")] + public string Zones { get; set; } + + [JsonPropertyName("spawnChance")] + public int SpawnChance { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/TraderConfig.cs b/Core/Models/Spt/Config/TraderConfig.cs new file mode 100644 index 00000000..cefaebab --- /dev/null +++ b/Core/Models/Spt/Config/TraderConfig.cs @@ -0,0 +1,173 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +public class TraderConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-trader"; + + [JsonPropertyName("updateTime")] + public List UpdateTime { get; set; } + + [JsonPropertyName("updateTimeDefault")] + public int UpdateTimeDefault { get; set; } + + [JsonPropertyName("purchasesAreFoundInRaid")] + public bool PurchasesAreFoundInRaid { get; set; } + + /** Should trader reset times be set based on server start time (false = bsg time - on the hour) */ + [JsonPropertyName("tradersResetFromServerStart")] + public bool TradersResetFromServerStart { get; set; } + + [JsonPropertyName("traderPriceMultipler")] + public double TraderPriceMultipler { get; set; } + + [JsonPropertyName("fence")] + public FenceConfig Fence { get; set; } + + [JsonPropertyName("moddedTraders")] + public ModdedTraders ModdedTraders { get; set; } +} + +public class UpdateTime +{ + [JsonPropertyName("traderId")] + public string TraderId { get; set; } + + /** Seconds between trader resets */ + [JsonPropertyName("seconds")] + public MinMax Seconds { get; set; } +} + +public class FenceConfig +{ + [JsonPropertyName("discountOptions")] + public DiscountOptions DiscountOptions { get; set; } + + [JsonPropertyName("partialRefreshTimeSeconds")] + public int PartialRefreshTimeSeconds { get; set; } + + [JsonPropertyName("partialRefreshChangePercent")] + public double PartialRefreshChangePercent { get; set; } + + [JsonPropertyName("assortSize")] + public int AssortSize { get; set; } + + [JsonPropertyName("weaponPresetMinMax")] + public MinMax WeaponPresetMinMax { get; set; } + + [JsonPropertyName("equipmentPresetMinMax")] + public MinMax EquipmentPresetMinMax { get; set; } + + [JsonPropertyName("itemPriceMult")] + public double ItemPriceMult { get; set; } + + [JsonPropertyName("presetPriceMult")] + public double PresetPriceMult { get; set; } + + [JsonPropertyName("armorMaxDurabilityPercentMinMax")] + public ItemDurabilityCurrentMax ArmorMaxDurabilityPercentMinMax { get; set; } + + [JsonPropertyName("weaponDurabilityPercentMinMax")] + public ItemDurabilityCurrentMax WeaponDurabilityPercentMinMax { get; set; } + + /** Keyed to plate protection level */ + [JsonPropertyName("chancePlateExistsInArmorPercent")] + public Dictionary ChancePlateExistsInArmorPercent { get; set; } + + /** Key: item tpl */ + [JsonPropertyName("itemStackSizeOverrideMinMax")] + public Dictionary ItemStackSizeOverrideMinMax { get; set; } + + [JsonPropertyName("itemTypeLimits")] + public Dictionary ItemTypeLimits { get; set; } + + /** Prevent duplicate offers of items of specific categories by parentId */ + [JsonPropertyName("preventDuplicateOffersOfCategory")] + public List PreventDuplicateOffersOfCategory { get; set; } + + [JsonPropertyName("regenerateAssortsOnRefresh")] + public bool RegenerateAssortsOnRefresh { get; set; } + + /** Max rouble price before item is not listed on flea */ + [JsonPropertyName("itemCategoryRoublePriceLimit")] + public Dictionary ItemCategoryRoublePriceLimit { get; set; } + + /** Each slotid with % to be removed prior to listing on fence */ + [JsonPropertyName("presetSlotsToRemoveChancePercent")] + public Dictionary PresetSlotsToRemoveChancePercent { get; set; } + + /** Block seasonal items from appearing when season is inactive */ + [JsonPropertyName("blacklistSeasonalItems")] + public bool BlacklistSeasonalItems { get; set; } + + /** Max pen value allowed to be listed on flea - affects ammo + ammo boxes */ + [JsonPropertyName("ammoMaxPenLimit")] + public double AmmoMaxPenLimit { get; set; } + + [JsonPropertyName("blacklist")] + public List Blacklist { get; set; } + + [JsonPropertyName("coopExtractGift")] + public CoopExtractReward CoopExtractGift { get; set; } + + [JsonPropertyName("btrDeliveryExpireHours")] + public int BtrDeliveryExpireHours { get; set; } + + /** Smallest value player rep with fence can fall to */ + [JsonPropertyName("playerRepMin")] + public double PlayerRepMin { get; set; } + + /** Highest value player rep with fence can climb to */ + [JsonPropertyName("playerRepMax")] + public double PlayerRepMax { get; set; } +} + +public class ItemDurabilityCurrentMax +{ + [JsonPropertyName("current")] + public MinMax Current { get; set; } + + [JsonPropertyName("max")] + public MinMax Max { get; set; } +} + +public class CoopExtractReward : LootRequest +{ + [JsonPropertyName("sendGift")] + public bool SendGift { get; set; } + + [JsonPropertyName("messageLocaleIds")] + public List MessageLocaleIds { get; set; } + + [JsonPropertyName("giftExpiryHours")] + public int GiftExpiryHours { get; set; } +} + +public class DiscountOptions +{ + [JsonPropertyName("assortSize")] + public int AssortSize { get; set; } + + [JsonPropertyName("itemPriceMult")] + public double ItemPriceMult { get; set; } + + [JsonPropertyName("presetPriceMult")] + public double PresetPriceMult { get; set; } + + [JsonPropertyName("weaponPresetMinMax")] + public MinMax WeaponPresetMinMax { get; set; } + + [JsonPropertyName("equipmentPresetMinMax")] + public MinMax EquipmentPresetMinMax { get; set; } +} + +/** Custom trader data needed client side for things such as the clothing service */ +public class ModdedTraders +{ + /** Trader Ids to enable the clothing service for */ + [JsonPropertyName("clothingService")] + public List ClothingService { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Config/WeatherConfig.cs b/Core/Models/Spt/Config/WeatherConfig.cs new file mode 100644 index 00000000..fb70cf67 --- /dev/null +++ b/Core/Models/Spt/Config/WeatherConfig.cs @@ -0,0 +1,105 @@ +using System.Text.Json.Serialization; +using Core.Models.Common; + +namespace Core.Models.Spt.Config; + +public class WeatherConfig : BaseConfig +{ + [JsonPropertyName("kind")] + public string Kind { get; set; } = "spt-weather"; + + [JsonPropertyName("acceleration")] + public double Acceleration { get; set; } + + [JsonPropertyName("weather")] + public WeatherValues Weather { get; set; } + + [JsonPropertyName("seasonDates")] + public List SeasonDates { get; set; } + + [JsonPropertyName("overrideSeason")] + public Season? OverrideSeason { get; set; } +} + +public class SeasonDateTimes +{ + [JsonPropertyName("seasonType")] + public Season SeasonType { get; set; } + + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("startDay")] + public int StartDay { get; set; } + + [JsonPropertyName("startMonth")] + public int StartMonth { get; set; } + + [JsonPropertyName("endDay")] + public int EndDay { get; set; } + + [JsonPropertyName("endMonth")] + public int EndMonth { get; set; } +} + +public class WeatherValues +{ + [JsonPropertyName("seasonValues")] + public Dictionary SeasonValues { get; set; } + + /** How many hours to generate weather data into the future */ + [JsonPropertyName("generateWeatherAmountHours")] + public int GenerateWeatherAmountHours { get; set; } + + /** Length of each weather period */ + [JsonPropertyName("timePeriod")] + public WeatherSettings TimePeriod { get; set; } +} + +public class SeasonalValues +{ + [JsonPropertyName("clouds")] + public WeatherSettings Clouds { get; set; } + + [JsonPropertyName("windSpeed")] + public WeatherSettings WindSpeed { get; set; } + + [JsonPropertyName("windDirection")] + public WeatherSettings WindDirection { get; set; } + + [JsonPropertyName("windGustiness")] + public MinMax WindGustiness { get; set; } + + [JsonPropertyName("rain")] + public WeatherSettings Rain { get; set; } + + [JsonPropertyName("rainIntensity")] + public MinMax RainIntensity { get; set; } + + [JsonPropertyName("fog")] + public WeatherSettings Fog { get; set; } + + [JsonPropertyName("temp")] + public TempDayNight Temp { get; set; } + + [JsonPropertyName("pressure")] + public MinMax Pressure { get; set; } +} + +public class TempDayNight +{ + [JsonPropertyName("day")] + public MinMax Day { get; set; } + + [JsonPropertyName("night")] + public MinMax Night { get; set; } +} + +public class WeatherSettings +{ + [JsonPropertyName("values")] + public List Values { get; set; } + + [JsonPropertyName("weights")] + public List Weights { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Controllers/BotController.cs b/Core/Models/Spt/Controllers/BotController.cs new file mode 100644 index 00000000..ef680442 --- /dev/null +++ b/Core/Models/Spt/Controllers/BotController.cs @@ -0,0 +1,41 @@ +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Controllers; + +public class BotController +{ + public int GetBotLimit(string type) + { + throw new NotImplementedException(); + } + + public object GetBotDifficulty(string type, string difficulty) // TODO: return type was: IBotCore | IDifficultyCategories + { + throw new NotImplementedException(); + } + + public bool IsBotPmc(string botRole) + { + throw new NotImplementedException(); + } + + public bool IsBotBoss(string botRole) + { + throw new NotImplementedException(); + } + + public bool IsBotFollower(string botRole) + { + throw new NotImplementedException(); + } + + public List Generate(GenerateBotsRequestData info, bool playerscav) + { + throw new NotImplementedException(); + } + + public int GetBotCap() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Dialog/SendMessageDetails.cs b/Core/Models/Spt/Dialog/SendMessageDetails.cs new file mode 100644 index 00000000..a0d24b7b --- /dev/null +++ b/Core/Models/Spt/Dialog/SendMessageDetails.cs @@ -0,0 +1,106 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Dialog; + +public class SendMessageDetails +{ + /// + /// Player id + /// + [JsonPropertyName("recipientId")] + public string RecipientId { get; set; } + + /// + /// Who is sending this message + /// + [JsonPropertyName("sender")] + public MessageType Sender { get; set; } + + /// + /// Optional - leave blank to use sender value + /// + [JsonPropertyName("dialogType")] + public MessageType? DialogType { get; set; } + + /// + /// Optional - if sender is USER these details are used + /// + [JsonPropertyName("senderDetails")] + public IUserDialogInfo? SenderDetails { get; set; } + + /// + /// Optional - the trader sending the message + /// + [JsonPropertyName("trader")] + public Traders? Trader { get; set; } + + /// + /// Optional - used in player/system messages, otherwise templateId is used + /// + [JsonPropertyName("messageText")] + public string? MessageText { get; set; } + + /// + /// Optional - Items to send to player + /// + [JsonPropertyName("items")] + public List? Items { get; set; } + + /// + /// Optional - How long items will be stored in mail before expiry + /// + [JsonPropertyName("itemsMaxStorageLifetimeSeconds")] + public int? ItemsMaxStorageLifetimeSeconds { get; set; } + + /// + /// Optional - Used when sending messages from traders who send text from locale json + /// + [JsonPropertyName("templateId")] + public string? TemplateId { get; set; } + + /// + /// Optional - ragfair related + /// + [JsonPropertyName("systemData")] + public SystemData? SystemData { get; set; } + + /// + /// Optional - Used by ragfair messages + /// + [JsonPropertyName("ragfairDetails")] + public MessageContentRagfair? RagfairDetails { get; set; } + + /// + /// OPTIONAL - allows modification of profile settings via mail + /// + [JsonPropertyName("profileChangeEvents")] + public List? ProfileChangeEvents { get; set; } +} + +public class ProfileChangeEvent +{ + [JsonPropertyName("_id")] + public string Id { get; set; } + + [JsonPropertyName("Type")] + public ProfileChangeEventType Type { get; set; } + + [JsonPropertyName("value")] + public int Value { get; set; } + + [JsonPropertyName("entity")] + public string? Entity { get; set; } +} + +public enum ProfileChangeEventType +{ + TraderSalesSum, + TraderStanding, + ProfileLevel, + SkillPoints, + ExamineAllItems, + UnlockTrader, + AssortmentUnlockRule, + HideoutAreaLevel +} \ No newline at end of file diff --git a/Core/Models/Spt/Fence/CreateFenceAssortsResult.cs b/Core/Models/Spt/Fence/CreateFenceAssortsResult.cs new file mode 100644 index 00000000..2d0c2eed --- /dev/null +++ b/Core/Models/Spt/Fence/CreateFenceAssortsResult.cs @@ -0,0 +1,16 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Fence; + +public class CreateFenceAssortsResult +{ + [JsonPropertyName("sptItems")] + public List> SptItems { get; set; } + + [JsonPropertyName("barter_scheme")] + public Dictionary>> BarterScheme { get; set; } + + [JsonPropertyName("loyal_level_items")] + public Dictionary LoyalLevelItems { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Fence/FenceAssortGenerationValues.cs b/Core/Models/Spt/Fence/FenceAssortGenerationValues.cs new file mode 100644 index 00000000..6c39f7bf --- /dev/null +++ b/Core/Models/Spt/Fence/FenceAssortGenerationValues.cs @@ -0,0 +1,24 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Fence; + +public class FenceAssortGenerationValues +{ + [JsonPropertyName("normal")] + public GenerationAssortValues Normal { get; set; } + + [JsonPropertyName("discount")] + public GenerationAssortValues Discount { get; set; } +} + +public class GenerationAssortValues +{ + [JsonPropertyName("item")] + public int Item { get; set; } + + [JsonPropertyName("weaponPreset")] + public int WeaponPreset { get; set; } + + [JsonPropertyName("equipmentPreset")] + public int EquipmentPreset { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Generators/BotGenerator.cs b/Core/Models/Spt/Generators/BotGenerator.cs new file mode 100644 index 00000000..d4358de0 --- /dev/null +++ b/Core/Models/Spt/Generators/BotGenerator.cs @@ -0,0 +1,11 @@ +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Generators; + +public class BotGenerator +{ + public PmcInventory GenerateInventory(Inventory templateInventory, Chances equipmentChances, Generation generation, string botRole, bool isPmc) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Generators/LocationGenerator.cs b/Core/Models/Spt/Generators/LocationGenerator.cs new file mode 100644 index 00000000..8885a98a --- /dev/null +++ b/Core/Models/Spt/Generators/LocationGenerator.cs @@ -0,0 +1,18 @@ +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Generators; + +public class LocationGenerator +{ + public StaticContainerProps GenerateContainerLoot(StaticContainerProps containerIn, List staticForced, + Dictionary staticLootDist, Dictionary> staticAmmoDist, string locationName) + { + throw new NotImplementedException(); + } + + public List GenerateDynamicLoot(LooseLoot dynamicLootDist, Dictionary> staticAmmoDist, + string locationName) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Generators/PMCLootGenerator.cs b/Core/Models/Spt/Generators/PMCLootGenerator.cs new file mode 100644 index 00000000..109c46bb --- /dev/null +++ b/Core/Models/Spt/Generators/PMCLootGenerator.cs @@ -0,0 +1,14 @@ +namespace Core.Models.Spt.Generators; + +public class PMCLootGenerator +{ + public List GeneratePMCPocketLootPool() + { + throw new NotImplementedException(); + } + + public List GeneratePMCBackpackLootPool() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Generators/RagfairAssortGenerator.cs b/Core/Models/Spt/Generators/RagfairAssortGenerator.cs new file mode 100644 index 00000000..15ac2bf9 --- /dev/null +++ b/Core/Models/Spt/Generators/RagfairAssortGenerator.cs @@ -0,0 +1,11 @@ +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Generators; + +public class RagfairAssortGenerator +{ + public List GetAssortItems() + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Generators/RagfairOfferGenerator.cs b/Core/Models/Spt/Generators/RagfairOfferGenerator.cs new file mode 100644 index 00000000..aae34448 --- /dev/null +++ b/Core/Models/Spt/Generators/RagfairOfferGenerator.cs @@ -0,0 +1,13 @@ +using Core.Models.Eft.Common.Tables; +using Core.Models.Eft.Ragfair; + +namespace Core.Models.Spt.Generators; + +public class RagfairOfferGenerator +{ + public RagfairOffer CreateOffer(string userID, float time, List items, List barterScheme, int loyalLevel, int price, + bool sellInOnePiece) + { + throw new NotImplementedException(); + } +} \ No newline at end of file diff --git a/Core/Models/Spt/Hideout/CircleCraftDetails.cs b/Core/Models/Spt/Hideout/CircleCraftDetails.cs new file mode 100644 index 00000000..c496ca3e --- /dev/null +++ b/Core/Models/Spt/Hideout/CircleCraftDetails.cs @@ -0,0 +1,19 @@ +using System.Text.Json.Serialization; +using Core.Models.Spt.Config; + +namespace Core.Models.Spt.Hideout; + +public class CircleCraftDetails +{ + [JsonPropertyName("time")] + public int Time { get; set; } // this might not be the right "number" type + + [JsonPropertyName("rewardType")] + public CircleRewardType RewardType { get; set; } + + [JsonPropertyName("rewardAmountRoubles")] + public int RewardAmountRoubles { get; set; } + + [JsonPropertyName("rewardDetails")] + public CraftTimeThreshhold? RewardDetails { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Hideout/Hideout.cs b/Core/Models/Spt/Hideout/Hideout.cs new file mode 100644 index 00000000..441408d4 --- /dev/null +++ b/Core/Models/Spt/Hideout/Hideout.cs @@ -0,0 +1,22 @@ +using System.Text.Json.Serialization; +using Core.Models.Spt.Repeatable; + +namespace Core.Models.Spt.Hideout; + +public class Hideout +{ + [JsonPropertyName("areas")] + public List Areas { get; set; } + + [JsonPropertyName("customisation")] + public HideoutCustomisation Customisation { get; set; } + + [JsonPropertyName("production")] + public HideoutProductionData Production { get; set; } + + [JsonPropertyName("settings")] + public HideoutSettingsBase Settings { get; set; } + + [JsonPropertyName("qte")] + public List Qte { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Hideout/ScavCaseRewardCountsAndPrice.cs b/Core/Models/Spt/Hideout/ScavCaseRewardCountsAndPrice.cs new file mode 100644 index 00000000..61e780e3 --- /dev/null +++ b/Core/Models/Spt/Hideout/ScavCaseRewardCountsAndPrice.cs @@ -0,0 +1,30 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Hideout; + +public class ScavCaseRewardCountsAndPrice +{ + [JsonPropertyName("Common")] + public RewardCountAndPriceDetails Common { get; set; } + + [JsonPropertyName("Rare")] + public RewardCountAndPriceDetails Rare { get; set; } + + [JsonPropertyName("Superrare")] + public RewardCountAndPriceDetails Superrare { get; set; } +} + +public class RewardCountAndPriceDetails +{ + [JsonPropertyName("minCount")] + public int MinCount { get; set; } + + [JsonPropertyName("maxCount")] + public int MaxCount { get; set; } + + [JsonPropertyName("minPriceRub")] + public int MinPriceRub { get; set; } + + [JsonPropertyName("maxPriceRub")] + public int MaxPriceRub { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Inventory/OwnerInventoryItems.cs b/Core/Models/Spt/Inventory/OwnerInventoryItems.cs new file mode 100644 index 00000000..02f5e2ae --- /dev/null +++ b/Core/Models/Spt/Inventory/OwnerInventoryItems.cs @@ -0,0 +1,19 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common.Tables; + +namespace Core.Models.Spt.Inventory; + +public class OwnerInventoryItems +{ + [JsonPropertyName("from")] + public List From { get; set; } + + [JsonPropertyName("to")] + public List To { get; set; } + + [JsonPropertyName("sameInventory")] + public bool SameInventory { get; set; } + + [JsonPropertyName("isMail")] + public bool IsMail { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Location/RaidChanges.cs b/Core/Models/Spt/Location/RaidChanges.cs new file mode 100644 index 00000000..e8a757a4 --- /dev/null +++ b/Core/Models/Spt/Location/RaidChanges.cs @@ -0,0 +1,15 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Location; + +public class RaidChanges +{ + [JsonPropertyName("dynamicLootPercent")] + public float DynamicLootPercent { get; set; } + + [JsonPropertyName("staticLootPercent")] + public float StaticLootPercent { get; set; } + + [JsonPropertyName("simulatedRaidStartSeconds")] + public int SimulatedRaidStartSeconds { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Logging/ClientLogRequest.cs b/Core/Models/Spt/Logging/ClientLogRequest.cs new file mode 100644 index 00000000..07f69215 --- /dev/null +++ b/Core/Models/Spt/Logging/ClientLogRequest.cs @@ -0,0 +1,21 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Logging; + +public class ClientLogRequest +{ + [JsonPropertyName("Source")] + public string Source { get; set; } + + [JsonPropertyName("Level")] + public LogLevel Level { get; set; } + + [JsonPropertyName("Message")] + public string Message { get; set; } + + [JsonPropertyName("Color")] + public string? Color { get; set; } + + [JsonPropertyName("BackgroundColor")] + public string? BackgroundColor { get; set; } +} \ No newline at end of file diff --git a/Core/Models/Spt/Logging/LogBackgroundColor.cs b/Core/Models/Spt/Logging/LogBackgroundColor.cs new file mode 100644 index 00000000..f5853895 --- /dev/null +++ b/Core/Models/Spt/Logging/LogBackgroundColor.cs @@ -0,0 +1,16 @@ +// namespace Core.Models.Spt.Logging; +// +// public struct LogBackgroundColor +// { +// public const string DEFAULT = ""; +// public const string BLACK = "blackBG"; +// public const string RED = "redBG"; +// public const string GREEN = "greenBG"; +// public const string YELLOW = "yellowBG"; +// public const string BLUE = "blueBG"; +// public const string MAGENTA = "magentaBG"; +// public const string CYAN = "cyanBG"; +// public const string WHITE = "whiteBG"; +// } + +// TODO: this likely wont be used anymore, so commenting out insteaad of reimplementing \ No newline at end of file diff --git a/Core/Models/Spt/Logging/LogLevel.cs b/Core/Models/Spt/Logging/LogLevel.cs new file mode 100644 index 00000000..051cde1a --- /dev/null +++ b/Core/Models/Spt/Logging/LogLevel.cs @@ -0,0 +1,13 @@ +namespace Core.Models.Spt.Logging; + +public enum LogLevel +{ + ERROR = 0, + WARN = 1, + SUCCESS = 2, + INFO = 3, + CUSTOM = 4, + DEBUG = 5 +} + +// TODO: needs to be moved to enums namespace \ No newline at end of file diff --git a/Core/Models/Spt/Logging/LogTextColor.cs b/Core/Models/Spt/Logging/LogTextColor.cs new file mode 100644 index 00000000..cf7e1a20 --- /dev/null +++ b/Core/Models/Spt/Logging/LogTextColor.cs @@ -0,0 +1,16 @@ +// namespace Core.Models.Spt.Logging; +// +// public struct LogTextColor +// { +// public const string BLACK = "black"; +// public const string RED = "red"; +// public const string GREEN = "green"; +// public const string YELLOW = "yellow"; +// public const string BLUE = "blue"; +// public const string MAGENTA = "Magenta"; +// public const string CYAN = "cyan"; +// public const string WHITE = "white"; +// public const string GRAY = "gray"; +// } + +// TODO: this likely wont be used anymore, so commenting out insteaad of reimplementing \ No newline at end of file diff --git a/Core/Models/Spt/Logging/SptLogger.cs b/Core/Models/Spt/Logging/SptLogger.cs new file mode 100644 index 00000000..cd4dd87c --- /dev/null +++ b/Core/Models/Spt/Logging/SptLogger.cs @@ -0,0 +1,12 @@ +namespace Core.Models.Spt.Logging; + +public class SptLogger +{ + public object Error { get; set; } // error: (msg: string | Record) => void; + public object Warn { get; set; } // warn: (msg: string | Record) => void; + public object Succ { get; set; } // succ?: (msg: string | Record) => void; + public object Info { get; set; } // info: (msg: string | Record) => void; + public object Debug { get; set; } // debug: (msg: string | Record) => void; +} + +// TODO: needs to be reimplemented however we want to do it in this project \ No newline at end of file diff --git a/Core/Models/Spt/Mod/ModLoader.cs b/Core/Models/Spt/Mod/ModLoader.cs new file mode 100644 index 00000000..becae909 --- /dev/null +++ b/Core/Models/Spt/Mod/ModLoader.cs @@ -0,0 +1,16 @@ +namespace Core.Models.Spt.Mod; + +public class ModLoader +{ + public void Load(DependencyContainer container) + { + throw new NotImplementedException(); + } + + public string GetModPath(string mod) + { + throw new NotImplementedException(); + } +} + +// TODO: This needs to be reworked with however we do it for this project \ No newline at end of file diff --git a/Core/Models/Spt/Mod/NewItemDetails.cs b/Core/Models/Spt/Mod/NewItemDetails.cs new file mode 100644 index 00000000..d2617d07 --- /dev/null +++ b/Core/Models/Spt/Mod/NewItemDetails.cs @@ -0,0 +1,72 @@ +using System.Text.Json.Serialization; +using Core.Models.Eft.Common; + +namespace Core.Models.Spt.Mod; + +public class NewItemDetails : NewItemDetailsBase +{ + [JsonPropertyName("newItem")] + public TemplateItem NewItem { get; set; } +} + +public class NewItemFromCloneDetails : NewItemDetailsBase +{ + [JsonPropertyName("itemTplToClone")] + public string ItemTplToClone { get; set; } + + [JsonPropertyName("overrideProperties")] + public Props OverrideProperties { get; set; } + + [JsonPropertyName("parentId")] + public string ParentId { get; set; } + + [JsonPropertyName("newId")] + public string NewId { get; set; } = ""; +} + +public class NewItemDetailsBase +{ + [JsonPropertyName("fleaPriceRoubles")] + public float FleaPriceRoubles { get; set; } + + [JsonPropertyName("handbookPriceRoubles")] + public float HandbookPriceRoubles { get; set; } + + [JsonPropertyName("handbookParentId")] + public string HandbookParentId { get; set; } + + [JsonPropertyName("locales")] + public Dictionary Locales { get; set; } +} + +public class LocaleDetails +{ + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("shortName")] + public string ShortName { get; set; } + + [JsonPropertyName("description")] + public string Description { get; set; } +} + +public class CreateItemResult +{ + [JsonPropertyName("success")] + public bool Success { get; set; } + + [JsonPropertyName("itemId")] + public string ItemId { get; set; } + + [JsonPropertyName("errors")] + public List Errors { get; set; } + + public CreateItemResult() + { + Success = false; + Errors = new List(); + } +} + +// TODO: This needs to be reworked with however we do it for this project \ No newline at end of file diff --git a/Core/Models/Spt/Mod/PackageJsonData.cs b/Core/Models/Spt/Mod/PackageJsonData.cs new file mode 100644 index 00000000..e114969d --- /dev/null +++ b/Core/Models/Spt/Mod/PackageJsonData.cs @@ -0,0 +1,57 @@ +using System.Text.Json.Serialization; + +namespace Core.Models.Spt.Mod; + +public class PackageJsonData +{ + [JsonPropertyName("incompatibilities")] + public List? Incompatibilities { get; set; } + + [JsonPropertyName("loadBefore")] + public List? LoadBefore { get; set; } + + [JsonPropertyName("loadAfter")] + public List? LoadAfter { get; set; } + + [JsonPropertyName("dependencies")] + public Dictionary? Dependencies { get; set; } + + [JsonPropertyName("modDependencies")] + public Dictionary? ModDependencies { get; set; } + + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonPropertyName("url")] + public string Url { get; set; } + + [JsonPropertyName("author")] + public string Author { get; set; } + + [JsonPropertyName("version")] + public string Version { get; set; } + + [JsonPropertyName("sptVersion")] + public string SptVersion { get; set; } + + // We deliberately purge this data + [JsonPropertyName("scripts")] + public Dictionary Scripts { get; set; } + + [JsonPropertyName("devDependencies")] + public Dictionary? DevDependencies { get; set; } + + [JsonPropertyName("licence")] + public string Licence { get; set; } + + [JsonPropertyName("main")] + public string Main { get; set; } + + [JsonPropertyName("isBundleMod")] + public bool IsBundleMod { get; set; } + + [JsonPropertyName("contributors")] + public List Contributors { get; set; } +} + +// TODO: this will need changing to however we implement it in this project \ No newline at end of file diff --git a/Core/Models/Spt/Repeatable/QuestTypePool.cs b/Core/Models/Spt/Repeatable/QuestTypePool.cs index 53b45abe..eadf8713 100644 --- a/Core/Models/Spt/Repeatable/QuestTypePool.cs +++ b/Core/Models/Spt/Repeatable/QuestTypePool.cs @@ -28,7 +28,7 @@ public class QuestPool public class ExplorationPool { [JsonPropertyName("locations")] - public Dictionary> Locations { get; set; } + public Dictionary> Locations { get; set; } // TODO: check the type, originally - Partial> } public class EliminationPool @@ -40,37 +40,37 @@ public class EliminationPool public class EliminationTargetPool { [JsonPropertyName("Savage")] - public TargetLocation Savage { get; set; } + public TargetLocation? Savage { get; set; } [JsonPropertyName("AnyPmc")] - public TargetLocation AnyPmc { get; set; } + public TargetLocation? AnyPmc { get; set; } [JsonPropertyName("bossBully")] - public TargetLocation BossBully { get; set; } + public TargetLocation? BossBully { get; set; } [JsonPropertyName("bossGluhar")] - public TargetLocation BossGluhar { get; set; } + public TargetLocation? BossGluhar { get; set; } [JsonPropertyName("bossKilla")] - public TargetLocation BossKilla { get; set; } + public TargetLocation? BossKilla { get; set; } [JsonPropertyName("bossSanitar")] - public TargetLocation BossSanitar { get; set; } + public TargetLocation? BossSanitar { get; set; } [JsonPropertyName("bossTagilla")] - public TargetLocation BossTagilla { get; set; } + public TargetLocation? BossTagilla { get; set; } [JsonPropertyName("bossKnight")] - public TargetLocation BossKnight { get; set; } + public TargetLocation? BossKnight { get; set; } [JsonPropertyName("bossZryachiy")] - public TargetLocation BossZryachiy { get; set; } + public TargetLocation? BossZryachiy { get; set; } [JsonPropertyName("bossBoar")] - public TargetLocation BossBoar { get; set; } + public TargetLocation? BossBoar { get; set; } [JsonPropertyName("bossBoarSniper")] - public TargetLocation BossBoarSniper { get; set; } + public TargetLocation? BossBoarSniper { get; set; } } public class TargetLocation diff --git a/Core/Models/Spt/Server/LocaleBase.cs b/Core/Models/Spt/Server/LocaleBase.cs index 064301db..9898ffc3 100644 --- a/Core/Models/Spt/Server/LocaleBase.cs +++ b/Core/Models/Spt/Server/LocaleBase.cs @@ -1,5 +1,4 @@ using System.Text.Json.Serialization; -using System.Collections.Generic; namespace Core.Models.Spt.Server;