void UpdatePosition()
{
if (!ObjectFunctions.CheckObjectOutOfBounds(positionX, positionY))
{
GameObject targetTerrain = MapManager._Instance.RequestMapTile(positionX, positionY);
TerrainCubeData tempData = targetTerrain.GetComponent <TerrainCubeData> ();
GetComponentInParent <TerrainCubeData> ().occupant = null; // sets tile "object-free"! - PREEMPTIVE ACTION TO AVOID MAP BUGGING
if (CheckOccupiedTerrain(positionX, positionY))
{
transform.parent = null;
transform.position = Vector3.zero;
transform.SetParent(targetTerrain.transform, false);
transform.localPosition = new Vector3(0f, MapManager._Instance.objectOffset, 0f);
tempData.occupant = gameObject;
}
}
else
{
// GetComponent<EnemyData> ().DestroyEnemy ();
ObjectFunctions.DestroyObject(gameObject);
}
}
/// <summary>
/// Visits the given input data node.
/// </summary>
/// <param name="data">Input data node.</param>
public override void Visit(InputData.PDDL.EqualsObjectFunctionInitElement data)
{
int functionNameId = IdManager.Functions.GetId(data.Function.Name, data.Function.Terms.Count);
List <ITerm> terms = GetTerms(data.Function.Terms);
int valueTermId = IdManager.Constants.GetId(data.Term.Name);
ObjectFunctions.Add(new Atom(functionNameId, terms), valueTermId);
}
/// <summary>
/// Returns the value of the given object function.
/// </summary>
/// <param name="function">Grounded function atom.</param>
/// <returns>Object value, i.e. constant name ID.</returns>
public int GetObjectFunctionValue(IAtom function)
{
if (ObjectFunctions == null || !ObjectFunctions.ContainsKey(function))
{
return(ObjectFunctionTerm.UndefinedValue);
}
return(ObjectFunctions[function]);
}
/// <summary>
/// Defines a new value for the requested function in the state.
/// </summary>
/// <param name="function">Requested function.</param>
/// <param name="assignment">Value to be assigned.</param>
public void AssignObjectFunction(IAtom function, int assignment)
{
if (assignment == ObjectFunctionTerm.UndefinedValue)
{
if (ObjectFunctions != null && ObjectFunctions.ContainsKey(function))
{
ObjectFunctions.Remove(function);
}
}
else
{
CheckObjectFunctionsInitialized();
ObjectFunctions[function] = assignment;
}
}
public static object Evaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, object leftValue, object rightValue)
{
if (op == ScriptBinaryOperator.EmptyCoalescing)
{
return(leftValue ?? rightValue);
}
switch (op)
{
case ScriptBinaryOperator.ShiftLeft:
var leftList = leftValue as IList;
if (leftList != null)
{
var newList = new ScriptArray(leftList)
{
rightValue
};
return(newList);
}
break;
case ScriptBinaryOperator.ShiftRight:
var rightList = rightValue as IList;
if (rightList != null)
{
var newList = new ScriptArray(rightList);
newList.Insert(0, leftValue);
return(newList);
}
break;
case ScriptBinaryOperator.LiquidHasKey:
{
var leftDict = leftValue as IDictionary <string, object>;
if (leftDict != null)
{
return(ObjectFunctions.HasKey(leftDict, context.ToString(span, rightValue)));
}
}
break;
case ScriptBinaryOperator.LiquidHasValue:
{
var leftDict = leftValue as IDictionary <string, object>;
if (leftDict != null)
{
return(ObjectFunctions.HasValue(leftDict, context.ToString(span, rightValue)));
}
}
break;
case ScriptBinaryOperator.CompareEqual:
case ScriptBinaryOperator.CompareNotEqual:
case ScriptBinaryOperator.CompareGreater:
case ScriptBinaryOperator.CompareLess:
case ScriptBinaryOperator.CompareGreaterOrEqual:
case ScriptBinaryOperator.CompareLessOrEqual:
case ScriptBinaryOperator.Add:
case ScriptBinaryOperator.Substract:
case ScriptBinaryOperator.Multiply:
case ScriptBinaryOperator.Divide:
case ScriptBinaryOperator.DivideRound:
case ScriptBinaryOperator.Modulus:
case ScriptBinaryOperator.RangeInclude:
case ScriptBinaryOperator.RangeExclude:
case ScriptBinaryOperator.LiquidContains:
case ScriptBinaryOperator.LiquidStartsWith:
case ScriptBinaryOperator.LiquidEndsWith:
if (leftValue is string || rightValue is string)
{
return(CalculateToString(context, span, op, leftValue, rightValue));
}
else if (leftValue == EmptyScriptObject.Default || rightValue == EmptyScriptObject.Default)
{
return(CalculateEmpty(context, span, op, leftValue, rightValue));
}
else
{
return(CalculateOthers(context, span, op, leftValue, rightValue));
}
}
throw new ScriptRuntimeException(span, $"Operator `{op.ToText()}` is not implemented for `{leftValue}` and `{rightValue}`");
}
