public async Task <AbstractDownloadState?> GetDownloaderState(dynamic archiveINI, bool quickMode)
{
var general = archiveINI.General;
if (general.modID != null && general.fileID != null && general.gameName != null)
{
var game = GameRegistry.GetByFuzzyName((string)general.gameName).Game;
if (quickMode)
{
return(new State
{
Game = GameRegistry.GetByFuzzyName((string)general.gameName).Game,
ModID = long.Parse(general.modID),
FileID = long.Parse(general.fileID),
});
}
var client = DownloadDispatcher.GetInstance <NexusDownloader>().Client ?? await NexusApiClient.Get();
ModInfo info;
try
{
info = await client.GetModInfo(game, long.Parse((string)general.modID));
}
catch (Exception)
{
return(new State
{
Game = GameRegistry.GetByFuzzyName((string)general.gameName).Game,
ModID = long.Parse(general.modID),
FileID = long.Parse(general.fileID),
});
}
try
{
return(new State
{
Name = NexusApiUtils.FixupSummary(info.name),
Author = NexusApiUtils.FixupSummary(info.author),
Version = general.version ?? "0.0.0.0",
ImageURL = info.picture_url,
IsNSFW = info.contains_adult_content,
Description = NexusApiUtils.FixupSummary(info.summary),
Game = GameRegistry.GetByFuzzyName((string)general.gameName).Game,
ModID = long.Parse(general.modID),
FileID = long.Parse(general.fileID)
});
}
catch (FormatException)
{
Utils.Log(
$"Cannot parse ModID/FileID from {(string)general.gameName} {(string)general.modID} {(string)general.fileID}");
throw;
}
}
return(null);
}
public async Task <NexusApiClient.GetModFilesResponse> GetModFiles(string GameName, long ModId)
{
Utils.Log($"Nexus Mod Files {GameName} {ModId}");
var game = GameRegistry.GetByFuzzyName(GameName).Game;
var result = await SQL.GetModFiles(game, ModId);
string method = "CACHED";
if (result == null)
{
var api = await NexusApiClient.Get(Request.Headers["apikey"].FirstOrDefault());
result = await api.GetModFiles(game, ModId, false);
await SQL.AddNexusModFiles(game, ModId, DateTime.UtcNow, result);
method = "NOT_CACHED";
Interlocked.Increment(ref ForwardCount);
}
else
{
Interlocked.Increment(ref CachedCount);
}
Response.Headers.Add("x-cache-result", method);
return(result);
}
public override async Task <bool> Verify(Archive a)
{
try
{
var gameMeta = GameRegistry.GetByMO2ArchiveName(GameName) ?? GameRegistry.GetByNexusName(GameName);
if (gameMeta == null)
{
return(false);
}
var game = gameMeta.Game;
if (!int.TryParse(ModID, out var modID))
{
return(false);
}
var client = await NexusApiClient.Get();
var modFiles = await client.GetModFiles(game, modID);
if (!ulong.TryParse(FileID, out var fileID))
{
return(false);
}
var found = modFiles.files
.FirstOrDefault(file => file.file_id == fileID && file.category_name != null);
return(found != null);
}
catch (Exception ex)
{
Utils.Log($"{ModName} - {GameName} - {ModID} - {FileID} - Error getting Nexus download URL - {ex}");
return(false);
}
}
public void RemoveGame(GameRegistry gameRegistry)
{
_logger.LogInformation($"Removing Game with id: {gameRegistry.Name}.");
_redisCacheClient.Db0.RemoveAsync(gameRegistry.Name).Wait();
gameRegistry.GameState = GameStates.NoGame;
SaveGameRegistryPersistent(gameRegistry, true).Wait();
}
internal static void DisableQueuedGadgets()
{
Logger.Log("Unloading Gadgets...");
foreach (GadgetInfo gadget in QueuedGadgets)
{
gadget.Gadget.Unload();
LootTables.RemoveModEntries(gadget.Gadget.ModID);
GadgetCoreAPI.RemoveModResources(gadget.Gadget.ModID);
GadgetCoreAPI.UnregisterStatModifiers(gadget.Gadget.ModID);
GadgetNetwork.UnregisterSyncVars(gadget.Gadget.ModID);
PlanetRegistry.UnregisterGadget(gadget.Gadget.ModID);
foreach (Registry reg in GameRegistry.ListAllRegistries())
{
reg.UnregisterGadget(gadget);
}
}
Logger.Log("Done unloading Gadgets.");
Logger.Log("Unpatching Gadgets...");
foreach (GadgetInfo gadget in QueuedGadgets.ToList())
{
try
{
gadget.Gadget.HarmonyInstance.UnpatchAll(gadget.Mod.Name + "." + gadget.Attribute.Name + ".gadget");
}
catch (Exception e)
{
Logger.LogError("Exception Unpatching Gadget '" + gadget.Attribute.Name + "':" + Environment.NewLine + e.ToString());
}
}
Logger.Log("Done patching Gadgets.");
Logger.Log("Sorting Gadgets...");
Gadgets.SortGadgets();
Logger.Log("Done sorting Gadgets.");
QueuedGadgets.Clear();
}
public async Task <IActionResult> IngestNexusFile()
{
long totalRows = 0;
var dataPath = @"nexus_export.json".RelativeTo(_settings.TempPath);
var data = JsonConvert.DeserializeObject <NexusIngestHeader>(await dataPath.ReadAllTextAsync());
foreach (var record in data.ModInfos)
{
await SQL.AddNexusModInfo(GameRegistry.GetByFuzzyName(record.Game).Game, record.ModId,
record.LastCheckedUTC, record.Data);
totalRows += 1;
}
foreach (var record in data.FileInfos)
{
await SQL.AddNexusFileInfo(GameRegistry.GetByFuzzyName(record.Game).Game, record.ModId,
long.Parse(record.FileId),
record.LastCheckedUTC, record.Data);
totalRows += 1;
}
foreach (var record in data.ModFiles)
{
await SQL.AddNexusModFiles(GameRegistry.GetByFuzzyName(record.Game).Game, record.ModId,
record.LastCheckedUTC, record.Data);
totalRows += 1;
}
return(Ok(totalRows));
}
public async Task <AbstractDownloadState> GetDownloaderState(dynamic archiveINI)
{
var gameName = (string)archiveINI?.General?.gameName;
var gameFile = (string)archiveINI?.General?.gameFile;
if (gameFile == null || gameFile == null)
{
return(null);
}
var game = GameRegistry.GetByMO2ArchiveName(gameName);
if (game == null)
{
return(null);
}
var path = game.GameLocation();
var filePath = Path.Combine(path, gameFile);
if (!File.Exists(filePath))
{
return(null);
}
var hash = filePath.FileHashCached();
return(new State
{
Game = GameRegistry.GetByMO2ArchiveName(gameName).Game,
GameFile = gameFile,
Hash = hash,
});
}
public ObstacleType(string desc, string name, params RequireWrapper[] reqs)
{
this.desc = desc;
requirements = reqs;
this.name = this.GetType().Name + name;
GameRegistry.RegisterObstacle(this);
}
private async Task <object> HandleGetFiles(dynamic arg)
{
Utils.Log($"{DateTime.Now} - Mod Files - {arg.GameName} {arg.ModID}");
var api = await NexusApiClient.Get(Request.Headers["apikey"].FirstOrDefault());
return(api.GetModFiles(GameRegistry.GetByNexusName((string)arg.GameName).Game, (int)arg.ModID).ToJSON());
}
public async Task <ActionResult <NexusFileInfo> > GetModFile(string GameName, long ModId, long FileId)
{
try
{
var game = GameRegistry.GetByFuzzyName(GameName).Game;
var result = await _sql.GetModFile(game, ModId, FileId);
string method = "CACHED";
if (result == null)
{
var api = await GetClient();
result = await api.GetModFile(game, ModId, FileId, false);
var date = result.uploaded_time;
date = date == default ? DateTime.UtcNow : date;
await _sql.AddNexusModFile(game, ModId, FileId, date, result);
method = "NOT_CACHED";
Interlocked.Increment(ref ForwardCount);
}
else
{
Interlocked.Increment(ref CachedCount);
}
Response.Headers.Add("x-cache-result", method);
return(result);
}
catch (Exception ex)
{
_logger.LogInformation("Unable to find mod file {GameName} {ModId}, {FileId}", GameName, ModId, FileId);
return(NotFound());
}
}
public async Task <NexusApiClient.GetModFilesResponse> GetModFiles(string GameName, long ModId)
{
_logger.Log(LogLevel.Information, $"{GameName} {ModId}");
var game = GameRegistry.GetByFuzzyName(GameName).Game;
var result = await _sql.GetModFiles(game, ModId);
string method = "CACHED";
if (result == null)
{
var api = await NexusApiClient.Get(Request.Headers["apikey"].FirstOrDefault());
result = await api.GetModFiles(game, ModId, false);
var date = result.files.Select(f => f.uploaded_time).OrderByDescending(o => o).FirstOrDefault();
date = date == default ? DateTime.UtcNow : date;
await _sql.AddNexusModFiles(game, ModId, date, result);
method = "NOT_CACHED";
Interlocked.Increment(ref ForwardCount);
}
else
{
Interlocked.Increment(ref CachedCount);
}
Response.Headers.Add("x-cache-result", method);
return(result);
}
public static void update()
{
foreach (Industry ind in Main.instance.player.builtItems)
{
GameObject go;
enchantInvenList.TryGetValue(ind, out go);
if (go != null)
{
go.transform.Find("Quantity").GetComponent <Text>().text = Main.AsCurrency(ind.quantityStored) + " / " + Main.AsCurrency(10000);
}
else
{
enchantIngredList.TryGetValue(ind, out go);
if (go != null)
{
//int v = (ind.quantityStored > int.MaxValue ? 999999999 : BigInteger.ToInt32(ind.quantityStored));
//ItemStack stack = new ItemStack(ind, v);
Enchantment e = GameRegistry.GetEnchantmentByItem(ind.industryItem);
go.transform.Find("Quantity").GetComponent <Text>().text = Main.AsCurrency(ind.quantityStored) + " / " + Main.AsCurrency(e.ingredientQuantity);
}
}
}
foreach (ItemStack stack in Main.instance.player.miscInventory)
{
GameObject go;
enchantMiscInvenList.TryGetValue(stack, out go);
Enchantment e = GameRegistry.GetEnchantmentByItem(stack.item);
if (go != null && e != null)
{
go.transform.Find("Quantity").GetComponent <Text>().text = Main.AsCurrency(stack.stackSize) + " / " + Main.AsCurrency(e.ingredientQuantity);
}
}
}
static void Main(string[] args)
{
GameRegistry.Initialize();
Server room = new Server(44325, 0.02f);
room.Start();
while (true)
{
room.Update();
if (Console.KeyAvailable)
{
ConsoleKeyInfo key = Console.ReadKey(true);
switch (key.Key)
{
case ConsoleKey.F1:
room.Stop();
return;
default:
break;
}
}
}
}
public async Task <AbstractDownloadState?> GetDownloaderState(dynamic archiveINI, bool quickMode)
{
var gameName = (string?)archiveINI?.General?.gameName;
var gameFile = (string?)archiveINI?.General?.gameFile;
if (gameName == null || gameFile == null)
{
return(null);
}
if (!GameRegistry.TryGetByFuzzyName(gameName, out var game))
{
return(null);
}
var path = game.TryGetGameLocation();
var filePath = path?.Combine(gameFile);
if (!(filePath?.Exists ?? false))
{
return(null);
}
var fp = filePath.Value;
var hash = await fp.FileHashCachedAsync();
return(new State(game.InstalledVersion)
{
Game = game.Game,
GameFile = (RelativePath)gameFile,
Hash = hash
});
}
public async Task <ModInfo> GetModInfo(string GameName, long ModId)
{
var game = GameRegistry.GetByFuzzyName(GameName).Game;
var result = await _sql.GetNexusModInfoString(game, ModId);
string method = "CACHED";
if (result == null)
{
var api = await GetClient();
result = await api.GetModInfo(game, ModId, false);
await _sql.AddNexusModInfo(game, ModId, result.updated_time, result);
method = "NOT_CACHED";
Interlocked.Increment(ref ForwardCount);
}
else
{
Interlocked.Increment(ref CachedCount);
}
Response.Headers.Add("x-cache-result", method);
return(result);
}
public async Task <AbstractDownloadState> GetDownloaderState(dynamic archiveINI)
{
var general = archiveINI?.General;
if (general.modID != null && general.fileID != null && general.gameName != null)
{
var name = (string)general.gameName;
var gameMeta = GameRegistry.GetByMO2ArchiveName(name);
var game = gameMeta != null?GameRegistry.GetByMO2ArchiveName(name).Game : GameRegistry.GetByNexusName(name).Game;
var client = await NexusApiClient.Get();
var info = await client.GetModInfo(game, general.modID);
return(new State
{
GameName = general.gameName,
FileID = general.fileID,
ModID = general.modID,
Version = general.version ?? "0.0.0.0",
Author = info.author,
UploadedBy = info.uploaded_by,
UploaderProfile = info.uploaded_users_profile_url,
ModName = info.name,
SlideShowPic = info.picture_url,
NexusURL = NexusApiUtils.GetModURL(game, info.mod_id),
Summary = info.summary,
Adult = info.contains_adult_content
});
}
return(null);
}
public static string ConvertGameName(string gameName)
{
if (Regex.IsMatch(gameName, @"^[^a-z\s]+\.[^a-z\s]+$"))
{
return(gameName);
}
return(GameRegistry.GetByMO2ArchiveName(gameName)?.NexusName ?? gameName.ToLower());
}
void Start()
{
GameRegistry.AssignItemDatabase(this);
/* Items are now created using the inspector, due to problems with WebGL builds.
* items = new List<Item> ();
* fillDatabase ();*/
}
public QuestChallenge(SerializationInfo info, StreamingContext context)
{
string ID = info.GetString("quest_id");
type = GameRegistry.GetObstacleByID(ID);
//UnityEngine.Debug.Log("ID: " + ID + ", " + type);
questBonus = info.GetInt32("bonus");
monsterHealth = info.GetInt32("monsterHealth");
}
public Enchantment(string enchantName, Item ingredientHerb, int quantity, ItemEquipType restrictions, RequirementType satisfiesReq)
{
name = enchantName;
ingredient = ingredientHerb;
ingredientQuantity = quantity;
enchantSlotRestriction = restrictions;
reqTypes = satisfiesReq;
GameRegistry.RegisterEnchantment(this);
}
public override Block GetBlock(int x, int y, int z)
{
var chunkInWorld = ChunkInWorld(x, y, z);
var blockInChunk = BlockInChunk(x, y, z);
return(LoadedChunks.TryGetValue(chunkInWorld, out Chunk chunk)
? GameRegistry.GetBlock(chunk.GetBlock(blockInChunk))
: BlockRegistry.BlockAir);
}
protected override async Task <ExitCode> Run()
{
var game = GameRegistry.GetByFuzzyName(GameName).Game;
var p = await HTMLInterface.GetUploadPermissions(game, ModId);
Console.WriteLine($"Game: {game}");
Console.WriteLine($"ModId: {ModId}");
Console.WriteLine($"Permissions: {p}");
return(ExitCode.Ok);
}
private static void FilterEnchantIngredients(int filter)
{
GameObject go;
List <GameObjectPair> ingreds = new List <GameObjectPair>();
for (var i = 0; i < inventoryList2.childCount; i++)
{
go = inventoryList2.GetChild(i).gameObject;
KeyValuePair <ItemStack, GameObject> stack = enchantMiscInvenList.FirstOrDefault(x => x.Value == go);
KeyValuePair <Industry, GameObject> ind = enchantIngredList.FirstOrDefault(x => x.Value == go);
Enchantment ench = null;
if (stack.Key != null)
{
ench = GameRegistry.GetEnchantmentByItem(stack.Key.item);
}
if (ind.Key != null)
{
ench = GameRegistry.GetEnchantmentByItem(ind.Key.industryItem);
}
if (ench != null && (filter < 0 || ((int)ench.enchantSlotRestriction & filter) > 0))
{
go.SetActive(true);
//go.transform.localPosition = new Vector3(6, (i * -125) - 5, 0);
ingreds.Add(new GameObjectPair(go.transform, ind.Key, stack.Key));
}
else
{
if (ench != null)
{
go.SetActive(false);
}
}
}
/*for(var i = 0; i < inventoryList2.childCount; i++) {
* Transform t = inventoryList2.GetChild(i);
* KeyValuePair<ItemStack, GameObject> stack;
* stack = enchantMiscInvenList.FirstOrDefault(x => x.Value == t.gameObject);
* KeyValuePair<Industry, GameObject> ind;
* ind = enchantIngredList.FirstOrDefault(x => x.Value == t.gameObject);
* ingreds.Add(new GameObjectPair(t, ind.Key, stack.Key));
* }*/
ingreds.Sort((x, y) => {
var v = y.val.CompareTo(x.val);
return(v != 0 ? v : x.name.CompareTo(y.name));
});
for (var i = 0; i < ingreds.Count; i++)
{
ingreds[i].t.localPosition = new Vector3(6, (i * -125) - 5, 0);
}
((RectTransform)inventoryList2).SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, ingreds.Count * 126 + 5);
inventoryList2.transform.localPosition = Vector3.zero;
}
public GameRegistry GetDefaultRegistry()
{
var exileReg = GetEmbeddedResource(EXILE_REGISTRY_FILENAME);
var revelationReg = GetEmbeddedResource(REVELATION_REGISTRY_FILENAME);
var registry = new GameRegistry();
registry.Exile = DeserializeRegistry(exileReg);
registry.Revelation = DeserializeRegistry(revelationReg);
return(registry);
}
public async Task <IActionResult> GetFiles(string game, string version)
{
if (!GameRegistry.TryGetByFuzzyName(game, out var meta))
{
return(NotFound($"Game {game} not found"));
}
var files = await _sql.GetGameFiles(meta.Game, version);
return(Ok(files.ToJson()));
}
public void SaveRegistryToDisk(GameRegistry registry, string selectedGame, string filePath)
{
if (selectedGame.ToUpper() == "EXILE")
{
SaveRegistryFile(filePath, registry.Exile);
}
if (selectedGame.ToUpper() == "REVELATION")
{
SaveRegistryFile(filePath, registry.Revelation);
}
}
public void RegenTreeView(GameRegistry registry)
{
var games = new List <TreeNode>();
var exileNodes = NodesForAssetRegistry(registry.Exile);
games.Add(new TreeNode("Exile", exileNodes.ToArray()));
var revNodes = NodesForAssetRegistry(registry.Revelation);
games.Add(new TreeNode("Revelation", revNodes.ToArray()));
PopulateNodes(games.ToArray());
}
public void FinishLoad()
{
//if(StatisticsTracker.guildmastersElected.value == 0) {
//renown = totalRenown = 100000;
//}
currentVendors = 0;
//renown = totalRenown = 100000; //for testing
//if(industriesFromDisk == null) return;
for (int o = 0; o < industriesFromDisk.Count; o++)
{
Industry ind;
if (Main.saveVersionFromDisk >= 14)
{
ind = GameRegistry.GetIndustryByID(industriesFromDisk[o].name);
}
else
{
#pragma warning disable CS0612 // Type or member is obsolete
ind = GameRegistry.GetIndustryByID(industriesFromDisk[o].ID);
#pragma warning restore CS0612 // Type or member is obsolete
}
ind.ReadFromCopy(industriesFromDisk[o].ind);
if (ind.level > 0)
{
CraftingManager.BuildIndustry(ind, true, false);
currentVendors += ind.getRawVendors();
}
}
industriesFromDisk.Clear();
industriesFromDisk = null;
for (int o = 0; o < questsFromDisk.Count; o++)
{
questsFromDisk[o].quest.FinishLoad();
QuestManager.availableQuests.Add(questsFromDisk[o].quest);
}
questsFromDisk.Clear();
questsFromDisk = null;
for (int o = 0; o < activeQuestsFromDisk.Count; o++)
{
activeQuestsFromDisk[o].quest.FinishLoad();
QuestManager.activeQuests.Add(activeQuestsFromDisk[o].quest);
}
activeQuestsFromDisk.Clear();
activeQuestsFromDisk = null;
UpgradeValueWrapper wrap;
Main.instance.player.upgrades.TryGetValue(UpgradeType.MONEY_INCOME, out wrap);
Main.instance.player.miscInventory.ForEach(x => {
if (x.antiquity > 0 || x.relicData != null)
{
x.stackSize = 1;
}
});
}
void Awake()
{
GameRegistry.AssignSpellDatabase(this);
foreach (var spell in spells)
{
if (spell.Prefab != null)
{
Debug.Log("Bound prefab to database");
spell.Prefab.GetComponent <Castable> ().BindCastableToSpell(spell);
}
}
}
public void addItemToInventory(ItemStack stack, Quest theQuest, bool doNotify)
{
int v = addItemToInventory(stack);
Enchantment ench = GameRegistry.GetEnchantmentByItem(stack.item);
//TODO: does not seem to be working correctly
if (v == stack.stackSize || (ench != null && v >= ench.ingredientQuantity && v - stack.stackSize < ench.ingredientQuantity))
{
//Debug.Log(stack.item.name + " +" + stack.stackSize + " = " + v + "|" + (ench != null?""+ench.ingredientQuantity:"no enchant"));
NotificationItem notify = new NotificationItem(theQuest.heroName, "Found: " + Main.ToTitleCase(stack.item.name) + "\nAdded to your stocks", SpriteLoader.getSpriteForResource("items/" + stack.item.name));
GuiManager.ShowNotification(notify);
}
}
private async Task<TelegramBotReply> onPlayerPicked(User u, TelegramBot.TelegramBot bot, Message m, GameRegistry.Game game)
{
const string viewMembership = "is picking someone to view his/her membership";
var flowObj = new PickPlayerFlow(game, onPickedMembershipTarget);
if (u == m.From)
{
await AnnounceMessage(u, bot, viewMembership);
m.From.MessageFlow = new MessageFlow(u, new FlowObject { Handler = flowObj });
return Message(m, "You cheating bastard! Pick the one you would like to view the membership off.", replyMarkup: flowObj.GetKeyboard());
}
else
{
await AnnounceMessage(u, bot, viewMembership);
u.MessageFlow = new MessageFlow(u, new FlowObject { Handler = flowObj });
await Message(u.ID, "You've been chosen to view somebody's membership. Please pick one.", replyMarkup: flowObj.GetKeyboard()).HandleReply(bot);
}
return Message(m, $"You have chosen {u.Bold()} to pick a player", replyMarkup: HostMessageHandler.HostKeyboard, userMarkup: true);
}
public LeaveMessageConfirm(GameRegistry.Game game, User user)
{
this.game = game;
this.user = user;
}
public WallObject()
{
this.registry = GameRegistry.Instance;
}
private async Task<TelegramBotReply> onPickedMembershipTarget(User u, TelegramBot.TelegramBot bot, Message m, GameRegistry.Game game)
{
await AnnounceMessage(m.From, bot, $"has chosen to view {u.Bold()}'s membership");
return Message(m, $"The role of {u.Bold()} is {game.GetRole(u).Membership.Bold()}", replyMarkup: game.Host == m.From ? HostMessageHandler.HostKeyboard : JoinMessageHandler.JoinedPlayerKeyboard, userMarkup: true);
}
public PickPlayerFlow(GameRegistry.Game game, Func<User, TelegramBot.TelegramBot, Message, GameRegistry.Game, Task<TelegramBotReply>> onPlayerPicked)
{
this.game = game;
this.onPlayerPicked = onPlayerPicked;
}
