private string ParseOptionCommand(PlayerGameSave gameSave, string command)
{
if (command.EndsWith("]"))
{
var commandSplit = command.Split('[', ']');
commandSplit = commandSplit.Where(a => !string.IsNullOrWhiteSpace(a)).ToArray();
var result = ResolveCommand(gameSave, commandSplit[0]);
if (result)
{
return(commandSplit[1]);
}
}
else
{
var result = ResolveCommand(gameSave, command);
if (result)
{
return("#TRUE");
}
else
{
return("#FALSE");
}
}
return(null);
}
private bool ResolveOperation(string data1, string data2, string operat, PlayerGameSave gameSave)
{
data1 = ResolveValue(data1, gameSave);
data2 = ResolveValue(data2, gameSave);
if (operat == ">")
{
if (!int.TryParse(data1, out int data1int))
{
throw new ArgumentException($"{data1} was tried to be operated on in a '>' command, but it is not a number!");
}
if (!int.TryParse(data2, out int data2int))
{
throw new ArgumentException($"{data2} was tried to be operated on in a '>' command, but it is not a number!");
}
return(data1int > data2int);
}
if (operat == "<")
{
if (!int.TryParse(data1, out int data1int))
{
throw new ArgumentException($"{data1} was tried to be operated on in a '<' command, but it is not a number!");
}
if (!int.TryParse(data2, out int data2int))
{
throw new ArgumentException($"{data2} was tried to be operated on in a '<' command, but it is not a number!");
}
return(data1int < data2int);
}
if (operat == "=")
{
return(data1 == data2);
}
throw new ArgumentException($"Found a command with an operator {operat} which is not valid");
}
public void SaveCurrentGame(Player player, string name = "")
{
PlayerGameSave gameSave = new PlayerGameSave
{
GameName = player.ActiveGameSave.GameName,
GameSaveData = player.ActiveGameSave.GameSaveData.Select(a => new PlayerGameSaveData
{
Name = a.Name,
Value = a.Value,
}).ToList(),
StateId = player.ActiveGameSave.StateId,
};
var addedSave = _context.PlayerGameSave.Add(gameSave);
addedSave.Entity.FrameStack = player.ActiveGameSave.FrameStack.Select(a => new PlayerFrameStack
{
CreatedDate = a.CreatedDate,
FunctionName = a.FunctionName,
ReturnStateId = a.ReturnStateId,
Save = addedSave.Entity,
SaveId = addedSave.Entity.SaveId,
}).ToList();
player.GameSaves.Add(new GameSaves {
PlayerGameSave = addedSave.Entity, Name = name
});
}
private void ReportError(string text, PlayerGameSave gameSave, DrawGame game)
{
var state = game.FindStateById(gameSave.StateId);
var mText = $"Error '{text}' \nIn state with text: '{(!string.IsNullOrWhiteSpace(state.StateText) && state.StateText.Length >= 300 ? state.StateText.Substring(0, 300) : state.StateText)}'";
errors.Add(mText);
}
public static ExecutionResult LaunchGameForPlayer(DrawGame game, PlayerGameSave save, Player player, IGameProcessor gameProcessor)
{
player.ActiveGameSave = new PlayerGameSave
{
GameName = game.GameName,
StateId = game.StartState.Id,
};
var messages = gameProcessor.RecursivelyHandleStates(game.StartState, player.ActiveGameSave, player, game, true);
messages.Messages.Reverse();
player.ActiveGameSave = new PlayerGameSave
{
GameName = game.GameName,
StateId = messages.EndingState.Id,
};
player.PlayerFlag = PlayerFlag.IN_GAME.ToString();
var execResult = new ExecutionResult {
MessagesToShow = messages.Item1, OptionsToShow = gameProcessor.GetCurrentOptions(player.ActiveGameSave, game)
};
return(execResult);
}
public static string MakeMessage(Exception e, PlayerGameSave gameSave, string additional = "")
{
return(MakeMessage(e, new PlayerState {
player = new Player {
ActiveGameSave = gameSave
}
}, additional));
}
public ParsedStateOption ResolveOption(PlayerGameSave gameSave, string optionText)
{
try
{
optionText = CleanText(optionText);
optionText = optionText.Trim(' ', '\n');
//if (optionText.Contains("<") || optionText.Contains(">"))
// Log.LogMessage($"Potential HTML in option text: '{optionText}' at state with id '{gameSave.StateId}' in game '{gameSave.GameName}'", LogType.Important);
if (optionText.StartsWith("#if"))
{
var result = ParseLine(gameSave, ParseOptionCommand(gameSave, optionText));
ParsedStateOption option = new ParsedStateOption {
OptionType = OptionType.Normal, text = result
};
if (result == "#TRUE")
{
option.IsDirectTransition = true;
option.DirectTransitionCommandResult = true;
}
else if (result == "#FALSE")
{
option.IsDirectTransition = true;
option.DirectTransitionCommandResult = false;
}
return(option);
}
else if (optionText.StartsWith("#fallback"))
{
var result = ParseLine(gameSave, optionText.Replace("#fallback", "").Replace("[", "").Replace("]", "").Trim(' '));
if (string.IsNullOrWhiteSpace(result))
{
return new ParsedStateOption {
OptionType = OptionType.Fallback, IsDirectTransition = true, DirectTransitionCommandResult = true
}
}
;
else
{
return new ParsedStateOption {
OptionType = OptionType.Fallback, text = result
}
};
}
else
{
var result = ParseLine(gameSave, optionText);
return(new ParsedStateOption {
OptionType = OptionType.Normal, text = result
});
}
} catch (Exception e)
{
HandleError(optionText, e, gameSave);
return(null);
}
}
private string ParseWord(PlayerGameSave gameSave, string word)
{
var trimmed = word.Trim(' ');
if (trimmed.Substring(0, 1) == "#")
{
return(ParseCommad(gameSave, trimmed));
}
return(_gameDataService.GetData(gameSave, word));
}
public void SaveData(PlayerGameSave data, string dataName, string valueSet)
{
DeleteData(data, dataName);
data.GameSaveData.Add(new PlayerGameSaveData
{
Name = dataName,
Value = valueSet,
PlayerGameSaveSaveId = data.SaveId
});
}
public string ParseText(PlayerGameSave gameSave, string text)
{
try
{
return(ParseLine(gameSave, text));
}
catch (Exception e)
{
HandleError(text, e, gameSave);
return(null);
}
}
public bool ResolveCommand(PlayerGameSave gameSave, string command)
{
command = CleanText(command);
command = command.Trim(' ');
if (command.StartsWith("#if"))
{
return(ResolveIf(gameSave, command));
}
if (command.StartsWith("#else"))
{
return(true);
}
throw new ApplicationException("Error parsing: " + command);
}
private string ParseCommad(PlayerGameSave gameSave, string command)
{
var commandSplit = command.Split('[', ']');
commandSplit = commandSplit.Where(a => !string.IsNullOrWhiteSpace(a)).ToArray();
for (int i = 0; i < commandSplit.Length; i = i + 2)
{
var result = ResolveCommand(gameSave, commandSplit[i]);
if (result)
{
return(commandSplit[i + 1]);
}
}
return(null);
}
public void IncrementData(PlayerGameSave data, string dataName)
{
if (!data.GameSaveData.Any(a => a.Name == dataName))
{
throw new AdventureGameException("Attempted to increment: " + dataName + " But that data does not exist!");
}
if (!int.TryParse(data.GameSaveData.First(a => a.Name == dataName).Value, out int result))
{
throw new Exception("Error - data with name: " + dataName + " Is not a number, so the -- operator cannot be applied to it");
}
else
{
var newVal = result + 1;
SaveData(data, dataName, newVal.ToString());
}
}
private void ResetGame()
{
gameState = new PlayerGameSave();
gameState.GameName = game.GameName;
gameState.StateId = startingState.Id;
if (startData != null)
{
gameState.GameSaveData = startData.Select(a => new PlayerGameSaveData
{
Name = a.Name,
Value = a.Value
}).ToList();
}
actionsDoneThisRun = 0;
previousDataLength = 0;
}
private void ParseAttachmentCommand(Player player, PlayerGameSave gameSave, string command)
{
command = CleanText(command);
var commandSplit = command.Split(' ');
if (command.StartsWith("imageBuild"))
{
ResolveImageBuildCommand(commandSplit);
}
else if (command.StartsWith("save"))
{
var dataName = commandSplit[1];
_gameDataService.SaveData(gameSave, dataName);
}
else if (command.StartsWith("set"))
{
var dataName = commandSplit[1];
if (commandSplit[2] == "=")
{
var valueSet = ResolveValue(ConcatSplitAfterIndex(commandSplit, 3), gameSave);
_gameDataService.SaveData(gameSave, dataName, valueSet);
}
else if (commandSplit[2] == "--")
{
_gameDataService.DecrementData(gameSave, dataName);
}
else if (commandSplit[2] == "++")
{
_gameDataService.IncrementData(gameSave, dataName);
}
else
{
throw new Exception("Error parsing: " + command + " as an attachment state command");
}
}
else if (command.StartsWith("delete"))
{
var dataName = commandSplit[1];
_gameDataService.DeleteData(gameSave, dataName);
}
else if (command.StartsWith("achievement"))
{
var dataValue = command.Substring(11, command.Length - 11).Trim();
_gameDataService.SavePermanentData(player, gameSave.GameName, dataValue, PlayerSaveDataType.ACHIEVEMENT);
}
}
public void ParseAttachment(Player player, PlayerGameSave gameSave, StateAttachment stateAttachment)
{
try
{
var text = stateAttachment.StateText.Replace("<br>", "");
text = text.Replace("<span>", "");
var split = text.Split('#').ToList();
split = split.Where(a => !string.IsNullOrWhiteSpace(a)).ToList();
split.ForEach(a =>
{
ParseAttachmentCommand(player, gameSave, a);
});
} catch (Exception e)
{
HandleError(stateAttachment.StateText, e, gameSave);
}
}
public static string MakeMessage(Exception e, PlayerGameSave gameState, string additional = "")
{
var messages = e.GetInnerExceptions().Select(a => a.Message);
var stackTrace = e.StackTrace;
string saveData = "NODATA";
string gameName = "NOGAME";
string player = "NOPLAYER";
gameName = gameState.GameName;
if (gameState.GameSaveData != null)
{
saveData = string.Join(" ", gameState.GameSaveData.Select(a => $"[N: {a.Name} V: {a.Value}] "));
}
return($"ERROR: {additional} \n\nPlayer: {player}\nGame: {gameName} \nException messages: \n{messages} \n\nSave data: \n{saveData}\n\nStack trace\n{stackTrace}");
}
public DrawGame FindGame(Player player, PlayerGameSave gameSave)
{
var games = _gameStore.ListGames();
var gamesFound = games.Where(a => a.GameName == gameSave.GameName).ToList();
if (gamesFound.Count == 0)
{
throw new AdventureGameException("Could not find the game being played for user: "******" and game name: " + gameSave.GameName + ". It may have been removed - sending back to main menu.", true);
}
if (gamesFound.Count > 1)
{
throw new AdventureGameException("Found more than one game applicable for player: " + player.Name + " and game name: " + gameSave.GameName + ". Something has therefore critically wrong.", true);
}
var gameBeingPlayed = gamesFound.First();
return(gameBeingPlayed);
}
public static PlayerGameSave Clone(this PlayerGameSave gameSave)
{
return(new PlayerGameSave
{
GameName = gameSave.GameName,
SaveName = gameSave.SaveName,
GameSaveData = gameSave.GameSaveData.Select(a => new PlayerGameSaveData
{
Name = a.Name,
Value = a.Value
}).ToList(),
StateId = gameSave.StateId,
FrameStack = gameSave.FrameStack.Select(a => new PlayerFrameStack
{
CreatedDate = a.CreatedDate,
FunctionName = a.FunctionName,
ReturnStateId = a.ReturnStateId,
}).ToList()
});
}
private string ParseLine(PlayerGameSave gameSave, string line)
{
if (string.IsNullOrWhiteSpace(line))
{
return(null);
}
line = CleanText(line);
var split = line.Split(new string[] { "{{" }, StringSplitOptions.None);
var lineConstruction = "";
lineConstruction = split[0];
for (int i = 1; i < split.Length; i++)
{
int indexOfClose = split[i].IndexOf("}}");
string parseString = split[i].Substring(0, indexOfClose);
string parsedWord = ParseWord(gameSave, parseString);
lineConstruction = lineConstruction + parsedWord + split[i].Substring(parseString.Length + 2, split[i].Length - parseString.Length - 2);
}
return(lineConstruction);
}
private string ResolveValue(string valueString, PlayerGameSave gameSave)
{
var mainSplit = valueString.Split(' ');
string currentVal = "";
if (mainSplit[0].StartsWith("rand"))
{
var split = valueString.Split(',');
var fromString = split[0].Split('(')[1];
var toString = split[1].Split(')')[0];
if (!int.TryParse(fromString, out int fromValue))
{
throw new ArgumentException("Attempted to create rand from: " + valueString + " But the section: " + fromString + " was not a number");
}
if (!int.TryParse(toString, out int toValue))
{
throw new ArgumentException("Attempted to create rand from: " + valueString + " But the section: " + fromString + " was not a number");
}
currentVal = "" + (new Random().Next(fromValue, toValue));
}
else if (_gameDataService.DataExists(gameSave, mainSplit[0]))
{
currentVal = _gameDataService.GetData(gameSave, mainSplit[0]);
}
else if (int.TryParse(mainSplit[0], out int valResult))
{
currentVal = "" + valResult;
}
else
{
currentVal = valueString;
}
if (mainSplit.Length > 1)
{
if (mainSplit[1] == "+")
{
return("" + (int.Parse(currentVal) + int.Parse(ResolveValue(ConcatSplitAfterIndex(mainSplit, 2), gameSave))));
}
else if (mainSplit[1] == "-")
{
return("" + (int.Parse(currentVal) - int.Parse(ResolveValue(ConcatSplitAfterIndex(mainSplit, 2), gameSave))));
}
else if (mainSplit[1] == "*")
{
return("" + (int.Parse(currentVal) * int.Parse(ResolveValue(ConcatSplitAfterIndex(mainSplit, 2), gameSave))));
}
else if (mainSplit[1] == "//")
{
return("" + (int.Parse(currentVal) / int.Parse(ResolveValue(ConcatSplitAfterIndex(mainSplit, 2), gameSave))));
}
else
{
return(currentVal);
}
}
else
{
return(currentVal);
}
throw new Exception("Shouldn't be possible");
}
private (List <MessageResult> Messages, DrawState EndingState, List <string> StatesVisited) HandleFunctionReturn(string message, DrawState currentState, PlayerGameSave gameSave, Player player, DrawGame game, bool withDataChanges = true)
{
var topStackItem = gameSave.FrameStack.OrderByDescending(a => a.CreatedDate).FirstOrDefault();
if (topStackItem == null)
{
throw new AdventureGameException($"No items on frame stack, but encountered a 'Return' statement", true);
}
var returnState = game.FindStateById(topStackItem.ReturnStateId);
gameSave.FrameStack.Remove(topStackItem);
gameSave.StateId = returnState.Id;
return(RecursivelyHandleStates(returnState, gameSave, player, game, false, true));
}
private void HandleError(string identifyingText, Exception e, PlayerGameSave gameSave = null)
{
Log.LogMessage(ErrorMessageHelper.MakeMessage(e, gameSave, "Parsing text: " + identifyingText), LogType.Error);
throw e;
}
public (List <MessageResult> Messages, DrawState EndingState, List <string> StatesVisited) RecursivelyHandleStates(DrawState currentState, PlayerGameSave gameSave, Player player, DrawGame game, bool withDataChanges = true, bool ignoreFrameShift = false)
{
if (withDataChanges)
{
HandleAnyAttachments(currentState, gameSave, player, false);
}
List <MessageResult> messages = new List <MessageResult>();
var message = _textParsing.ParseText(gameSave, currentState.StateText);
if (message != null && message.Trim().ToLower().StartsWith("#showbuiltimage"))
{
var imageUrl = _imageService.CreateImageAsync(_imageBuildDataTracker.GetParams()).Result;
messages.Add(new MessageResult
{
ImageUrl = imageUrl
});
message = "";
}
if (message != null && message.Trim().ToLower().StartsWith("#function"))
{
if (ignoreFrameShift)
{
message = "";
}
else
{
return(HandleFunction(message, currentState, gameSave, player, game, withDataChanges));
}
}
if (message != null && message.Trim().ToLower().Equals("#return"))
{
return(HandleFunctionReturn(message, currentState, gameSave, player, game, withDataChanges));
}
if (!string.IsNullOrEmpty(message))
{
messages.Add(new MessageResult
{
Message = message,
ImageUrl = currentState.IsImage ? currentState.StateText : null,
});
}
DrawState newState = null;
var directTransitions = currentState.StateOptions.Where(a => a.IsDirectTransition).ToList();
var nondirectTransitions = currentState.StateOptions.Where(a => !a.IsDirectTransition).ToList();
var resolvedTransitions = nondirectTransitions.Select(a => (a.ResultState, _textParsing.ResolveOption(gameSave, a.StateText)));
var validTransitions = resolvedTransitions.Where(a => a.Item2.IsDirectTransition && a.Item2.DirectTransitionCommandResult && a.Item2.OptionType != OptionType.Fallback).ToList();
var fallbackTransitions = resolvedTransitions.Where(a => a.Item2.IsDirectTransition && a.Item2.DirectTransitionCommandResult && a.Item2.OptionType == OptionType.Fallback).ToList();
if (validTransitions.Count > 1)
{
throw new AdventureGameException("Found more than 1 applicable conditional direct transition");
}
else if (validTransitions.Count == 1)
{
newState = validTransitions.First().ResultState;
}
else if (directTransitions.Count > 1)
{
throw new AdventureGameException("Found more than 1 applicable direct transition");
}
else if (directTransitions.Count == 1)
{
newState = directTransitions.First().ResultState;
}
else if (fallbackTransitions.Count > 1)
{
throw new AdventureGameException("Found more than 1 applicable conditional direct transition");
}
else if (fallbackTransitions.Count == 1)
{
newState = fallbackTransitions.First().ResultState;
}
if (withDataChanges)
{
HandleAnyAttachments(currentState, gameSave, player, true);
}
if (newState == null)
{
return(messages, currentState, new List <string> {
currentState.Id
});
private bool ResolveIf(PlayerGameSave gameSave, string command)
{
var split = command.Split(null);
split = split.Where(a => !string.IsNullOrEmpty(a)).ToArray();
bool andMore = false;
bool orMore = false;
int indexMod = 0;
bool?initialResult = null;
if (split.Length > 2 && (split[2] == "=" || split[2] == ">" || split[2] == "<"))
{
if (split.Length > 4)
{
andMore = split[4] == "#and";
orMore = split[4] == "#or";
}
var data1 = ResolveValue(split[1], gameSave);
var conditional = split[2];
var data2 = ConcactSplitAfterxUptoCharacter(split, 3, "#");
var doesData2Exist = _gameDataService.GetData(gameSave, data2);
if (doesData2Exist != null)
{
data2 = doesData2Exist;
}
data2 = ResolveValue(data2, gameSave);
if (split[0] == "#ifnot")
{
initialResult = !ResolveOperation(data1, data2, conditional, gameSave);
}
if (split[0] == "#if")
{
initialResult = ResolveOperation(data1, data2, conditional, gameSave);
}
indexMod = 5;
}
else
{
if (split.Length > 2)
{
andMore = split[2] == "#and";
orMore = split[2] == "#or";
}
bool exists = _gameDataService.DataExists(gameSave, split[1]);
if (split[0] == "#ifnot")
{
initialResult = !exists;
}
if (split[0] == "#if")
{
initialResult = exists;
}
indexMod = 3;
}
if (andMore)
{
return(initialResult.Value && ResolveIf(gameSave, ConcatSplitAfterIndex(split, indexMod)));
}
else if (orMore)
{
return(initialResult.Value || ResolveIf(gameSave, ConcatSplitAfterIndex(split, indexMod)));
}
else
{
return(initialResult.Value);
}
throw new ApplicationException("Error parsing: " + command);
}
public void WarningMessage(string message, PlayerGameSave gameSave)
{
WarningMessages.Add(new UniqueTestDataItemWithSave {
Value = message, GameSave = gameSave
});
}
public void PotentialEndStateFound(string stateId, PlayerGameSave gameSave)
{
PotentialEndStates.Add(new UniqueTestDataItemWithSave {
Value = stateId, GameSave = gameSave
});
}
public void ErrorMessageEncountered(string errorMessage, PlayerGameSave gameSave)
{
ErrorMessages.Add(new UniqueTestDataItemWithSave {
Value = errorMessage, GameSave = gameSave
});
}
public void GrammarMistakeFound(string grammarMessage, PlayerGameSave gameSave)
{
GrammarMistakes.Add(new UniqueTestDataItemWithSave {
Value = grammarMessage, GameSave = gameSave
});
}
internal void CheckForNewVariables(PlayerGameSave gameState)
{
gameState.GameSaveData.ForEach(a => VariableNameEncountered(a.Name));
}
