public async Task InitFileList()
{
string requestUri = FilesApi +
"?list" +
"&spaces=appDataFolder" +
"&q=" + Uri.EscapeDataString("trashed=false");
bool bHasValidResponse = false;
Reply reply = await HandleRequest("GET", requestUri);
if (reply.bIsSuccessful)
{
JsonParser.ObjectValue jsonOb = JsonParser.ParseJson(reply.contentBody);
if (jsonOb != null)
{
JsonParser.ArrayValue fileArr = (JsonParser.ArrayValue)jsonOb["files"];
foreach (JsonParser.Value entry in fileArr.entries)
{
JsonParser.ObjectValue entryOb = (JsonParser.ObjectValue)entry;
string mapKey = entryOb["name"];
mapFileIds.Remove(mapKey);
mapFileIds.Add(mapKey, entryOb["id"]);
}
bHasValidResponse = true;
}
}
UpdateCurrentState(bHasValidResponse);
}
private static MemoryPath CreateMemoryPath(JsonParser.ObjectValue jsonOb)
{
JsonParser.ArrayValue offsetsArr = (JsonParser.ArrayValue)jsonOb["offsets"];
long[] offsetValues = new long[offsetsArr.entries.Count];
for (int idx = 0; idx < offsetValues.Length; idx++)
{
JsonParser.IntValue intV = (JsonParser.IntValue)offsetsArr.entries[idx];
offsetValues[idx] = intV;
}
string pathType = jsonOb["type"];
if (pathType == "sig")
{
string pattern = jsonOb["sig"];
return(new MemoryPathSignature(pattern, offsetValues));
}
else if (pathType == "fixed")
{
string pattern = jsonOb["fixed"];
long[] offsetValuesFixed = new long[offsetValues.Length + 1];
offsetValuesFixed[0] = Convert.ToInt64(pattern, 16);
for (int idx = 0; idx < offsetValues.Length; idx++)
{
offsetValuesFixed[idx + 1] = offsetValues[idx];
}
return(new MemoryPath(offsetValuesFixed));
}
return(null);
}
private static void UpdateMemoryLayout(JsonParser.ArrayValue jsonArr, Type structType)
{
List <Tuple <string, int> > layoutArr = new List <Tuple <string, int> >();
for (int idx = 0; idx < jsonArr.entries.Count; idx++)
{
JsonParser.ObjectValue fieldOb = (JsonParser.ObjectValue)jsonArr.entries[idx];
JsonParser.StringValue idV = (JsonParser.StringValue)fieldOb["id"];
JsonParser.IntValue valueV = (JsonParser.IntValue)fieldOb["v"];
layoutArr.Add(new Tuple <string, int>(idV, valueV));
}
FieldInfo[] fields = structType.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo prop in fields)
{
for (int idx = 0; idx < layoutArr.Count; idx++)
{
if (prop.Name.Equals(layoutArr[idx].Item1, StringComparison.OrdinalIgnoreCase))
{
prop.SetValue(null, layoutArr[idx].Item2);
break;
}
}
}
}
public bool LoadFromJson(JsonParser.ObjectValue jsonOb)
{
bool hasLoaded = false;
try
{
Name = jsonOb["name"];
ShowOnlyMatching = (JsonParser.BoolValue)jsonOb["onlyMatching"];
version = jsonOb.entries.ContainsKey("ver") ? (JsonParser.IntValue)jsonOb["ver"] : 1;
JsonParser.ArrayValue arrFilters = (JsonParser.ArrayValue)jsonOb["filters"];
foreach (JsonParser.Value v in arrFilters.entries)
{
JsonParser.ObjectValue filterJsonOb = (JsonParser.ObjectValue)v;
ActorFilter filterOb = new ActorFilter();
bool loadedFilter = filterOb.LoadFromJson(filterJsonOb);
if (loadedFilter)
{
Filters.Add(filterOb);
}
}
hasLoaded = true;
}
catch (Exception ex)
{
Logger.WriteLine("Failed to load preset '" + jsonOb + "', exception:" + ex);
}
return(hasLoaded);
}
private bool LoadFromJson(JsonParser.ObjectValue jsonOb)
{
bool hasLoaded = false;
try
{
FontSize = (JsonParser.FloatValue)jsonOb["fontSize"];
MaxDistanceFromCenter = (JsonParser.FloatValue)jsonOb["maxCenterDist"];
MaxDistanceFromCamera = (JsonParser.FloatValue)jsonOb["maxCameraDist"];
FilterNearbyActors = jsonOb.entries.ContainsKey("filterNearby") ? (JsonParser.BoolValue)jsonOb["filterNearby"] : false;
JsonParser.ArrayValue arrPresets = (JsonParser.ArrayValue)jsonOb["presets"];
foreach (JsonParser.Value v in arrPresets.entries)
{
JsonParser.ObjectValue presetJsonOb = (JsonParser.ObjectValue)v;
ActorFilterPreset presetOb = new ActorFilterPreset();
bool loadedPreset = presetOb.LoadFromJson(presetJsonOb);
if (loadedPreset)
{
Presets.Add(presetOb);
}
}
hasLoaded = true;
}
catch (Exception ex)
{
Logger.WriteLine("Failed to load settings, exception:" + ex);
}
return(hasLoaded);
}
public List <ImageHashData> LoadImageHashes(JsonParser.ObjectValue jsonOb)
{
List <ImageHashData> list = new List <ImageHashData>();
string[] enumArr = Enum.GetNames(typeof(EImageHashType));
foreach (var kvp in jsonOb.entries)
{
EImageHashType groupType = (EImageHashType)Array.IndexOf(enumArr, kvp.Key);
JsonParser.ArrayValue typeArr = (JsonParser.ArrayValue)kvp.Value;
foreach (JsonParser.Value value in typeArr.entries)
{
JsonParser.ObjectValue jsonHashOb = (JsonParser.ObjectValue)value;
string idStr = jsonHashOb["id"];
bool hasIdNum = int.TryParse(idStr, out int idNum);
bool needsIdNum = (groupType != EImageHashType.Rule);
if (hasIdNum != needsIdNum)
{
continue;
}
ImageHashData hashEntry = new ImageHashData()
{
type = groupType, isKnown = true
};
switch (groupType)
{
case EImageHashType.Rule:
hashEntry.ownerOb = ParseRule(idStr);
break;
case EImageHashType.CardImage:
hashEntry.ownerOb = TriadCardDB.Get().cards[idNum];
break;
default:
hashEntry.ownerOb = idNum;
break;
}
if (hashEntry.ownerOb != null)
{
string descHashTLSH = jsonHashOb["hashC", JsonParser.StringValue.Empty];
string descHashMd5 = jsonHashOb["hashB", JsonParser.StringValue.Empty];
hashEntry.LoadFromString(descHashTLSH, descHashMd5);
if (hashEntry.IsValid())
{
list.Add(hashEntry);
}
}
}
}
return(list);
}
public List <ImagePatternDigit> LoadDigitHashes(JsonParser.ArrayValue jsonArr)
{
List <ImagePatternDigit> list = new List <ImagePatternDigit>();
foreach (JsonParser.Value value in jsonArr.entries)
{
JsonParser.ObjectValue jsonOb = (JsonParser.ObjectValue)value;
string hashValue = (JsonParser.StringValue)jsonOb["hash"];
ImagePatternDigit digitHash = new ImagePatternDigit((JsonParser.IntValue)jsonOb["id"], ImageDataDigit.FromHexString(hashValue));
list.Add(digitHash);
}
return(list);
}
private GameState LoadValidationConfig(string configPath)
{
GameState configData = new GameState();
string configText = File.ReadAllText(configPath);
JsonParser.ObjectValue rootOb = JsonParser.ParseJson(configText);
JsonParser.ArrayValue ruleArr = rootOb.entries["board"] as JsonParser.ArrayValue;
configData.board = new int[ruleArr.entries.Count];
for (int idx = 0; idx < ruleArr.entries.Count; idx++)
{
configData.board[idx] = ruleArr.entries[idx] as JsonParser.IntValue;
}
return(configData);
}
public static bool DownloadAndUpdateLayout(out string statusMsg)
{
bool result = false;
try
{
string jsonContent = DownloadLayoutFile("signatures.json");
statusMsg = "downloaded memory layout";
JsonParser.ObjectValue jsonOb = JsonParser.ParseJson(jsonContent);
JsonParser.ArrayValue entriesArr = (JsonParser.ArrayValue)jsonOb["layout"];
for (int idx = 0; idx < entriesArr.entries.Count; idx++)
{
JsonParser.ObjectValue entryOb = (JsonParser.ObjectValue)entriesArr.entries[idx];
string typeStr = entryOb["id"];
if (typeStr == "actors")
{
MemoryLayout.memPathActors = CreateMemoryPath(entryOb);
UpdateMemoryLayout((JsonParser.ArrayValue)entryOb["fields"], typeof(MemoryLayout.ActorConsts));
}
else if (typeStr == "target")
{
MemoryLayout.memPathTarget = CreateMemoryPath(entryOb);
UpdateMemoryLayout((JsonParser.ArrayValue)entryOb["fields"], typeof(MemoryLayout.TargetConsts));
}
else if (typeStr == "camera")
{
MemoryLayout.memPathCamera = CreateMemoryPath(entryOb);
UpdateMemoryLayout((JsonParser.ArrayValue)entryOb["fields"], typeof(MemoryLayout.CameraConsts));
}
else
{
throw new Exception("Unexpected type: " + typeStr + " in entry " + idx);
}
}
result = true;
}
catch (Exception ex)
{
statusMsg = "failed! " + ex;
}
return(result);
}
public List <ImageHashData> LoadImageHashes(JsonParser.ObjectValue jsonOb)
{
List <ImageHashData> list = new List <ImageHashData>();
string[] enumArr = Enum.GetNames(typeof(EImageHashType));
foreach (KeyValuePair <string, JsonParser.Value> kvp in jsonOb.entries)
{
EImageHashType groupType = (EImageHashType)Array.IndexOf(enumArr, kvp.Key);
JsonParser.ArrayValue typeArr = (JsonParser.ArrayValue)kvp.Value;
foreach (JsonParser.Value value in typeArr.entries)
{
JsonParser.ObjectValue jsonHashOb = (JsonParser.ObjectValue)value;
string idStr = jsonHashOb["id"];
object hashOwner = null;
switch (groupType)
{
case EImageHashType.Rule: hashOwner = ParseRule(idStr); break;
case EImageHashType.Card: hashOwner = TriadCardDB.Get().cards[int.Parse(idStr)]; break;
case EImageHashType.Cactpot: hashOwner = CactpotGame.hashDB[int.Parse(idStr) - 1]; break;
default: break;
}
if (hashOwner != null)
{
HashCollection hashes = new HashCollection(jsonHashOb["hashC", JsonParser.StringValue.Empty], jsonHashOb["hashS", JsonParser.StringValue.Empty]);
ImageHashData hashEntry = new ImageHashData(hashOwner, hashes, groupType);
list.Add(hashEntry);
}
}
}
return(list);
}
public static void RunTest(string configPath, bool debugMode)
{
string testName = System.IO.Path.GetFileNameWithoutExtension(configPath);
string configText = System.IO.File.ReadAllText(configPath);
JsonParser.ObjectValue configOb = JsonParser.ParseJson(configText);
if (configOb["type"] != "Solver")
{
return;
}
TriadGameSession testSession = new TriadGameSession();
// intial state
ScannerTriad.VerifyConfig configData = new ScannerTriad.VerifyConfig();
configData.Load(configOb);
if (mapValidationRules == null)
{
mapValidationRules = new Dictionary <string, TriadGameModifier>();
foreach (TriadGameModifier mod in ImageHashDB.Get().modObjects)
{
mapValidationRules.Add(mod.GetCodeName(), mod);
}
}
foreach (string modName in configData.rules)
{
testSession.modifiers.Add(mapValidationRules[modName]);
}
testSession.UpdateSpecialRules();
TriadGameData testGameData = new TriadGameData()
{
bDebugRules = debugMode
};
if (configData.board.Length > 0)
{
Func <ScannerTriad.VerifyCard, TriadCard> ConvertToTriadCard = configCard =>
{
if (configCard.state == ScannerTriad.ECardState.None)
{
return(null);
}
if (configCard.state == ScannerTriad.ECardState.Hidden)
{
return(TriadCardDB.Get().hiddenCard);
}
TriadCard matchingCard = !string.IsNullOrEmpty(configCard.name) ?
TriadCardDB.Get().Find(configCard.name) :
TriadCardDB.Get().Find(configCard.sides[0], configCard.sides[1], configCard.sides[2], configCard.sides[3]);
if (matchingCard == null)
{
string exceptionMsg = string.Format("Test {0} failed! Can't match validation card: '{1}' [{2},{3},{4},{5}]", testName,
configCard.name, configCard.sides[0], configCard.sides[1], configCard.sides[2], configCard.sides[3]);
throw new Exception(exceptionMsg);
}
return(matchingCard);
};
for (int idx = 0; idx < configData.board.Length; idx++)
{
var configState = configData.board[idx].state;
if (configState != ScannerTriad.ECardState.None)
{
testGameData.board[idx] = new TriadCardInstance(ConvertToTriadCard(configData.board[idx]),
(configState == ScannerTriad.ECardState.PlacedBlue) ? ETriadCardOwner.Blue :
(configState == ScannerTriad.ECardState.PlacedRed) ? ETriadCardOwner.Red :
ETriadCardOwner.Unknown);
}
}
}
var deckRed = new TriadDeck();
var deckBlue = new TriadDeck();
testGameData.deckBlue = new TriadDeckInstanceManual(deckBlue);
testGameData.deckRed = new TriadDeckInstanceManual(deckRed);
JsonParser.ArrayValue moveArr = configOb.entries["moves"] as JsonParser.ArrayValue;
for (int idx = 0; idx < moveArr.entries.Count; idx++)
{
var move = new VerifyMove();
move.Load(moveArr.entries[idx] as JsonParser.ObjectValue);
var useDeck = (move.owner == ETriadCardOwner.Blue) ? deckBlue : deckRed;
useDeck.knownCards.Add(move.card);
if (idx == 0)
{
testGameData.state = (move.owner == ETriadCardOwner.Blue) ? ETriadGameState.InProgressBlue : ETriadGameState.InProgressRed;
}
if (debugMode)
{
Logger.WriteLine("move[{0}]: [{1}] {2}: {3}", idx, move.boardPos, move.owner, move.card);
}
bool result = testSession.PlaceCard(testGameData, move.card, move.owner, move.boardPos);
if (!result)
{
string exceptionMsg = string.Format("Test {0} failed! Can't place card!", testName);
throw new Exception(exceptionMsg);
}
result = move.VerifyState(testGameData, debugMode);
if (!result)
{
string exceptionMsg = string.Format("Test {0} failed! Finished with bad state!", testName);
throw new Exception(exceptionMsg);
}
}
}
public bool LoadFromJson(string jsonStr)
{
TriadCardDB cardDB = TriadCardDB.Get();
TriadNpcDB npcDB = TriadNpcDB.Get();
try
{
JsonParser.ObjectValue jsonOb = JsonParser.ParseJson(jsonStr);
JsonParser.ObjectValue uiOb = (JsonParser.ObjectValue)jsonOb["ui", null];
if (uiOb != null)
{
useAutoScan = (JsonParser.BoolValue)uiOb["autoScan", JsonParser.BoolValue.Empty];
}
JsonParser.ObjectValue cloudOb = (JsonParser.ObjectValue)jsonOb["cloud", null];
if (cloudOb != null)
{
useCloudStorage = (JsonParser.BoolValue)cloudOb["use", JsonParser.BoolValue.Empty];
cloudToken = (JsonParser.StringValue)cloudOb["token", null];
}
JsonParser.ArrayValue cardsArr = (JsonParser.ArrayValue)jsonOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)value;
ownedCards.Add(cardDB.cards[cardId]);
}
JsonParser.ArrayValue npcsArr = (JsonParser.ArrayValue)jsonOb["npcs", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in npcsArr.entries)
{
int npcId = (JsonParser.IntValue)value;
completedNpcs.Add(npcDB.npcs[npcId]);
}
JsonParser.ArrayValue decksArr = (JsonParser.ArrayValue)jsonOb["decks", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in decksArr.entries)
{
JsonParser.ObjectValue deckOb = (JsonParser.ObjectValue)value;
int npcId = (JsonParser.IntValue)deckOb["id"];
TriadNpc npc = TriadNpcDB.Get().npcs[npcId];
if (npc != null)
{
TriadDeck deckCards = new TriadDeck();
cardsArr = (JsonParser.ArrayValue)deckOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value cardValue in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)cardValue;
deckCards.knownCards.Add(cardDB.cards[cardId]);
}
lastDeck.Add(npc, deckCards);
}
}
JsonParser.ArrayValue favDecksArr = (JsonParser.ArrayValue)jsonOb["favDecks", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in favDecksArr.entries)
{
JsonParser.ObjectValue deckOb = (JsonParser.ObjectValue)value;
TriadDeckNamed deckCards = new TriadDeckNamed();
cardsArr = (JsonParser.ArrayValue)deckOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value cardValue in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)cardValue;
deckCards.knownCards.Add(cardDB.cards[cardId]);
}
if (deckCards.knownCards.Count > 0)
{
deckCards.Name = deckOb["name", JsonParser.StringValue.Empty];
favDecks.Add(deckCards);
}
}
JsonParser.ObjectValue imageHashesOb = (JsonParser.ObjectValue)jsonOb["images", null];
if (imageHashesOb != null)
{
customHashes = ImageHashDB.Get().LoadImageHashes(imageHashesOb);
}
JsonParser.ArrayValue digitHashesArr = (JsonParser.ArrayValue)jsonOb["digits", null];
if (digitHashesArr != null)
{
customDigits = ImageHashDB.Get().LoadDigitHashes(digitHashesArr);
}
}
catch (Exception ex)
{
Logger.WriteLine("Loading failed! Exception:" + ex);
}
return(ownedCards.Count > 0);
}
public bool LoadFromJson(string jsonStr)
{
TriadCardDB cardDB = TriadCardDB.Get();
TriadNpcDB npcDB = TriadNpcDB.Get();
ownedCards.Clear();
completedNpcs.Clear();
lastDeck.Clear();
favDecks.Clear();
try
{
JsonParser.ObjectValue jsonOb = JsonParser.ParseJson(jsonStr);
JsonParser.ObjectValue uiOb = (JsonParser.ObjectValue)jsonOb["ui", null];
if (uiOb != null)
{
JsonParser.Value BoolTrue = new JsonParser.BoolValue(true);
JsonParser.Value BoolFalse = new JsonParser.BoolValue(false);
useXInput = (JsonParser.BoolValue)uiOb["xInput", BoolTrue];
alwaysOnTop = (JsonParser.BoolValue)uiOb["onTop", BoolFalse];
forcedLanguage = (JsonParser.StringValue)uiOb["lang", null];
TryGettingFloatValue(uiOb, "fontSize", ref fontSize);
TryGettingFloatValue(uiOb, "markerCard", ref markerDurationCard);
TryGettingFloatValue(uiOb, "markerSwap", ref markerDurationSwap);
TryGettingFloatValue(uiOb, "markerCactpot", ref markerDurationCactpot);
TryGettingIntValue(uiOb, "lastNpcId", ref lastNpcId);
TryGettingFloatValue(uiOb, "lastWidth", ref lastWidth);
TryGettingFloatValue(uiOb, "lastHeight", ref lastHeight);
fontSize = Math.Min(Math.Max(fontSize, 10), 40);
}
JsonParser.ObjectValue cloudOb = (JsonParser.ObjectValue)jsonOb["cloud", null];
if (cloudOb != null)
{
useCloudStorage = (JsonParser.BoolValue)cloudOb["use", JsonParser.BoolValue.Empty];
cloudToken = (JsonParser.StringValue)cloudOb["token", null];
}
JsonParser.ArrayValue cardsArr = (JsonParser.ArrayValue)jsonOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)value;
ownedCards.Add(cardDB.cards[cardId]);
}
JsonParser.ArrayValue npcsArr = (JsonParser.ArrayValue)jsonOb["npcs", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in npcsArr.entries)
{
int npcId = (JsonParser.IntValue)value;
completedNpcs.Add(npcDB.npcs[npcId]);
}
JsonParser.ArrayValue decksArr = (JsonParser.ArrayValue)jsonOb["decks", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in decksArr.entries)
{
JsonParser.ObjectValue deckOb = (JsonParser.ObjectValue)value;
int npcId = (JsonParser.IntValue)deckOb["id"];
TriadNpc npc = TriadNpcDB.Get().npcs[npcId];
if (npc != null)
{
TriadDeck deckCards = new TriadDeck();
cardsArr = (JsonParser.ArrayValue)deckOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value cardValue in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)cardValue;
deckCards.knownCards.Add(cardDB.cards[cardId]);
}
lastDeck.Add(npc, deckCards);
}
}
JsonParser.ArrayValue favDecksArr = (JsonParser.ArrayValue)jsonOb["favDecks", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value value in favDecksArr.entries)
{
JsonParser.ObjectValue deckOb = (JsonParser.ObjectValue)value;
TriadDeckNamed deckCards = new TriadDeckNamed();
cardsArr = (JsonParser.ArrayValue)deckOb["cards", JsonParser.ArrayValue.Empty];
foreach (JsonParser.Value cardValue in cardsArr.entries)
{
int cardId = (JsonParser.IntValue)cardValue;
deckCards.knownCards.Add(cardDB.cards[cardId]);
}
if (deckCards.knownCards.Count > 0)
{
deckCards.Name = deckOb["name", JsonParser.StringValue.Empty];
favDecks.Add(deckCards);
}
}
JsonParser.ObjectValue imageHashesOb = (JsonParser.ObjectValue)jsonOb["images", null];
if (imageHashesOb != null)
{
customHashes = ImageHashDB.Get().LoadImageHashes(imageHashesOb);
ImageHashDB.Get().hashes.AddRange(customHashes);
}
}
catch (Exception ex)
{
Logger.WriteLine("Loading failed! Exception:" + ex);
}
Logger.WriteLine("Loaded player cards: " + ownedCards.Count + ", npcs: " + completedNpcs.Count + ", hashes: " + customHashes.Count);
return(ownedCards.Count > 0);
}
