private void GetObjects(RulesetNode rulesetNode, string file, TranslateRule globalTranslate, TranslateRule playerTranslate)
{
string absolute = new Uri(file).AbsolutePath;
// Get the defined types
foreach (var definedType in rulesetNode.DefinedTypes)
{
try
{
if (DefinedTypes.Any(type => type.Name == definedType.Name))
{
throw SyntaxErrorException.NameAlreadyDefined(definedType.Location);
}
DefinedTypes.Add(DefinedType.GetDefinedType(definedType));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the user methods.
for (int i = 0; i < rulesetNode.UserMethods.Length; i++)
{
try
{
UserMethods.Add(UserMethod.CreateUserMethod(Root, rulesetNode.UserMethods[i]));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the rules
RuleNodes.AddRange(rulesetNode.Rules);
List <string> importedFiles = new List <string>();
foreach (ImportObjectNode importObject in rulesetNode.ObjectImports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importObject.File, file, importObject.Location);
if (!importer.AlreadyImported)
{
importedFiles.Add(importer.ResultingPath);
switch (importer.FileType)
{
case ".obj":
importer.FileData.Update();
string content = importer.FileData.Content;
Model newModel = Model.ImportObj(content);
new ModelVar(importObject.Name, Root, importObject, newModel);
break;
case ".pathmap":
PathMap pathMap = PathMap.ImportFromXML(importer.ResultingPath);
new PathMapVar(this, importObject.Name, Root, importObject, pathMap);
break;
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the variables
foreach (var definedVar in rulesetNode.DefinedVars)
{
try
{
IndexedVar var;
if (!definedVar.Extended)
{
if (definedVar.OverrideID == -1)
{
var = IndexedVar.AssignVar(VarCollection, Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
else
{
var = IndexedVar.AssignVar(
VarCollection,
Root,
definedVar.VariableName,
definedVar.IsGlobal,
new WorkshopVariable(definedVar.IsGlobal, definedVar.OverrideID, VarCollection.WorkshopNameFromCodeName(definedVar.IsGlobal, definedVar.VariableName)),
definedVar
);
}
}
else
{
var = IndexedVar.AssignVarExt(VarCollection, Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
if (definedVar.Type != null)
{
var.Type = GetDefinedType(definedVar.Type, definedVar.Location);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
private LanguageServerOptions AddRequests(LanguageServerOptions options)
{
// Pathmap creation is seperated into 2 requests, 'pathmapFromClipboard' and 'pathmapApply'.
// Pathmap generation request.
options.OnRequest <object, string>("pathmapFromClipboard", _ => Task <string> .Run(() => {
// Create the error handler for pathmap parser.
ServerPathmapHandler error = new ServerPathmapHandler();
// Get the pathmap. 'map' will be null if there is an error.
try
{
PathMap map = PathMap.ImportFromCSV(Clipboard.GetText(), error);
if (map == null)
{
return(error.Message);
}
else
{
lastMap = map;
return("success");
}
}
catch (Exception ex)
{
return(ex.Message);
}
}));
// Pathmap save request.
options.OnRequest <Newtonsoft.Json.Linq.JToken>("pathmapApply", uriToken => Task.Run(() => {
// Save 'lastMap' to a file.
string result = lastMap.ExportAsXML();
string output = uriToken["path"].ToObject <string>().Trim('/');
using (FileStream fs = File.Create(output))
{
Byte[] info = Encoding.Unicode.GetBytes(result);
fs.Write(info, 0, info.Length);
}
}));
// Pathmap editor request.
options.OnRequest <PathmapDocument, bool>("pathmapEditor", (editFileToken) => Task <bool> .Run(() => {
DeltinScript compile;
if (editFileToken.Text == null)
{
string editor = Extras.CombinePathWithDotNotation(null, "!PathfindEditor.del");
compile = new DeltinScript(new TranslateSettings(editor)
{
OutputLanguage = ConfigurationHandler.OutputLanguage
});
}
else
{
compile = Editor.Generate(PathMap.ImportFromXML(editFileToken.Text), ConfigurationHandler.OutputLanguage);
}
Clipboard.SetText(compile.WorkshopCode);
return(true);
}));
return(options);
}
