742 lines
30 KiB
C#
742 lines
30 KiB
C#
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using CodeImp.DoomBuilder.Compilers;
|
|
using CodeImp.DoomBuilder.Data;
|
|
using CodeImp.DoomBuilder.ZDoom;
|
|
using CodeImp.DoomBuilder.GZBuilder.Data;
|
|
using System.Windows.Forms;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.SRB2
|
|
{
|
|
internal sealed class LuaObjectParser : ZDTextParser
|
|
{
|
|
#region ================== Delegates
|
|
|
|
public delegate void IncludeDelegate(LuaObjectParser parser, string includefile, bool clearerror);
|
|
public IncludeDelegate OnInclude;
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
private Dictionary<string, SRB2Object> objects;
|
|
/*private Dictionary<string, SRB2State> states;
|
|
private List<string> objectfreeslots;
|
|
private List<string> statefreeslots;
|
|
private List<string> spritefreeslots;*/
|
|
private IDictionary<string, int> flagValues = new Dictionary<string,int>
|
|
{
|
|
{ "MF_SPECIAL", 0x1 },
|
|
{ "MF_SOLID", 0x2 },
|
|
{ "MF_SHOOTABLE", 0x4 },
|
|
{ "MF_NOSECTOR", 0x8 },
|
|
{ "MF_NOBLOCKMAP", 0x10 },
|
|
{ "MF_PAPERCOLLISION", 0x20 },
|
|
{ "MF_PUSHABLE", 0x40 },
|
|
{ "MF_BOSS", 0x80 },
|
|
{ "MF_SPAWNCEILING", 0x100 },
|
|
{ "MF_NOGRAVITY", 0x200 },
|
|
{ "MF_AMBIENT", 0x400 },
|
|
{ "MF_SLIDEME", 0x800 },
|
|
{ "MF_NOCLIP", 0x1000 },
|
|
{ "MF_FLOAT", 0x2000 },
|
|
{ "MF_BOXICON", 0x4000 },
|
|
{ "MF_MISSILE", 0x8000 },
|
|
{ "MF_SPRING", 0x10000 },
|
|
{ "MF_BOUNCE", 0x20000 },
|
|
{ "MF_MONITOR", 0x40000 },
|
|
{ "MF_NOTHINK", 0x80000 },
|
|
{ "MF_FIRE", 0x100000 },
|
|
{ "MF_NOCLIPHEIGHT", 0x200000 },
|
|
{ "MF_ENEMY", 0x400000 },
|
|
{ "MF_SCENERY", 0x800000 },
|
|
{ "MF_PAIN", 0x1000000 },
|
|
{ "MF_STICKY", 0x2000000 },
|
|
{ "MF_NIGHTSITEM", 0x4000000 },
|
|
{ "MF_NOCLIPTHING", 0x8000000 },
|
|
{ "MF_GRENADEBOUNCE", 0x10000000 },
|
|
{ "MF_RUNSPAWNFUNC", 0x20000000 }
|
|
};
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
public Dictionary<string, SRB2Object> Objects { get { return objects; } }
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor
|
|
|
|
public LuaObjectParser()
|
|
{
|
|
// Syntax
|
|
whitespace = "\n \t\r\u00A0";
|
|
specialtokens = "=\n";
|
|
|
|
objects = new Dictionary<string, SRB2Object>();
|
|
/*states = new Dictionary<string,SRB2State>();
|
|
objectfreeslots = new List<string>();
|
|
statefreeslots = new List<string>();
|
|
spritefreeslots = new List<string>();*/
|
|
}
|
|
|
|
// Disposer
|
|
public void Dispose()
|
|
{
|
|
objects = null;
|
|
/*states = null;
|
|
objectfreeslots = null;
|
|
statefreeslots = null;
|
|
spritefreeslots = null;*/
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Parsing
|
|
|
|
override public bool Parse(Stream stream, string sourcefilename, bool clearerrors)
|
|
{
|
|
if (!base.Parse(stream, sourcefilename, clearerrors)) return false;
|
|
|
|
// Keep local data
|
|
Stream localstream = datastream;
|
|
string localsourcename = sourcename;
|
|
BinaryReader localreader = datareader;
|
|
|
|
string token;
|
|
|
|
while (SkipWhitespace(true))
|
|
{
|
|
token = ReadToken();
|
|
if (!string.IsNullOrEmpty(token))
|
|
{
|
|
if (!token.StartsWith("mobjinfo[") || !token.EndsWith("]")) continue;
|
|
string objname = token.Substring(9).TrimEnd(new char[] { ']' });
|
|
string name = objname;
|
|
string sprite = DataManager.INTERNAL_PREFIX + "unknownthing";
|
|
string category = "";
|
|
string[] states = new string[8];
|
|
int mapThingNum = -1;
|
|
int radius = 0;
|
|
int height = 0;
|
|
int flags = 0;
|
|
Dictionary<string, string> newflags = new Dictionary<string, string>();
|
|
string angletext = "";
|
|
string parametertext = "";
|
|
string flagsvaluetext = "";
|
|
bool arrow = false;
|
|
bool tagthing = false;
|
|
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
if (token != "=")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
if (token != "{")
|
|
{
|
|
ReportError("Invalid object definition, missing {");
|
|
return false;
|
|
}
|
|
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
bool finished = false;
|
|
bool blockclosed = false;
|
|
while (token != null)
|
|
{
|
|
if (finished) break;
|
|
switch (token)
|
|
{
|
|
case "$Name":
|
|
case "$Title":
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
name = ZDTextParser.StripQuotes(token);
|
|
break;
|
|
case "$Sprite":
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
if (((token.Length > DataManager.INTERNAL_PREFIX.Length) &&
|
|
token.ToLowerInvariant().StartsWith(DataManager.INTERNAL_PREFIX)) ||
|
|
General.Map.Data.GetSpriteExists(token))
|
|
{
|
|
sprite = token;
|
|
break;
|
|
}
|
|
LogWarning("The sprite \"" + token + "\" assigned by the \"$sprite\" property does not exist");
|
|
break;
|
|
case "$Category":
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
category = token;
|
|
break;
|
|
case "$Flags1Text":
|
|
case "$Flags2Text":
|
|
case "$Flags4Text":
|
|
case "$Flags8Text":
|
|
string index = token.Substring(6,1);
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
newflags[index] = "[" + index + "] " + ZDTextParser.StripQuotes(token);
|
|
break;
|
|
case "$AngleText":
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
angletext = ZDTextParser.StripQuotes(token);
|
|
break;
|
|
case "$ParameterText":
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
parametertext = ZDTextParser.StripQuotes(token);
|
|
break;
|
|
case "$FlagsValueText":
|
|
SkipWhitespace(true);
|
|
token = ReadLine();
|
|
flagsvaluetext = ZDTextParser.StripQuotes(token);
|
|
break;
|
|
case "$Arrow":
|
|
case "$Angled":
|
|
arrow = true;
|
|
break;
|
|
case "$NoArrow":
|
|
case "$NotAngled":
|
|
arrow = false;
|
|
break;
|
|
case "$TagThing":
|
|
tagthing = true;
|
|
break;
|
|
case "doomednum":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out mapThingNum))
|
|
LogWarning("Could not parse map thing number");
|
|
break;
|
|
case "radius":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
if (!ParseWithArithmetic(token, out radius))
|
|
LogWarning("Could not parse radius");
|
|
radius /= 65536;
|
|
break;
|
|
case "height":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
if (!ParseWithArithmetic(token, out height))
|
|
LogWarning("Could not parse height");
|
|
height /= 65536;
|
|
break;
|
|
case "spawnstate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[0] = token;
|
|
break;
|
|
case "seestate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[1] = token;
|
|
break;
|
|
case "painstate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[2] = token;
|
|
break;
|
|
case "meleestate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[3] = token;
|
|
break;
|
|
case "missilestate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[4] = token;
|
|
break;
|
|
case "deathstate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[5] = token;
|
|
break;
|
|
case "xdeathstate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[6] = token;
|
|
break;
|
|
case "raisestate":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
states[7] = token;
|
|
break;
|
|
case "flags":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
if (!ParseFlags(token, out flags))
|
|
LogWarning("Could not parse flags");
|
|
break;
|
|
case "spawnhealth":
|
|
case "seesound":
|
|
case "reactiontime":
|
|
case "attacksound":
|
|
case "painchance":
|
|
case "painsound":
|
|
case "deathsound":
|
|
case "speed":
|
|
case "dispoffset":
|
|
case "mass":
|
|
case "damage":
|
|
case "activesound":
|
|
if (!ReadParameter(out token, out finished)) return false;
|
|
break;
|
|
case "}":
|
|
finished = true;
|
|
blockclosed = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!blockclosed)
|
|
{
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
}
|
|
}
|
|
|
|
if (token != "}")
|
|
{
|
|
ReportError("Invalid object definition, missing }");
|
|
return false;
|
|
}
|
|
|
|
if (mapThingNum > 0)
|
|
{
|
|
SRB2Object o = new SRB2Object(name, sprite, category, states, mapThingNum, radius, height, flags,
|
|
newflags, angletext, parametertext, flagsvaluetext, arrow, tagthing);
|
|
if (objects.ContainsKey(objname))
|
|
objects[objname] = o;
|
|
else
|
|
objects.Add(objname, o);
|
|
}
|
|
}
|
|
}
|
|
// All done
|
|
return !this.HasError;
|
|
}
|
|
|
|
// This skips whitespace on the stream, placing the read
|
|
// position right before the first non-whitespace character
|
|
// Returns false when the end of the stream is reached
|
|
protected internal override bool SkipWhitespace(bool skipnewline)
|
|
{
|
|
int offset = skipnewline ? 0 : 1;
|
|
char c;
|
|
prevstreamposition = datastream.Position; //mxd
|
|
|
|
do
|
|
{
|
|
if (datastream.Position == datastream.Length) return false;
|
|
c = (char)datareader.ReadByte();
|
|
|
|
// Check if this is comment
|
|
if (c == '/' || c == '-')
|
|
{
|
|
if (datastream.Position == datastream.Length) return false;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if (c2 == c)
|
|
{
|
|
// Check if not a special comment with a token
|
|
if (datastream.Position == datastream.Length) return false;
|
|
char c3 = (char)datareader.ReadByte();
|
|
if (c3 != '$')
|
|
{
|
|
// Skip entire line
|
|
char c4 = ' ';
|
|
while ((c4 != '\n') && (datastream.Position < datastream.Length)) { c4 = (char)datareader.ReadByte(); }
|
|
c = c4;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment
|
|
c = c3;
|
|
}
|
|
}
|
|
else if (c2 == '*')
|
|
{
|
|
// Skip until */
|
|
char c4, c3 = '\0';
|
|
prevstreamposition = datastream.Position; //mxd
|
|
do
|
|
{
|
|
if (datastream.Position == datastream.Length) //mxd
|
|
{
|
|
// ZDoom doesn't give even a warning message about this, so we shouldn't report error or fail parsing.
|
|
General.ErrorLogger.Add(ErrorType.Warning, "Lua warning in '" + sourcename + "', line " + GetCurrentLineNumber() + ". Block comment is not closed.");
|
|
return false;
|
|
}
|
|
|
|
c4 = c3;
|
|
c3 = (char)datareader.ReadByte();
|
|
}
|
|
while ((c4 != '*') || (c3 != '/'));
|
|
c = ' ';
|
|
}
|
|
else
|
|
{
|
|
// Not a comment, rewind from reading c2
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
}
|
|
}
|
|
|
|
if (c == '-')
|
|
{
|
|
if (datastream.Position == datastream.Length) return false;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if (c2 == '-')
|
|
{
|
|
if (datastream.Position == datastream.Length) return false;
|
|
char c3 = (char)datareader.ReadByte();
|
|
if (c3 == '[')
|
|
{
|
|
if (datastream.Position == datastream.Length) return false;
|
|
char c4 = (char)datareader.ReadByte();
|
|
if (c4 == '[')
|
|
{
|
|
//Skip until ]]
|
|
char c5 = '\0';
|
|
char c6 = '\0';
|
|
prevstreamposition = datastream.Position; //mxd
|
|
do
|
|
{
|
|
if (datastream.Position == datastream.Length) //mxd
|
|
{
|
|
General.ErrorLogger.Add(ErrorType.Warning, "Lua warning in '" + sourcename + "', line " + GetCurrentLineNumber() + ". Block comment is not closed.");
|
|
return false;
|
|
}
|
|
|
|
c5 = c6;
|
|
c6 = (char)datareader.ReadByte();
|
|
}
|
|
while ((c6 != ']') || (c5 != ']'));
|
|
c = ' ';
|
|
}
|
|
else
|
|
{
|
|
// Not a multiline comment, rewind from reading c4
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
}
|
|
}
|
|
while ((c3 != '\n') && (datastream.Position < datastream.Length)) { c3 = (char)datareader.ReadByte(); }
|
|
c = c3;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment, rewind from reading c2
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
}
|
|
}
|
|
}
|
|
while (whitespace.IndexOf(c, offset) > -1);
|
|
|
|
// Go one character back so we can read this non-whitespace character again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
return true;
|
|
}
|
|
|
|
protected internal override string ReadToken(bool multiline)
|
|
{
|
|
//mxd. Return empty string when the end of the stream has been reached
|
|
if (datastream.Position == datastream.Length) return string.Empty;
|
|
|
|
//mxd. Store starting position
|
|
prevstreamposition = datastream.Position;
|
|
|
|
string token = "";
|
|
bool quotedstring = false;
|
|
|
|
// Start reading
|
|
char c = (char)datareader.ReadByte();
|
|
while (!IsWhitespace(c) || quotedstring || IsSpecialToken(c))
|
|
{
|
|
//mxd. Break at newline?
|
|
if (!multiline && c == '\r')
|
|
{
|
|
// Go one character back so line number is correct
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
return token;
|
|
}
|
|
|
|
// Special token?
|
|
if (!quotedstring && IsSpecialToken(c))
|
|
{
|
|
// Not reading a token yet?
|
|
if (token.Length == 0)
|
|
{
|
|
// This is our whole token
|
|
token += c;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// This is a new token and shouldn't be read now
|
|
// Go one character back so we can read this token again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Quote?
|
|
if (c == '"')
|
|
{
|
|
// Quote to end the string?
|
|
if (quotedstring) quotedstring = false;
|
|
|
|
// First character is a quote?
|
|
if (token.Length == 0) quotedstring = true;
|
|
|
|
token += c;
|
|
}
|
|
// Potential comment?
|
|
else if ((c == '/') && !quotedstring)
|
|
{
|
|
// Check the next byte
|
|
if (datastream.Position == datastream.Length) return token;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if ((c2 == '/') || (c2 == '*'))
|
|
{
|
|
// This is a comment start, so the token ends here
|
|
// Go two characters back so we can read this comment again
|
|
datastream.Seek(-2, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment
|
|
// Go one character back so we can read this char again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
token += c;
|
|
}
|
|
}
|
|
// Potential comment?
|
|
else if ((c == '-') && !quotedstring)
|
|
{
|
|
// Check the next byte
|
|
if (datastream.Position == datastream.Length) return token;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if (c2 == '-')
|
|
{
|
|
// This is a comment start, so the token ends here
|
|
// Go two characters back so we can read this comment again
|
|
datastream.Seek(-2, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment
|
|
// Go one character back so we can read this char again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
token += c;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
token += c;
|
|
}
|
|
}
|
|
|
|
// Next character
|
|
if (datastream.Position < datastream.Length)
|
|
c = (char)datareader.Read();
|
|
else
|
|
break;
|
|
}
|
|
|
|
return token;
|
|
}
|
|
|
|
// This reads a token (all sequential non-whitespace characters or a single character) using custom set of special tokens
|
|
// Returns null when the end of the stream has been reached (mxd)
|
|
protected internal override string ReadToken(string specialTokens)
|
|
{
|
|
// Return null when the end of the stream has been reached
|
|
if (datastream.Position == datastream.Length) return null;
|
|
|
|
//mxd. Store starting position
|
|
prevstreamposition = datastream.Position;
|
|
|
|
string token = "";
|
|
bool quotedstring = false;
|
|
|
|
// Start reading
|
|
char c = (char)datareader.ReadByte();
|
|
while (!IsWhitespace(c) || quotedstring || specialTokens.IndexOf(c) != -1)
|
|
{
|
|
// Special token?
|
|
if (!quotedstring && specialTokens.IndexOf(c) != -1)
|
|
{
|
|
// Not reading a token yet?
|
|
if (token.Length == 0)
|
|
{
|
|
// This is our whole token
|
|
token += c;
|
|
break;
|
|
}
|
|
|
|
// This is a new token and shouldn't be read now
|
|
// Go one character back so we can read this token again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Quote?
|
|
if (c == '"')
|
|
{
|
|
// Quote to end the string?
|
|
if (quotedstring) quotedstring = false;
|
|
|
|
// First character is a quote?
|
|
if (token.Length == 0) quotedstring = true;
|
|
|
|
token += c;
|
|
}
|
|
// Potential comment?
|
|
else if ((c == '/') && !quotedstring)
|
|
{
|
|
// Check the next byte
|
|
if (datastream.Position == datastream.Length) return token;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if ((c2 == '/') || (c2 == '*'))
|
|
{
|
|
// This is a comment start, so the token ends here
|
|
// Go two characters back so we can read this comment again
|
|
datastream.Seek(-2, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment
|
|
// Go one character back so we can read this char again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
token += c;
|
|
}
|
|
}
|
|
// Potential comment?
|
|
else if ((c == '-') && !quotedstring)
|
|
{
|
|
// Check the next byte
|
|
if (datastream.Position == datastream.Length) return token;
|
|
char c2 = (char)datareader.ReadByte();
|
|
if (c2 == '-')
|
|
{
|
|
// This is a comment start, so the token ends here
|
|
// Go two characters back so we can read this comment again
|
|
datastream.Seek(-2, SeekOrigin.Current);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Not a comment
|
|
// Go one character back so we can read this char again
|
|
datastream.Seek(-1, SeekOrigin.Current);
|
|
token += c;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
token += c;
|
|
}
|
|
}
|
|
|
|
// Next character
|
|
if (datastream.Position < datastream.Length)
|
|
c = (char)datareader.Read();
|
|
else
|
|
break;
|
|
}
|
|
|
|
return token;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
private bool ReadParameter(out string output, out bool finished)
|
|
{
|
|
output = "";
|
|
finished = false;
|
|
SkipWhitespace(true);
|
|
string token = ReadToken();
|
|
if (token != "=")
|
|
{
|
|
ReportError("Invalid parameter definition, missing =");
|
|
return false;
|
|
}
|
|
SkipWhitespace(true);
|
|
token = ReadToken();
|
|
if (!token.EndsWith(","))
|
|
{
|
|
finished = true;
|
|
}
|
|
output = token.TrimEnd(new char[] { ',' });
|
|
return true;
|
|
}
|
|
|
|
private bool ParseWithArithmetic(string input, out int output)
|
|
{
|
|
output = 0;
|
|
string[] tokens = input.Split(new char[] { '+' });
|
|
foreach (string t in tokens)
|
|
{
|
|
int val = 0;
|
|
if (!ParseMultiplication(t, out val))
|
|
return false;
|
|
output += val;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool ParseMultiplication(string input, out int output)
|
|
{
|
|
output = 1;
|
|
string[] tokens = input.Split(new char[] { '*' });
|
|
foreach (string t in tokens)
|
|
{
|
|
string trimmed = t.Trim();
|
|
int val = 1;
|
|
if (trimmed == "FRACUNIT") val = 65536;
|
|
else if (!int.TryParse(trimmed, NumberStyles.Integer, CultureInfo.InvariantCulture, out val))
|
|
return false;
|
|
output *= val;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool ParseFlags(string input, out int output)
|
|
{
|
|
output = 0;
|
|
string[] tokens = input.Split(new char[] { '|' });
|
|
foreach (string token in tokens)
|
|
{
|
|
if (flagValues.ContainsKey(token))
|
|
{
|
|
output |= flagValues[token];
|
|
}
|
|
else
|
|
{
|
|
int val = 0;
|
|
if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out val))
|
|
return false;
|
|
output |= val;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected override string GetLanguageType()
|
|
{
|
|
return "Lua";
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|