mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-23 12:22:35 +00:00
654 lines
18 KiB
C#
654 lines
18 KiB
C#
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using CodeImp.DoomBuilder.Config;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.ZDoom
|
|
{
|
|
public sealed class ActorStructure
|
|
{
|
|
#region ================== Constants
|
|
|
|
private readonly string[] SPRITE_POSTFIXES = new string[] {"2C8", "2D8", "2A8", "2B8", "1C1", "1D1", "1A1", "1B1", "A2", "A1", "A0", "2", "1", "0" };
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
// Declaration
|
|
private string classname;
|
|
private string inheritclass;
|
|
private string replaceclass;
|
|
private int doomednum = -1;
|
|
|
|
// Inheriting
|
|
private ActorStructure baseclass;
|
|
private bool skipsuper;
|
|
|
|
// Flags
|
|
private Dictionary<string, bool> flags;
|
|
|
|
// Properties
|
|
private Dictionary<string, List<string>> props;
|
|
private List<string> userVars; //mxd
|
|
|
|
// States
|
|
private Dictionary<string, StateStructure> states;
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
public Dictionary<string, bool> Flags { get { return flags; } }
|
|
public Dictionary<string, List<string>> Properties { get { return props; } }
|
|
public string ClassName { get { return classname; } }
|
|
public string InheritsClass { get { return inheritclass; } }
|
|
public string ReplacesClass { get { return replaceclass; } }
|
|
public ActorStructure BaseClass { get { return baseclass; } }
|
|
public int DoomEdNum { get { return doomednum; } }
|
|
public List<string> UserVars { get { return userVars; } } //mxd
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor / Disposer
|
|
|
|
// Constructor
|
|
internal ActorStructure(DecorateParser parser)
|
|
{
|
|
// Initialize
|
|
flags = new Dictionary<string, bool>();
|
|
props = new Dictionary<string, List<string>>();
|
|
states = new Dictionary<string, StateStructure>();
|
|
userVars = new List<string>();//mxd
|
|
bool haveBaseClass = false;//mxd
|
|
|
|
// Always define a game property, but default to 0 values
|
|
props["game"] = new List<string>();
|
|
|
|
inheritclass = "actor";
|
|
replaceclass = null;
|
|
baseclass = null;
|
|
skipsuper = false;
|
|
|
|
// First next token is the class name
|
|
parser.SkipWhitespace(true);
|
|
classname = parser.StripTokenQuotes(parser.ReadToken());
|
|
if(string.IsNullOrEmpty(classname))
|
|
{
|
|
parser.ReportError("Expected actor class name");
|
|
return;
|
|
}
|
|
|
|
// Parse tokens before entering the actor scope
|
|
while(parser.SkipWhitespace(true))
|
|
{
|
|
string token = parser.ReadToken();
|
|
if(!string.IsNullOrEmpty(token))
|
|
{
|
|
token = token.ToLowerInvariant();
|
|
if(token == ":")
|
|
{
|
|
haveBaseClass = true; //mxd
|
|
// The next token must be the class to inherit from
|
|
parser.SkipWhitespace(true);
|
|
inheritclass = parser.StripTokenQuotes(parser.ReadToken());
|
|
if(string.IsNullOrEmpty(inheritclass) || parser.IsSpecialToken(inheritclass))
|
|
{
|
|
parser.ReportError("Expected class name to inherit from");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Find the actor to inherit from
|
|
baseclass = parser.GetArchivedActorByName(inheritclass);
|
|
}
|
|
}
|
|
else if(token == "replaces")
|
|
{
|
|
// The next token must be the class to replace
|
|
parser.SkipWhitespace(true);
|
|
replaceclass = parser.StripTokenQuotes(parser.ReadToken());
|
|
if(string.IsNullOrEmpty(replaceclass) || parser.IsSpecialToken(replaceclass))
|
|
{
|
|
parser.ReportError("Expected class name to replace");
|
|
return;
|
|
}
|
|
}
|
|
else if(token == "native")
|
|
{
|
|
// Igore this token
|
|
}
|
|
else if(token == "{")
|
|
{
|
|
// Actor scope begins here,
|
|
// break out of this parse loop
|
|
break;
|
|
}
|
|
else if(token == "-")
|
|
{
|
|
// This could be a negative doomednum (but our parser sees the - as separate token)
|
|
// So read whatever is after this token and ignore it (negative doomednum indicates no doomednum)
|
|
parser.ReadToken();
|
|
}
|
|
else
|
|
{
|
|
// Check if numeric
|
|
if(!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out doomednum))
|
|
{
|
|
// Not numeric!
|
|
parser.ReportError("Expected numeric editor thing number or start of actor scope while parsing '" + classname + "'");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.ReportError("Unexpected end of structure");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Now parse the contents of actor structure
|
|
string previoustoken = "";
|
|
while(parser.SkipWhitespace(true))
|
|
{
|
|
string token = parser.ReadToken();
|
|
token = token.ToLowerInvariant();
|
|
|
|
if((token == "+") || (token == "-"))
|
|
{
|
|
// Next token is a flag (option) to set or remove
|
|
bool flagvalue = (token == "+");
|
|
parser.SkipWhitespace(true);
|
|
string flagname = parser.ReadToken();
|
|
if(!string.IsNullOrEmpty(flagname))
|
|
{
|
|
// Add the flag with its value
|
|
flagname = flagname.ToLowerInvariant();
|
|
flags[flagname] = flagvalue;
|
|
}
|
|
else
|
|
{
|
|
parser.ReportError("Expected flag name");
|
|
return;
|
|
}
|
|
}
|
|
else if((token == "action") || (token == "native"))
|
|
{
|
|
// We don't need this, ignore up to the first next ;
|
|
while(parser.SkipWhitespace(true))
|
|
{
|
|
string t = parser.ReadToken();
|
|
if((t == ";") || (t == null)) break;
|
|
}
|
|
}
|
|
else if(token == "skip_super")
|
|
{
|
|
skipsuper = true;
|
|
}
|
|
else if(token == "states")
|
|
{
|
|
// Now parse actor states until we reach the end of the states structure
|
|
while(parser.SkipWhitespace(true))
|
|
{
|
|
string statetoken = parser.ReadToken();
|
|
if(!string.IsNullOrEmpty(statetoken))
|
|
{
|
|
// Start of scope?
|
|
if(statetoken == "{")
|
|
{
|
|
// This is fine
|
|
}
|
|
// End of scope?
|
|
else if(statetoken == "}")
|
|
{
|
|
// Done with the states,
|
|
// break out of this parse loop
|
|
break;
|
|
}
|
|
// State label?
|
|
else if(statetoken == ":")
|
|
{
|
|
if(!string.IsNullOrEmpty(previoustoken))
|
|
{
|
|
// Parse actor state
|
|
StateStructure st = new StateStructure(this, parser, previoustoken);
|
|
if(parser.HasError) return;
|
|
states[previoustoken.ToLowerInvariant()] = st;
|
|
}
|
|
else
|
|
{
|
|
parser.ReportError("Unexpected end of structure");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Keep token
|
|
previoustoken = statetoken;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.ReportError("Unexpected end of structure");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if(token == "var") //mxd
|
|
{
|
|
while(parser.SkipWhitespace(true)) {
|
|
string t = parser.ReadToken();
|
|
if((t == ";") || (t == null)) break;
|
|
if(t.StartsWith("user_") && !userVars.Contains(t)) userVars.Add(t);
|
|
}
|
|
}
|
|
else if(token == "}")
|
|
{
|
|
// Actor scope ends here,
|
|
// break out of this parse loop
|
|
break;
|
|
}
|
|
// Monster property?
|
|
else if(token == "monster")
|
|
{
|
|
// This sets certain flags we are interested in
|
|
flags["shootable"] = true;
|
|
flags["countkill"] = true;
|
|
flags["solid"] = true;
|
|
flags["canpushwalls"] = true;
|
|
flags["canusewalls"] = true;
|
|
flags["activatemcross"] = true;
|
|
flags["canpass"] = true;
|
|
flags["ismonster"] = true;
|
|
}
|
|
// Projectile property?
|
|
else if(token == "projectile")
|
|
{
|
|
// This sets certain flags we are interested in
|
|
flags["noblockmap"] = true;
|
|
flags["nogravity"] = true;
|
|
flags["dropoff"] = true;
|
|
flags["missile"] = true;
|
|
flags["activateimpact"] = true;
|
|
flags["activatepcross"] = true;
|
|
flags["noteleport"] = true;
|
|
}
|
|
// Clearflags property?
|
|
else if(token == "clearflags")
|
|
{
|
|
// Clear all flags
|
|
flags.Clear();
|
|
}
|
|
// Game property?
|
|
else if(token == "game")
|
|
{
|
|
// Include all tokens on the same line
|
|
List<string> games = new List<string>();
|
|
while(parser.SkipWhitespace(false))
|
|
{
|
|
string v = parser.ReadToken();
|
|
if(v == null)
|
|
{
|
|
parser.ReportError("Unexpected end of structure");
|
|
return;
|
|
}
|
|
if(v == "\n") break;
|
|
if (v == "}") return; //mxd
|
|
if(v != ",")
|
|
games.Add(v.ToLowerInvariant());
|
|
}
|
|
props[token] = games;
|
|
}
|
|
// Property
|
|
else
|
|
{
|
|
// Property begins with $? Then the whole line is a single value
|
|
if(token.StartsWith("$"))
|
|
{
|
|
// This is for editor-only properties such as $sprite and $category
|
|
List<string> values = new List<string>();
|
|
if(parser.SkipWhitespace(false))
|
|
values.Add(parser.ReadLine());
|
|
else
|
|
values.Add("");
|
|
props[token] = values;
|
|
}
|
|
else
|
|
{
|
|
// Next tokens up until the next newline are values
|
|
List<string> values = new List<string>();
|
|
while(parser.SkipWhitespace(false))
|
|
{
|
|
string v = parser.ReadToken();
|
|
if(v == null)
|
|
{
|
|
parser.ReportError("Unexpected end of structure");
|
|
return;
|
|
}
|
|
if(v == "\n") break;
|
|
if (v == "}") return; //mxd
|
|
if(v != ",")
|
|
values.Add(v);
|
|
}
|
|
props[token] = values;
|
|
}
|
|
}
|
|
|
|
// Keep token
|
|
previoustoken = token;
|
|
}
|
|
|
|
//mxd. Check if baseclass is valid
|
|
if(haveBaseClass && doomednum > -1 && baseclass == null) {
|
|
//check if this class inherits from a class defined in game configuration
|
|
Dictionary<int, ThingTypeInfo> things = General.Map.Config.GetThingTypes();
|
|
inheritclass = inheritclass.ToLowerInvariant();
|
|
|
|
foreach(KeyValuePair<int, ThingTypeInfo> ti in things) {
|
|
if(ti.Value.ClassName == inheritclass) {
|
|
//states
|
|
if(states.Count == 0 && !string.IsNullOrEmpty(ti.Value.Sprite))
|
|
states.Add("spawn", new StateStructure(ti.Value.Sprite.Substring(0, 4)));
|
|
|
|
//flags
|
|
if(ti.Value.Hangs && !flags.ContainsKey("spawnceiling"))
|
|
flags["spawnceiling"] = true;
|
|
|
|
if(ti.Value.Blocking > 0 && !flags.ContainsKey("solid"))
|
|
flags["solid"] = true;
|
|
|
|
//properties
|
|
if(!props.ContainsKey("height"))
|
|
props["height"] = new List<string>() { ti.Value.Height.ToString() };
|
|
|
|
if(!props.ContainsKey("radius"))
|
|
props["radius"] = new List<string>() { ti.Value.Radius.ToString() };
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
General.ErrorLogger.Add(ErrorType.Warning, "Unable to find the DECORATE class '" + inheritclass + "' to inherit from, while parsing '" + classname + ":" + doomednum + "'");
|
|
}
|
|
}
|
|
|
|
// Disposer
|
|
public void Dispose()
|
|
{
|
|
baseclass = null;
|
|
flags = null;
|
|
props = null;
|
|
states = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
/// <summary>
|
|
/// This checks if the actor has a specific property.
|
|
/// </summary>
|
|
public bool HasProperty(string propname)
|
|
{
|
|
if(props.ContainsKey(propname))
|
|
return true;
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.HasProperty(propname);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This checks if the actor has a specific property with at least one value.
|
|
/// </summary>
|
|
public bool HasPropertyWithValue(string propname)
|
|
{
|
|
if(props.ContainsKey(propname) && (props[propname].Count > 0))
|
|
return true;
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.HasPropertyWithValue(propname);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns values of a specific property as a complete string. Returns an empty string when the propery has no values.
|
|
/// </summary>
|
|
public string GetPropertyAllValues(string propname)
|
|
{
|
|
if(props.ContainsKey(propname) && (props[propname].Count > 0))
|
|
return string.Join(" ", props[propname].ToArray());
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.GetPropertyAllValues(propname);
|
|
else
|
|
return "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns a specific value of a specific property as a string. Returns an empty string when the propery does not have the specified value.
|
|
/// </summary>
|
|
public string GetPropertyValueString(string propname, int valueindex)
|
|
{
|
|
if(props.ContainsKey(propname) && (props[propname].Count > valueindex))
|
|
return props[propname][valueindex];
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.GetPropertyValueString(propname, valueindex);
|
|
else
|
|
return "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns a specific value of a specific property as an integer. Returns 0 when the propery does not have the specified value.
|
|
/// </summary>
|
|
public int GetPropertyValueInt(string propname, int valueindex)
|
|
{
|
|
string str = GetPropertyValueString(propname, valueindex);
|
|
|
|
int intvalue;
|
|
if(int.TryParse(str, NumberStyles.Integer, CultureInfo.InvariantCulture, out intvalue))
|
|
return intvalue;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns a specific value of a specific property as a float. Returns 0.0f when the propery does not have the specified value.
|
|
/// </summary>
|
|
public float GetPropertyValueFloat(string propname, int valueindex)
|
|
{
|
|
string str = GetPropertyValueString(propname, valueindex);
|
|
|
|
float fvalue;
|
|
if(float.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture, out fvalue))
|
|
return fvalue;
|
|
else
|
|
return 0.0f;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns the status of a flag.
|
|
/// </summary>
|
|
public bool HasFlagValue(string flag)
|
|
{
|
|
if(flags.ContainsKey(flag))
|
|
return true;
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.HasFlagValue(flag);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns the status of a flag.
|
|
/// </summary>
|
|
public bool GetFlagValue(string flag, bool defaultvalue)
|
|
{
|
|
if(flags.ContainsKey(flag))
|
|
return flags[flag];
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.GetFlagValue(flag, defaultvalue);
|
|
else
|
|
return defaultvalue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This checks if a state has been defined.
|
|
/// </summary>
|
|
public bool HasState(string statename)
|
|
{
|
|
if(states.ContainsKey(statename))
|
|
return true;
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.HasState(statename);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This returns a specific state, or null when the state can't be found.
|
|
/// </summary>
|
|
public StateStructure GetState(string statename)
|
|
{
|
|
if(states.ContainsKey(statename))
|
|
return states[statename];
|
|
else if(!skipsuper && (baseclass != null))
|
|
return baseclass.GetState(statename);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This creates a list of all states, also those inherited from the base class.
|
|
/// </summary>
|
|
public Dictionary<string, StateStructure> GetAllStates()
|
|
{
|
|
Dictionary<string, StateStructure> list = new Dictionary<string, StateStructure>(states);
|
|
|
|
if(!skipsuper && (baseclass != null))
|
|
{
|
|
Dictionary<string, StateStructure> baselist = baseclass.GetAllStates();
|
|
foreach(KeyValuePair<string, StateStructure> s in baselist)
|
|
if(!list.ContainsKey(s.Key)) list.Add(s.Key, s.Value);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This checks if this actor is meant for the current decorate game support
|
|
/// </summary>
|
|
public bool CheckActorSupported()
|
|
{
|
|
// Check if we want to include this actor
|
|
string includegames = General.Map.Config.DecorateGames.ToLowerInvariant();
|
|
bool includeactor = (props["game"].Count == 0);
|
|
foreach(string g in props["game"])
|
|
includeactor |= includegames.Contains(g);
|
|
|
|
return includeactor;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This finds the best suitable sprite to use when presenting this actor to the user.
|
|
/// </summary>
|
|
public string FindSuitableSprite()
|
|
{
|
|
string result = "";
|
|
|
|
// Sprite forced?
|
|
if(HasPropertyWithValue("$sprite"))
|
|
{
|
|
return GetPropertyValueString("$sprite", 0);
|
|
}
|
|
else
|
|
{
|
|
// Try the idle state
|
|
if(HasState("idle"))
|
|
{
|
|
StateStructure s = GetState("idle");
|
|
string spritename = s.GetSprite(0);
|
|
if(!string.IsNullOrEmpty(spritename))
|
|
result = spritename;
|
|
}
|
|
|
|
// Try the see state
|
|
if(string.IsNullOrEmpty(result) && HasState("see"))
|
|
{
|
|
StateStructure s = GetState("see");
|
|
string spritename = s.GetSprite(0);
|
|
if(!string.IsNullOrEmpty(spritename))
|
|
result = spritename;
|
|
}
|
|
|
|
// Try the inactive state
|
|
if(string.IsNullOrEmpty(result) && HasState("inactive"))
|
|
{
|
|
StateStructure s = GetState("inactive");
|
|
string spritename = s.GetSprite(0);
|
|
if(!string.IsNullOrEmpty(spritename))
|
|
result = spritename;
|
|
}
|
|
|
|
// Try the spawn state
|
|
if(string.IsNullOrEmpty(result) && HasState("spawn"))
|
|
{
|
|
StateStructure s = GetState("spawn");
|
|
string spritename = s.GetSprite(0);
|
|
if(!string.IsNullOrEmpty(spritename))
|
|
result = spritename;
|
|
}
|
|
|
|
// Still no sprite found? then just pick the first we can find
|
|
if(string.IsNullOrEmpty(result))
|
|
{
|
|
Dictionary<string, StateStructure> list = GetAllStates();
|
|
foreach(StateStructure s in list.Values)
|
|
{
|
|
string spritename = s.GetSprite(0);
|
|
if(!string.IsNullOrEmpty(spritename))
|
|
{
|
|
result = spritename;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(result))
|
|
{
|
|
// The sprite name is not actually complete, we still have to append
|
|
// the direction characters to it. Find an existing sprite with direction.
|
|
foreach(string postfix in SPRITE_POSTFIXES)
|
|
{
|
|
if(General.Map.Data.GetSpriteExists(result + postfix))
|
|
return result + postfix;
|
|
}
|
|
}
|
|
}
|
|
|
|
// No sprite found
|
|
return "";
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|