private bool ValidateValue(ScriptObject scriptObject, ScriptObjectBehaviourData data)
{
if (!CheckCompatibilityOfSides(scriptObject, data))
{
return(false);
}
foreach (var s in scriptObject.lhsSchema.TypeList)
{
string type = scriptObject.rhsSchema == null?InferTypeFromRHS(scriptObject, data, s) : s;
string ltype = s;
if (ltype == null)
{
ltype = scriptObject.lhsSchema.targetScope.ToString();
}
if (type != ltype)
{
continue;
}
// primitive or scope
if (type == "value")
{
float val;
if (Single.TryParse(data.rhs, out val))
{
return(true);
}
var nameSet =
EnumManager.Instance.GetEnums("value",
true); //Core.Instance.GetNameSetFromEnumType(type, true);
var v = data.rhs;
if (v != null && v.Contains("."))
{
v = v.Substring(v.LastIndexOf(".") + 1);
}
if (nameSet.Contains(v))
{
data.ReferencedObject = Core.Instance.Get(v, type);
data.ReferenceValid = true;
return(true);
}
var triggerSchema = SchemaManager.Instance.GetSchema("trigger");
var results = triggerSchema.Children.Where(a =>
a.name == v && (a.scopes.Contains(data.deepestRHSScopeFound) ||
a.scopes.Contains(ScopeType.none)));
if (results.Count() > 0)
{
data.ReferenceValid = true;
return(true);
}
}
if (type == "any" || type == "string")
{
data.ReferenceValid = true;
return(true);
}
if (type == "flag")
{
if (data.rhs.StartsWith("flag:"))
{
data.ReferenceValid = true;
return(true);
}
}
else if (type == "scope")
{
List <ScriptScope> results = new List <ScriptScope>();
scriptObject.Topmost.GetValidScriptScopesInit(results, true, ScopeFindType.Any);
foreach (var topmostScriptScope in results)
{
// its a scope!
if (topmostScriptScope.Name == data.rhs)
{
data.ReferenceValid = true;
return(true);
}
}
}
else if (type == "var")
{
data.ReferenceValid = true;
return(true);
}
else if (type == "global_var")
{
data.ReferenceValid = true;
return(true);
}
else if (type == "local_var")
{
data.ReferenceValid = true;
return(true);
}
else if (type == "bool")
{
if (data.rhs == "yes" || data.rhs == "no")
{
data.ReferenceValid = true;
return(true);
}
}
else if (type == "localized")
{
if (Core.Instance.HasLocalizedText(data.rhs.Replace("\"", "")))
{
data.ReferenceValid = true;
return(true);
}
}
else if (type == "trigger_localization")
{
if (Core.Instance.GetNameSet("trigger_localization", false).Contains(data.rhs.Replace("\"", "")))
{
data.ReferenceValid = true;
return(true);
}
}
else if (type == scriptObject.GetScopeType().ToString())
{
if (!data.foundRHSScope)
{
continue;
}
data.ReferenceValid = true;
return(true);
}
{
var nameSet =
EnumManager.Instance.GetEnums(type, true); //Core.Instance.GetNameSetFromEnumType(type, true);
if (nameSet.Contains(data.rhs))
{
data.ReferencedObject = Core.Instance.Get(data.rhs, type);
data.ReferenceValid = true;
return(true);
}
}
}
return(false);
}
public void ProcessObject(BinaryWriter writer, BinaryReader reader, ScriptObject obj)
{
if (obj.Name == "root")
{
obj.SetScopeType(obj.Topmost.GetScopeType());
}
BreakpointLine = 30;
BreakpointFile = "events/kill_them_all_events/kill_them_all_events.txt";
if (obj.Filename.ToRelativeFilename().Contains(BreakpointFile))
{
}
if (obj.LineStart == BreakpointLine &&
obj.Filename.ToRelativeFilename().Contains(BreakpointFile))
{
}
var data = new ScriptObjectBehaviourData();
data.ScriptObject = obj;
data.ScopeType = obj.GetScopeType();
if (obj.Parent != null)
{
data.ParentData = obj.Parent.BehaviourData;
}
obj.BehaviourData = data;
data.lhs = obj.Name;
if (obj.Parent != null)
{
data.ParentData = obj.Parent.BehaviourData;
}
if (data.lhs == "set_variable")
{
VariableStore.Instance.CompleteScopedVar(obj, data, obj.Parent.GetScopeType());
}
data.rhs = obj.GetStringValue();
data.IsBlock = obj.IsBlock;
if (reader == null)
{
DetermineBehaviourScope(obj, data);
}
else
{
ReadBehaviour(reader, obj);
}
if (data.lhs.Contains("var:"))
{
if (!VariableStore.Instance.HasScopedVariableComplete(data.lhs, obj.GetScopeType()) && obj.DeferedCount < 1)
{
obj.DeferedCount++;
Core.Instance.BehaviourRecalculateList.Add(obj);
}
}
if (data.rhs != null && data.rhs.Contains("var:"))
{
if (!VariableStore.Instance.HasScopedVariableComplete(data.rhs.Substring(data.rhs.IndexOf("var:")),
data.deepestRHSScopeFound) && obj.DeferedCount < 1)
{
obj.DeferedCount++;
Core.Instance.BehaviourRecalculateList.Add(obj);
}
}
if (writer != null)
{
WriteBehaviour(writer, obj);
}
foreach (var scriptObject in obj.Children)
{
scriptObject.PostInitialize(writer, reader);
}
}
private ScopeType GetScopeChangeFromData(ScriptObject obj, SchemaNode node, string name, string data,
bool rhs, ScopeType scope, out bool success)
{
success = false;
if (name == "scope")
{
var results = new List <ScriptScope>();
obj.Topmost.GetValidScriptScopesInit(results, true, ScopeFindType.Any);
foreach (var objScriptScope in results)
{
if (objScriptScope.Name == data)
{
success = true;
return(objScriptScope.To);
}
}
}
if (name == "var")
{
if (VariableStore.Instance.unsortedScopedVariables.ContainsKey(data))
{
var results = VariableStore.Instance.unsortedScopedVariables[data]
.Where(a => a.InsideScope == scope);
if (results.Any())
{
success = true;
return(results.First().VarType);
}
}
}
if (name == "cp")
{
if (EnumManager.Instance.GetEnums("council_position", true).Contains(data))
{
success = true;
return(ScopeType.character);
}
}
if (name == "culture_group")
{
if (EnumManager.Instance.GetEnums("culture_group", true).Contains(data))
{
success = true;
return(ScopeType.culture_group);
}
}
if (name == "culture")
{
if (EnumManager.Instance.GetEnums("culture", true).Contains(data))
{
success = true;
return(ScopeType.culture);
}
}
if (name == "global_var")
{
if (VariableStore.Instance.globalVariables.ContainsKey(data))
{
var results = VariableStore.Instance.globalVariables[data];
{
success = true;
return(results.VarType);
}
}
}
if (name == "local_var")
{
var results = new List <Variable>();
obj.Topmost.GetValidLocalVariablesInit(results);
foreach (var objScriptScope in results)
{
if (objScriptScope.Name == data)
{
success = true;
return(objScriptScope.VarType);
}
}
}
return(obj.GetScopeType());
}
public List <string> GetValidTokens(ScriptObject inside, string match)
{
if (inside == null || inside.BehaviourData == null)
{
return(new List <string>());
}
var results = new List <string>();
var results2 = new List <string>();
if (inside == null)
{
return(results);
}
if (!string.IsNullOrEmpty(match))
{
inside = inside.Parent;
}
if (inside == null)
{
return(results);
}
var scope = inside.GetScopeType();
if (inside.lhsSchema != null)
{
var ch = inside.lhsSchema.Children.Where(a =>
!a.rightHandOnly && (a.scopes.Contains(scope) || a.scopes.Contains(ScopeType.none) ||
a.scopes.Contains(ScopeType.inheritparent)));
foreach (var schemaNode in ch)
{
if (schemaNode.namesFrom != null)
{
}
else
{
results.Add(schemaNode.name);
}
}
if (inside.lhsSchema.IsEffect())
{
var sl = SchemaManager.Instance.GetSchema("scriptlist");
var options = sl.Children.Where(a => a.scopes.Contains(scope) && (a.name.StartsWith("every_") ||
a.name.StartsWith("random_") || a.name.StartsWith("ordered_"))).ToList();
foreach (var schemaNode in options)
{
results.Add(schemaNode.name);
}
}
if (inside.lhsSchema.IsTrigger())
{
var sl = SchemaManager.Instance.GetSchema("scriptlist");
var options = sl.Children.Where(a => a.scopes.Contains(scope) && a.name.StartsWith("any_"))
.ToList();
foreach (var schemaNode in options)
{
results.Add(schemaNode.name);
}
}
}
if (match != null)
{
results.RemoveAll(a => !a.ToLower().Contains(match.ToLower()));
}
results = results.OrderBy(a => a).Distinct().ToList();
if (inside.lhsSchema != null)
{
var ch = inside.lhsSchema.Children.Where(a =>
!a.rightHandOnly && (a.scopes.Contains(scope) || a.scopes.Contains(ScopeType.none) ||
a.scopes.Contains(ScopeType.inheritparent)));
foreach (var schemaNode in ch)
{
if (schemaNode.namesFrom != null)
{
results2.AddRange(EnumManager.Instance.GetEnums(schemaNode.namesFrom));
}
}
}
if (match != null)
{
results2.RemoveAll(a => !a.ToLower().Contains(match.ToLower()));
}
results2 = results2.OrderBy(a => a).Distinct().ToList();
results.AddRange(results2);
if (match != null)
{
results = results.OrderBy(a => !a.ToLower().StartsWith(match.ToLower())).ToList();
}
return(results);
}
public List <string> GetValidTokensEqual(ScriptObject inside, string child, string sofar)
{
var results = new List <string>();
if (inside == null)
{
return(results);
}
if (inside.BehaviourData == null)
{
return(new List <string>());
}
var expectedType = new List <string>();
var scope = inside.GetScopeType();
if (inside.lhsSchema != null)
{
expectedType.AddRange(inside.lhsSchema.TypeList);
var ch = inside.lhsSchema.Children.Where(a =>
a.rightHandOnly && (a.scopes.Contains(scope) || a.scopes.Contains(ScopeType.none) ||
a.scopes.Contains(ScopeType.inheritparent)));
//var l = ch.Where(a => a.TypeList.Any(b => inside.lhsSchema.TypeList.Contains(b))).ToList();
foreach (var schemaNode in ch)
{
results.Add(schemaNode.name);
}
foreach (var s in inside.lhsSchema.TypeList)
{
var enums = EnumManager.Instance.GetEnums(s);
results.AddRange(enums);
}
}
results = results.OrderBy(a => a).Distinct().ToList();
if (sofar != null)
{
results.RemoveAll(a => !a.ToLower().Contains(sofar.ToLower()));
}
if (sofar != null)
{
results = results.OrderBy(a => !a.ToLower().StartsWith(sofar.ToLower())).ToList();
}
if (string.IsNullOrWhiteSpace(sofar))
{
if (expectedType.Contains("value"))
{
results.Insert(0, "{ }");
}
else if (inside.BehaviourData.candidates != null)
{
foreach (var behaviourDataCandidate in inside.BehaviourData.candidates)
{
if (behaviourDataCandidate.Children.Count > 0)
{
results.Insert(0, "{ }");
break;
}
}
}
}
if (results.Count == 1 && results[0] == sofar)
{
results.Clear();
}
if (sofar != null && sofar.Trim().Length > 0)
{
int test;
if (int.TryParse(sofar, out test))
{
results.Clear();
}
}
return(results);
/*
* if (inside.BehaviourData == null)
* return new List<string>();
*
* if (inside == null)
* {
*
* return results;
* }
*
* var expected = inside.BehaviourData.TypeExpected;
*
*
* if (expected != null)
* {
* results.AddRange(EnumManager.Instance.GetEnums(expected, false));
* //results.AddRange();
* List<ScriptObject.ScriptScope> scoperesults = new List<ScriptObject.ScriptScope>();
*
* var ConnectionsIn = ReferenceManager.Instance.GetConnectionsTo(inside.Topmost.Name);
* HashSet<ScriptObject.ScriptScope> Scopes = new HashSet<ScriptObject.ScriptScope>();
* visited.Clear();
* foreach (var eventConnection in ConnectionsIn)
* {
* GetScriptScopesFromReferences(eventConnection.From, Scopes);
* }
* inside.Topmost.GetValidScriptScopes(scoperesults, true, ScriptObject.ScopeFindType.Any);
* scoperesults.AddRange(Scopes);
* var scopesval = scoperesults.Where(a => a.IsValue && a.VarType.ToString().ToLower() == expected).ToList();
* var scopes = scoperesults.Where(a => !a.IsValue && a.To.ToString().ToLower() == expected).ToList();
* scopes = scopes.Union(scopesval).ToList();
* foreach (var scriptScope in scopes)
* {
* if (scriptScope.RequiresScopeTag)
* results.Add("scope:"+scriptScope.Name);
* else
* results.Add(scriptScope.Name);
* }
* }
* List<string> addToTop = new List<string>();
*
* if (expected != null)
* {
* var l = Core.Instance.BaseCK3Library.ContextData.Where(a => a.Value.Type == expected).ToList();
*
* if (l.Any())
* {
* foreach (var keyValuePair in l)
* {
* if (keyValuePair.Value.Prepend != null)
* {
* if (string.IsNullOrEmpty(sofar) || ((keyValuePair.Value.Prepend + ":").Contains(sofar) && (keyValuePair.Value.Prepend + ":") != sofar))
* {
* addToTop.Add(keyValuePair.Value.Prepend + ":");
* }
* else if (sofar.StartsWith(keyValuePair.Value.Prepend + ":"))
* {
* var list = Core.Instance.GetNameSet(keyValuePair.Key, false).Select(a=>string.Concat(keyValuePair.Value.Prepend, ":", a)).ToList();
* results.AddRange(list);
* }
* }
* }
* }
* }
*
* results = results.OrderBy(a => a).Distinct().ToList();
* if(sofar != null)
* results.RemoveAll(a => !a.ToLower().Contains(sofar.ToLower()));
*
*
* foreach (var v in addToTop)
* {
* results.Insert(0, v);
*
* }
*
* if (sofar != null)
* results = results.OrderBy(a => !a.ToLower().StartsWith(sofar.ToLower())).ToList();
*
* if (results.Count==1 && results[0] == sofar)
* results.Clear();
*
* if (child == "limit" && string.IsNullOrEmpty(sofar) ||
* (string.IsNullOrEmpty(sofar) && expected == null &&
* inside.BehaviourData.ExpectedEffectFunction != null) ||
* (string.IsNullOrEmpty(sofar) && expected == null &&
* inside.BehaviourData.ExpectedTriggerFunction != null) ||
* (inside.BehaviourData.CanBeScope && string.IsNullOrEmpty(sofar))
* )
* {
* results.Insert(0, "{ }");
* }
*
* if (sofar != null && sofar.Trim().Length > 0)
* {
* int test;
* if (Int32.TryParse(sofar, out test))
* {
* results.Clear();
* }
* }*/
}
public ScriptObject CreateScriptObject(ScriptContext context, ScriptParsedSegment segment, ScriptObject parent,
string scriptNamespace)
{
if (context == ScriptContext.CharacterInteractions)
{
}
ScriptObject obj = null;
if (parent == null)
{
if (Core.Instance.LoadingCK3Library == Core.Instance.ModCK3Library)
{
if (segment.name == "abduct_outcome_roll_effect")
{
}
ReferenceManager.Instance.ClearConnectionsFrom(segment.name);
}
}
if (parent == null && segment.name.StartsWith("@"))
{
obj = ScriptValueParser.Instance.ParseScriptValue(parent, segment);
InitializeObject(obj, context);
obj.Namespace = scriptNamespace;
if (string.IsNullOrEmpty(scriptNamespace))
{
obj.Namespace = null;
}
return(obj);
}
switch (context)
{
case ScriptContext.None:
obj = new ScriptObject(parent, segment);
break;
case ScriptContext.ScriptObjectValue:
obj = ScriptValueParser.Instance.ParseScriptValue(parent, segment);
break;
case ScriptContext.Event:
if (segment.name.StartsWith("scripted_trigger "))
{
obj = new ScriptObject(parent, segment, SchemaManager.Instance.GetSchema("trigger"));
}
else
{
obj = new ScriptObject(parent, segment, SchemaManager.Instance.GetSchema("event"));
}
break;
default:
obj = new ScriptObject(parent, segment,
SchemaManager.Instance.GetSchema(Core.Instance.BaseCK3Library.ContextData[context].Type));
break;
}
obj.Context = context;
InitializeObject(obj, context);
AddScriptScope("root", obj, obj.GetScopeType(), true, false);
AddScriptScope("this", obj, obj.GetScopeType(), true, false);
obj.Namespace = scriptNamespace;
if (string.IsNullOrEmpty(scriptNamespace))
{
obj.Namespace = null;
}
return(obj);
}
