private static void ListBlocks(IList args, IMethodContext context) { ImplLogger.LogImpl("listblocks", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); Log.Write("TypeName/SubtypeName \"Name\" [IntityId]"); Log.WriteLine(); foreach (var block in blocks) { Log.WriteFormat("{0}/{1} \"{2}\" [{3}]", new object[] { block.GetType().Name, block.BlockDefinition.SubtypeName, block.CustomName, block.EntityId }); } }
private Field GetNextField(int[,] matrix, int[,] costMatrix, MatchingType matchingType, Field startField) { Field nextField = null; if (startField.x == 0) { nextField = startField; nextField.y--; } else if (startField.y == 0) { nextField = startField; nextField.x--; } else { int value = matrix[startField.x, startField.y]; int nextValue; int bestNextValue; Compare compare; switch (matchingType) { case MatchingType.Maximal: bestNextValue = int.MinValue; compare = delegate(int a, int b) { return(a > b); }; break; case MatchingType.Minimal: default: bestNextValue = int.MaxValue; compare = delegate(int a, int b) { return(a < b); }; break; } Field field = new Field(startField.x - 1, startField.y - 1); nextValue = matrix[field.x, field.y]; if (costMatrix[u[field.x], w[field.y]] + nextValue == value && compare(nextValue, bestNextValue)) // check if the step is legal { bestNextValue = nextValue; nextField = field.Clone(); } field = new Field(startField.x, startField.y - 1); nextValue = matrix[field.x, field.y]; if (costMatrix[DNAToByte('_'), w[field.y]] + nextValue == value && compare(nextValue, bestNextValue)) { bestNextValue = nextValue; nextField = field.Clone(); } field = new Field(startField.x - 1, startField.y); nextValue = matrix[field.x, field.y]; if (costMatrix[u[field.x], DNAToByte('_')] + nextValue == value && compare(nextValue, bestNextValue)) { bestNextValue = nextValue; nextField = field; } } return(nextField); }
private void OnMatchStateChange(MatchingType type, bool isShow) { string btnName = ""; switch (type) { case MatchingType.Gold: case MatchingType.Trial: btnName = "Entrance-Trial"; break; case MatchingType.PVP: btnName = "Entrance-Match"; break; } for (int index = 0; index < buttons.Length; ++index) { if (buttons[index] != null && buttons[index].name == btnName) { MatchStateChange item = buttons[index].GetComponent <MatchStateChange>(); if (item != null) { item.SetState(isShow); break; } } } }
internal static void ListActions(IList args, IMethodContext context) { ImplLogger.LogImpl("listactions", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); List <ITerminalAction> actions = new List <ITerminalAction>(); foreach (var block in blocks) { Log.WriteFormat("block \"{0}\" of type \"{1}\" have actions:", new object[] { block.CustomName, block.GetType().Name }); actions.Clear(); block.GetActions(actions); foreach (var action in actions) { Log.WriteFormat("\"{0}\": {1}", new object[] { action.Id, action.Name }); } Log.WriteLine(); } }
internal static void Test3(IList args, IMethodContext context) { ImplLogger.LogImpl("test3", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; // string prop = (string)args[2]; var blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); Log.Write("TypeName/SubtypeName \"Name\" [IntityId]"); Log.WriteLine(); foreach (var block in blocks) { var propDef = block.GetProperty("FontColor"); Log.WriteFormat("name as sb {0}", propDef.As <Color>()); Log.WriteFormat("name as int {0}", propDef.As <int>()); Log.WriteFormat("existing prop {0}", block.GetProperty("FontColor")); Log.WriteFormat("unexisting prop {0}", block.GetProperty("someunexistingproperty")); } }
public void OnStart() { matchingType = PhotonNetwork.lobby.Equals(LobbyManager.LeagueLobby) ? MatchingType.League : MatchingType.Club; var playerName = PhotonNetwork.playerName; var playerFightRecord = new FightRecord(0, 0); var player = new WaitingPlayer(playerName, playerFightRecord, 1000); playerPanel.Set(player); inPlayerPanel(); if (PhotonNetwork.otherPlayers.Length > 0) { var otherPlayer = PhotonNetwork.otherPlayers[0]; var opponentName = otherPlayer.NickName; var opponentFightRecord = new FightRecord(0, 0); var opponent = new WaitingPlayer(opponentName, opponentFightRecord, 1000); opponentPanel.Set(opponent); inOpponentPanel(); startModeSelect(); } else { inWaitingWindow(); } }
public static void Action(IList args, IMethodContext context) { ImplLogger.LogImpl("action", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; string action = (string)args[2]; List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); foreach (var block in blocks) { if (block.HasAction(action)) { block.ApplyAction(action); } else { Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "block \"{0}\" does not support action \"{1}\", ignoring", block.CustomName, action); } } }
private string[] GetMatching(int[,] matrix, int[,] costMatrix, MatchingType matchingType, bool stopAtNonPositive = false, Field startField = null) { Field field = startField ?? new Field(n, m); Field lastField = field.Clone(); StringBuilder outSequence1 = new StringBuilder(); StringBuilder outSequence2 = new StringBuilder(); while ((field.x != 0 || field.y != 0) && (!stopAtNonPositive || matrix[field.x, field.y] > 0)) { field = GetNextField(matrix, costMatrix, matchingType, field); if (field.x == lastField.x) { outSequence1.Insert(0, '_'); outSequence2.Insert(0, ByteToDNA(w[field.y])); // z nierówności trójkąta będzie działać } else if (field.y == lastField.y) { outSequence1.Insert(0, ByteToDNA(u[field.x])); outSequence2.Insert(0, '_'); } else { outSequence1.Insert(0, ByteToDNA(u[field.x])); outSequence2.Insert(0, ByteToDNA(w[field.y])); } lastField.Copy(field); } return(new string[] { outSequence1.ToString(), outSequence2.ToString() }); }
private void OnMatchStateChange(MatchingType type, bool isShow) { string name = ""; switch (type) { case MatchingType.Trial: name = NAME_TRIAL; break; case MatchingType.Gold: name = NAME_GOLD; break; } for (int i = 0; i < buttons.Count; i++) { string btnName = buttons[i].name; btnName = btnName.TrimStart("1234567890".ToCharArray()); if (btnName == name) { MatchStateChange item = buttons[i].GetComponent <MatchStateChange>(); if (item != null) { item.SetState(isShow); break; } } } }
public static void GetBlocksOfTypeWithQuery <T>(MatchingType selectionMode, string query, List <T> blocks) where T : class { switch (selectionMode) { case MatchingType.Match: { Program.Current.GridTerminalSystem.GetBlocksOfType(blocks, x => (x as IMyTerminalBlock)?.CustomName?.Equals(query) ?? false); return; } case MatchingType.Contains: { Program.Current.GridTerminalSystem.GetBlocksOfType(blocks, x => (x as IMyTerminalBlock)?.CustomName?.Contains(query) ?? false); return; } case MatchingType.Head: { Program.Current.GridTerminalSystem.GetBlocksOfType(blocks, x => (x as IMyTerminalBlock)?.CustomName?.StartsWith(query) ?? false); return; } case MatchingType.Group: { IMyBlockGroup group = Program.Current.GridTerminalSystem.GetBlockGroupWithName(query); blocks.Clear(); if (group != null) { group.GetBlocksOfType <T>(blocks); } return; } case MatchingType.Type: { string[] parts = query.Split("|/:, ".ToCharArray()).Select(x => x.Trim()).ToArray(); bool allTypes = parts[0] == "" || parts[0] == "*"; string type = "My" + parts[0]; bool allSubtypes = true; string subtype = ""; if (parts.Length > 1) { allSubtypes = parts[1] == "*"; subtype = parts[1]; } Program.Current.GridTerminalSystem.GetBlocksOfType(blocks, block => { return((allTypes || block.GetType().Name == type) && (allSubtypes || (block as IMyTerminalBlock)?.BlockDefinition.SubtypeName == subtype)); }); return; } } }
internal void Mark(MatchingType matchingType, PropertyInfo pi) { MatchingType |= matchingType; if (matchingType == MatchingType.Left) { LeftSideItem = new PropertyMatchingMemberItem <T1>(pi); } else if (matchingType == MatchingType.Right) { RightSideItem = new PropertyMatchingMemberItem <T2>(pi); } }
internal void Mark(MatchingType matchingType, FieldInfo fi) { MatchingType |= matchingType; if (matchingType == MatchingType.Left) { LeftSideItem = new FieldMatchingMemberItem <T1>(fi); } else if (matchingType == MatchingType.Right) { RightSideItem = new FieldMatchingMemberItem <T2>(fi); } }
private void AddField(Dictionary <string, MatchingMemberInfo <T1, T2> > members, FieldInfo fi, MatchingType matchingType) { if (!members.ContainsKey(fi.Name)) { members.Add(fi.Name, new MatchingMemberInfo <T1, T2>(fi.Name)); } if (ShouldBeCompared(fi)) { members[fi.Name].Mark(matchingType, fi); } }
static string MatchingTypeToString(MatchingType matchingType) { switch (matchingType) { case MatchingType.Equal: return(string.Empty); case MatchingType.GreaterOrEqual: return(GreaterOrEqual.ToString()); default: throw new ArgumentOutOfRangeException(nameof(matchingType), matchingType, null); } }
public static void Run(IList args, IMethodContext context) { ImplLogger.LogImpl("run", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; string argument = (string)args[2]; List <IMyProgrammableBlock> blocks = new List <IMyProgrammableBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); foreach (var block in blocks) { block.TryRun(argument); } }
private void AddProperty(Dictionary <string, MatchingMemberInfo <T1, T2> > members, PropertyInfo pi, MatchingType matchingType) { if (pi.GetIndexParameters().Length > 0) //skip indexed property { return; } if (!members.ContainsKey(pi.Name)) { members.Add(pi.Name, new MatchingMemberInfo <T1, T2>(pi.Name)); } if (ShouldBeCompared(pi)) { members[pi.Name].Mark(matchingType, pi); } }
static string ToStringInternal(int?number, MatchingType matchingType) { if (number.HasValue == false) { return(Wildcard); } switch (matchingType) { case MatchingType.Equal: return(number.ToString()); case MatchingType.GreaterOrEqual: return($"{number}{GreaterOrEqual}"); default: throw new ArgumentOutOfRangeException(nameof(matchingType), matchingType, null); } }
private string[] GetMatching(int[,] matrix, int[,] costMatrix, MatchingType matchingType, Sequence uSequence, Sequence wSequence, bool stopAtNonPositive = false, Field startField = null) { Field field = startField ?? new Field(uSequence.data.Length, wSequence.data.Length); Field lastField = field.Clone(); int stopSeq1 = (field.x + uSequence.index) * 3; // 3 chars for amino int stopSeq2 = (field.y + wSequence.index) * 3; StringBuilder outSequence1 = new StringBuilder(); StringBuilder outSequence2 = new StringBuilder(); while ((field.x != 0 || field.y != 0) && (!stopAtNonPositive || matrix[field.x, field.y] > 0)) { field = GetNextField(matrix, costMatrix, matchingType, field, uSequence.data, wSequence.data); if (field.x == lastField.x) { stopSeq2 -= 3; outSequence1.Insert(0, "___"); outSequence2.Insert(0, RNASequence2.Substring(stopSeq2, 3)); } else if (field.y == lastField.y) { stopSeq1 -= 3; outSequence1.Insert(0, RNASequence1.Substring(stopSeq1, 3)); outSequence2.Insert(0, "___"); } else { stopSeq1 -= 3; stopSeq2 -= 3; outSequence1.Insert(0, RNASequence1.Substring(stopSeq1, 3)); outSequence2.Insert(0, RNASequence2.Substring(stopSeq2, 3)); } lastField.Copy(field); } return(new string[] { outSequence1.ToString(), outSequence2.ToString() }); }
public ENFA_Controller(ParserType parserType) { _parserType = parserType; switch (_parserType) { case ParserType.Regex: _factory = new ENFA_Regex_Factory(this); _tokenizer = Factory.GetTokenizer(); _parser = Factory.GetParser(); break; case ParserType.Grammar: _factory = new ENFA_Grammar_Factory(this); _tokenizer = Factory.GetTokenizer(); _parser = Factory.GetParser(); break; } _patternStart = new ENFA_PatternStart(this); _matchingType = MatchingType.LazyMatching; _inDebugMode = false; }
public Node goToMatchingNode(String query, MatchingType type) { if (query.Count() > 0) { Node child = this.findChild(query.ToString()[0]); if (child == null) { return(null); } // filter wrong nodes if (!query.StartsWith(child.getSymbol(), this.stringComparison)) { if (type == MatchingType.MATCH_EXACT || type == MatchingType.MATCH_INSERT) { return(null); } else { return(child); } } query = query.Substring(child.getSymbol().Count()); Node nextChild = child.goToMatchingNode(query, type); //this is the case when there is either no matching translation in the trie, or we found a translation if (nextChild == null) { if (type == MatchingType.MATCH_EXACT && query.Length != 0) { return(null); } return(child); } else { return(nextChild); } } return(null); }
// static blocks internal static void Test1(IList args, IMethodContext context) { ImplLogger.LogImpl("test1", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; List <IMyTextSurfaceProvider> blocks = new List <IMyTextSurfaceProvider>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); Log.Write("TypeName/SubtypeName \"Name\" [IntityId]"); Log.WriteLine(); foreach (var lcd in blocks) { var block = lcd as IMyTerminalBlock; Log.Write($"{block.GetType().Name}/{block.BlockDefinition.SubtypeName} \"{block.CustomName}\" [{block.EntityId}]"); Log.WriteFormat("surfaces count: {0}", lcd.SurfaceCount); } }
public static void Text(IList args, IMethodContext context) { ImplLogger.LogImpl("text", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; int index = (int)(double)args[2]; bool append = (bool)args[3]; string text = (string)args[4]; var blocks = new List <IMyTextSurfaceProvider>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); foreach (var block in blocks) { IMyTextSurface surface; if (block is IMyTextPanel && index == 0) { surface = block as IMyTextSurface; } else { surface = block.GetSurface(index); } if (surface != null) { surface?.WriteText(text, append); } else { Log.Write(ImplLogger.LOG_CAT, LogLevel.Verbose, "surface index out of range"); } } }
private void Set(int i, string valueAsString, int?value, MatchingType matchingType) { switch (i) { case 0: AssertMatchingType(nameof(Major), valueAsString, MatchingType.Equal, matchingType); Major = value; break; case 1: AssertMatchingType(nameof(Minor), valueAsString, MatchingType.Equal, matchingType); Minor = value; break; case 2: AssertMatchingType(nameof(Patch), valueAsString, expectedMatchingType: null, matchingType); Patch = value; PatchMatchingType = matchingType; break; default: throw new ArgumentOutOfRangeException(nameof(i)); } void AssertMatchingType(string fieldName, string valueAsString, MatchingType?expectedMatchingType, MatchingType matchingType) { if (Suffix != null && matchingType != MatchingType.Equal) { throw new InvalidOperationException($"Cannot set '{fieldName}' with value '{valueAsString}' because '{MatchingTypeToString(matchingType)}' is not allowed when Suffix ('{Suffix}') is set."); } if (expectedMatchingType.HasValue && expectedMatchingType != matchingType) { throw new InvalidOperationException($"Cannot set '{fieldName}' with value '{valueAsString}' because '{MatchingTypeToString(matchingType)}' is not allowed."); } }
public ConsoleOutputSourceAttribute(string memberName, MatchingType matchingType = MatchingType.Standard, Type declaredType = null) { MemberName = memberName; MatchingType = matchingType; DeclaredType = declaredType; }
public ConsoleOutCommand(TestCommand innerCommand, string expectedMessage, MatchingType matchingType) : base(innerCommand) { _expectedMessage = expectedMessage; _matchingType = matchingType; }
public MatchingTagConditional(string tagToMatch, MatchingType type) { this.tagToMatch = tagToMatch; this.type = type; }
public static void Transmit(IList args, IMethodContext context) { ImplLogger.LogImpl("transmit", args); MatchingType matchingType = (MatchingType)args[0]; string filter = (string)args[1]; string targetString = (string)args[2]; string message = (string)args[3]; List <IMyTerminalBlock> antennas = new List <IMyTerminalBlock>(); List <IMyRadioAntenna> radioAntennas = new List <IMyRadioAntenna>(); BlockSelector.GetBlocksOfTypeWithQuery(matchingType, filter, radioAntennas); ImplLogger.LogBlocks(antennas); //get most powerful radio antenna IMyRadioAntenna mostPowerfulAntenna = null; //get radio antenna with longest radius that's enabled and broadcasting foreach (IMyRadioAntenna antenna in radioAntennas) { if (antenna.Enabled && antenna.GetValueBool("EnableBroadCast") && (mostPowerfulAntenna == null || antenna.Radius > mostPowerfulAntenna.Radius)) { mostPowerfulAntenna = antenna; } } if (mostPowerfulAntenna != null) { antennas.Add(mostPowerfulAntenna); } //--------get all laser antennas List <IMyLaserAntenna> laserAntennas = new List <IMyLaserAntenna>(); BlockSelector.GetBlocksOfTypeWithQuery(matchingType, filter, laserAntennas); Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Verbose, "{0} block(s) found", laserAntennas.Count); foreach (IMyLaserAntenna antenna in laserAntennas) { if (antenna.Status == MyLaserAntennaStatus.Connected) { antennas.Add(antenna); } } //-----check whether at least one valid antenna was found if (antennas.Count != 0) { var transmitter = new Transmitter(antennas); transmitter.Transmit(message, targetString); } else { string warning; switch (matchingType) { default: case MatchingType.Match: warning = string.Format("No antennas called \"{0}\" are currently able to transmit.", filter); break; case MatchingType.Contains: warning = string.Format("No antennas containing \"{0}\" are currently able to transmit.", filter); break; case MatchingType.Head: warning = string.Format("No antennas starting with \"{0}\" are currently able to transmit.", filter); break; case MatchingType.Group: warning = string.Format("No antennas in group \"{0}\" are currently able to transmit.", filter); break; case MatchingType.Type: warning = string.Format("No antennas of type \"{0}\" are currently able to transmit.", filter); break; } Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, warning); } }
public static void Set(IList args, IMethodContext context) { ImplLogger.LogImpl("set", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; string prop = (string)args[2]; string value = (string)args[3]; List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); // Boolean // StringBuilder // Single // Int64 // Color foreach (var block in blocks) { // todo: redo var propDef = block.GetProperty(prop); PropType propType; if (propDef != null && Enum.TryParse(propDef.TypeName, out propType)) { switch (propType) { case PropType.Boolean: { bool b; if (bool.TryParse(value, out b)) { block.SetValue(prop, b); } break; } case PropType.StringBuilder: { block.SetValue(prop, new StringBuilder(value)); break; } case PropType.String: { block.SetValue(prop, value); break; } case PropType.Single: { float s; if (float.TryParse(value, System.Globalization.NumberStyles.Number, C.I, out s)) { block.SetValue(prop, s); } } break; case PropType.Int64: { long i; if (ListConverter.ResolveListProperty(prop, value, out i)) { block.SetValue(prop, i); } } break; case PropType.Color: { Color c; if (ColorConverter.TryParseColor(value, out c)) { block.SetValueColor(prop, c); } else { Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "\"{0}\" is not a valid color", value); } } break; } } else { Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "block \"{0}\" does not have property \"{1}\", ignoring", block.CustomName, prop); } } }
private void CheckQuantifiers(StreamReader reader, out int minRepetitions, out int maxRepetitions, out MatchingType matchingType) { char matchedChar; minRepetitions = 0; maxRepetitions = -1; /* Run digits until comma or curly barce end */ string firstDigit = GetStringUntilChar(reader, new char[] { Constants.Comma, Constants.RightCurlyBracket }, out matchedChar); string secondDigit = null; if (matchedChar == Constants.RightCurlyBracket && firstDigit == String.Empty) { ThrowBuildException(ErrorText.EmptyCurlyBraces); } if (firstDigit != String.Empty && !int.TryParse(firstDigit, out minRepetitions)) { ThrowBuildException(ErrorText.CouldNotParseMinRepetitions); } else if (matchedChar == Constants.RightCurlyBracket) { maxRepetitions = minRepetitions; } if (matchedChar == Constants.Comma) { /* if comma is found then check digits until curly barce end */ secondDigit = GetStringUntilChar(reader, new char[] { Constants.RightCurlyBracket }, out matchedChar); if (secondDigit == String.Empty) { maxRepetitions = -1; } else if (!int.TryParse(secondDigit, out maxRepetitions)) { ThrowBuildException(ErrorText.CouldNotParseMaxRepetitions); } } /* Check for additional matching type */ if (PeekNextChar(reader) == Constants.QuestionMark) { /* Consume Quention Mark */ ConsumeNextChar(reader); /* Lazy matching overwriting default */ matchingType = MatchingType.LazyMatching; } else if (PeekNextChar(reader) == Constants.GreaterThanSign) { /* Consume Greater Than Sign */ ConsumeNextChar(reader); /* Greedy matching overwriting default */ matchingType = MatchingType.GreedyMatching; } else { /* Use default matching */ matchingType = Controller.DefaultMatchType; } }
internal static void ListProps(IList args, IMethodContext context) { ImplLogger.LogImpl("listprops", args); MatchingType type = (MatchingType)args[0]; string filter = (string)args[1]; List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); BlockSelector.GetBlocksOfTypeWithQuery(type, filter, blocks); ImplLogger.LogBlocks(blocks); List <ITerminalProperty> props = new List <ITerminalProperty>(); foreach (var block in blocks) { Log.WriteFormat("Block \"{0}\" of type \"{1}\" contains properties:", new object[] { block.CustomName, block.GetType().Name }); props.Clear(); block.GetProperties(props); var allProps = new HashSet <string>(); var badProps = new HashSet <string>(); // Termimal Properties can have same ids, which makes them unaccessible foreach (var prop in props) { if (allProps.Contains(prop.Id)) { badProps.Add(prop.Id); } else { allProps.Add(prop.Id); } } foreach (var prop in props) { // block.GetValue<object>(prop.Id) - Property is not of Type object <...> object value = null; try { PropType propType; if (!badProps.Contains(prop.Id) && Enum.TryParse(prop.TypeName, out propType)) { switch (propType) { case PropType.Boolean: value = block.GetValueBool(prop.Id); break; case PropType.Single: value = block.GetValueFloat(prop.Id); break; case PropType.Color: value = block.GetValueColor(prop.Id); break; case PropType.StringBuilder: value = block.GetValue <StringBuilder>(prop.Id); break; case PropType.String: value = block.GetValue <string>(prop.Id); break; case PropType.Int64: value = block.GetValue <long>(prop.Id); break; } } } catch { // Looks like some game mod is broken, which is bad. Game breaking bad. Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, $"Error reading property \"{prop.Id}\""); } Log.WriteFormat("\"{0}\" ({1}) = \"{2}\"", new object[] { prop.Id, prop.TypeName, value }); } Log.WriteLine(); } }