private static int GetNext(DreamObject regexInstance, DreamValue startParam, bool isGlobal)
{
if (startParam == DreamValue.Null)
{
if (isGlobal)
{
DreamValue nextVar = regexInstance.GetVariable("next");
return((nextVar != DreamValue.Null) ? nextVar.GetValueAsInteger() : 1);
}
else
{
return(1);
}
}
else
{
return(startParam.GetValueAsInteger());
}
}
public DreamValue OperatorRemove(DreamValue a, DreamValue b)
{
DreamList list = a.GetValueAsDreamList();
if (b.TryGetValueAsDreamList(out DreamList bList))
{
DreamValue[] values = bList.GetValues().ToArray();
foreach (DreamValue value in values)
{
list.RemoveValue(value);
}
}
else
{
list.RemoveValue(b);
}
return(a);
}
private void UpdateScreenLocation(DreamObject movable, DreamValue screenLocationValue)
{
if (!_entityManager.TryGetComponent <DMISpriteComponent>(_atomManager.GetAtomEntity(movable), out var sprite))
{
return;
}
ScreenLocation screenLocation;
if (screenLocationValue.TryGetValueAsString(out string screenLocationString))
{
screenLocation = new ScreenLocation(screenLocationString);
}
else
{
screenLocation = new ScreenLocation(0, 0, 0, 0);
}
sprite.ScreenLocation = screenLocation;
}
public DreamValue OperatorCombine(DreamValue a, DreamValue b)
{
DreamList list = a.GetValueAsDreamList();
if (b.TryGetValueAsDreamList(out DreamList bList))
{
foreach (DreamValue value in bList.GetValues())
{
if (!list.ContainsValue(value))
{
list.AddValue(value);
}
}
}
else if (!list.ContainsValue(b))
{
list.AddValue(b);
}
return(a);
}
public void OnVariableSet(DreamObject dreamObject, string varName, DreamValue value, DreamValue oldValue)
{
ParentType?.OnVariableSet(dreamObject, varName, value, oldValue);
if (varName == "loc")
{
if (value.TryGetValueAsDreamObjectOfType(DreamPath.Turf, out DreamObject replacedTurf))
{
//Transfer all the old turf's contents
DreamList contents = replacedTurf.GetVariable("contents").GetValueAsDreamList();
foreach (DreamValue child in contents.GetValues())
{
child.GetValueAsDreamObjectOfType(DreamPath.Movable).SetVariable("loc", new DreamValue(dreamObject));
}
int x = replacedTurf.GetVariable("x").GetValueAsInteger();
int y = replacedTurf.GetVariable("y").GetValueAsInteger();
int z = replacedTurf.GetVariable("z").GetValueAsInteger();
_dreamMapManager.SetTurf(x, y, z, dreamObject);
}
}
}
public DreamValue OnVariableGet(DreamObject dreamObject, string varName, DreamValue value)
{
if (varName == "key" || varName == "ckey")
{
if (dreamObject.GetVariable("client").TryGetValueAsDreamObjectOfType(DreamPath.Client, out var client))
{
return(client.GetVariable(varName));
}
else
{
return(DreamValue.Null);
}
}
else if (varName == "client")
{
return(new(_dreamManager.GetClientFromMob(dreamObject)));
}
else
{
return(ParentType?.OnVariableGet(dreamObject, varName, value) ?? value);
}
}
public void AssignReference(DMReference reference, DreamValue value)
{
switch (reference.RefType)
{
case DMReference.Type.Self: Result = value; break;
case DMReference.Type.Local: LocalVariables[reference.LocalId] = value; break;
case DMReference.Type.SrcField: Instance.SetVariable(reference.FieldName, value); break;
case DMReference.Type.Global: DreamManager.Globals[reference.GlobalId] = value; break;
case DMReference.Type.Field: {
DreamValue owner = Pop();
if (!owner.TryGetValueAsDreamObject(out var ownerObj) || ownerObj == null)
{
throw new Exception($"Cannot assign field \"{reference.FieldName}\" on {owner}");
}
ownerObj.SetVariable(reference.FieldName, value);
break;
}
case DMReference.Type.ListIndex: {
DreamValue index = Pop();
DreamValue list = Pop();
if (!list.TryGetValueAsDreamList(out var listObj))
{
throw new Exception($"Cannot assign to index {index} of {list}");
}
listObj.SetValue(index, value);
break;
}
default: throw new Exception($"Cannot assign to reference type {reference.RefType}");
}
}
public static DreamValue NativeProc_Replace(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
DreamRegex dreamRegex = DreamMetaObjectRegex.ObjectToDreamRegex[instance];
if (!dreamRegex.IsGlobal)
{
throw new NotImplementedException("Non-global regex replaces are not implemented");
}
DreamValue haystack = arguments.GetArgument(0, "haystack");
DreamValue replace = arguments.GetArgument(1, "replacement");
int start = arguments.GetArgument(2, "Start").GetValueAsInteger();
int end = arguments.GetArgument(3, "End").GetValueAsInteger();
string haystackString = haystack.GetValueAsString();
if (end == 0)
{
end = haystackString.Length;
}
if (replace.TryGetValueAsProc(out DreamProc replaceProc))
{
throw new NotImplementedException("Proc replacements are not implemented");
}
else if (replace.TryGetValueAsString(out string replaceString))
{
string replaced = dreamRegex.Regex.Replace(haystackString, replaceString, end - start, start - 1);
instance.SetVariable("text", new DreamValue(replaced));
return(new DreamValue(replaced));
}
else
{
throw new ArgumentException("Replacement argument must be a string");
}
}
public DreamProcIdentifierProc(DreamProc proc, DreamObject instance, string procName)
{
_proc = new DreamValue(proc);
Instance = instance;
ProcName = procName;
}
public void Assign(DreamValue value)
{
_localVariables[ID] = value;
}
public void Assign(DreamValue value)
{
Interpreter.DefaultReturnValue = value;
}
public void Assign(DreamValue value)
{
List.SetValue(ListIndex, value);
}
public override void OnVariableSet(DreamObject dreamObject, string variableName, DreamValue variableValue, DreamValue oldVariableValue)
{
base.OnVariableSet(dreamObject, variableName, variableValue, oldVariableValue);
if (variableName == "x" || variableName == "y" || variableName == "z")
{
int x = (variableName == "x") ? variableValue.GetValueAsInteger() : dreamObject.GetVariable("x").GetValueAsInteger();
int y = (variableName == "y") ? variableValue.GetValueAsInteger() : dreamObject.GetVariable("y").GetValueAsInteger();
int z = (variableName == "z") ? variableValue.GetValueAsInteger() : dreamObject.GetVariable("z").GetValueAsInteger();
DreamObject newLocation = Program.DreamMap.GetTurfAt(x, y, z);
dreamObject.SetVariable("loc", new DreamValue(newLocation));
}
else if (variableName == "loc")
{
Program.DreamStateManager.AddAtomLocationDelta(dreamObject, variableValue.GetValueAsDreamObject());
if (oldVariableValue.Value != null)
{
DreamObject oldLoc = oldVariableValue.GetValueAsDreamObjectOfType(DreamPath.Atom);
DreamList oldLocContents = oldLoc.GetVariable("contents").GetValueAsDreamList();
oldLocContents.RemoveValue(new DreamValue(dreamObject));
}
if (variableValue.Value != null)
{
DreamObject newLoc = variableValue.GetValueAsDreamObjectOfType(DreamPath.Atom);
DreamList newLocContents = newLoc.GetVariable("contents").GetValueAsDreamList();
newLocContents.AddValue(new DreamValue(dreamObject));
}
}
else if (variableName == "screen_loc")
{
UpdateScreenLocation(dreamObject, variableValue);
}
}
public override void OnVariableSet(DreamObject dreamObject, string variableName, DreamValue variableValue, DreamValue oldVariableValue)
{
base.OnVariableSet(dreamObject, variableName, variableValue, oldVariableValue);
if (variableName == "fps")
{
dreamObject.SetVariable("tick_lag", new DreamValue(10.0f / variableValue.GetValueAsInteger()));
}
else if (variableName == "maxz")
{
int newMaxZ = variableValue.GetValueAsInteger();
if (newMaxZ < oldVariableValue.GetValueAsInteger())
{
throw new NotImplementedException("Cannot set maxz lower than previous value");
}
while (Program.DreamMap.Levels.Count < newMaxZ)
{
Program.DreamMap.AddLevel();
}
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "loc")
{
int x = dreamObject.GetVariable("x").GetValueAsInteger();
int y = dreamObject.GetVariable("y").GetValueAsInteger();
int z = dreamObject.GetVariable("z").GetValueAsInteger();
return(new DreamValue(Program.DreamMap.GetAreaAt(x, y, z)));
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public void Assign(DreamValue value)
{
throw new Exception("Cannot assign to a proc");
}
public virtual DreamValue OperatorAppend(DreamValue a, DreamValue b)
{
throw new InvalidOperationException("Cannot append " + b + " to " + a);
}
public virtual DreamValue OperatorMask(DreamValue a, DreamValue b)
{
throw new InvalidOperationException("Cannot mask " + a + " and " + b);
}
public virtual DreamValue OperatorCombine(DreamValue a, DreamValue b)
{
throw new InvalidOperationException("Cannot combine " + a + " and " + b);
}
public virtual DreamValue OperatorRemove(DreamValue a, DreamValue b)
{
throw new InvalidOperationException("Cannot remove " + b + " from " + a);
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "contents")
{
return(new DreamValue(_dreamManager.AreaContents[dreamObject]));
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public DreamValue OperatorIndex(DreamObject dreamObject, DreamValue index)
{
return(((DreamList)dreamObject).GetValue(index));
}
public static DreamValue NativeProc_Replace(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
DreamRegex dreamRegex = DreamMetaObjectRegex.ObjectToDreamRegex[instance];
DreamValue haystack = arguments.GetArgument(0, "haystack");
DreamValue replace = arguments.GetArgument(1, "replacement");
int start = arguments.GetArgument(2, "Start").GetValueAsInteger();
int end = arguments.GetArgument(3, "End").GetValueAsInteger();
if (!haystack.TryGetValueAsString(out var haystackString))
{
if (haystack == DreamValue.Null)
{
return(DreamValue.Null);
}
//TODO Check what actually happens
throw new ArgumentException("Bad regex haystack");
}
string haystackSubstring = haystackString;
if (end != 0)
{
haystackSubstring = haystackString.Substring(0, end - start);
}
if (replace.TryGetValueAsProc(out DreamProc replaceProc))
{
return(DoProcReplace(replaceProc));
}
if (replace.TryGetValueAsString(out string replaceString))
{
return(DoTextReplace(replaceString));
}
if (replace.TryGetValueAsPath(out var procPath) && procPath.LastElement is not null)
{
var dreamMan = IoCManager.Resolve <IDreamManager>();
if (dreamMan.ObjectTree.TryGetGlobalProc(procPath.LastElement, out DreamProc? proc))
{
return(DoProcReplace(proc));
}
}
throw new ArgumentException("Replacement argument must be a string or a proc");
DreamValue DoProcReplace(DreamProc proc)
{
if (dreamRegex.IsGlobal)
{
throw new NotImplementedException("Proc global regex replacements are not implemented");
}
var match = dreamRegex.Regex.Match(haystackSubstring);
var groups = match.Groups;
List <DreamValue> args = new List <DreamValue>(groups.Count);
foreach (Group group in groups)
{
args.Add(new DreamValue(group.Value));
}
var result = DreamThread.Run(async(state) => await state.Call(proc, instance, null, new DreamProcArguments(args)));
if (result.TryGetValueAsString(out var replacement))
{
return(DoTextReplace(replacement));
}
//TODO Confirm this behavior
if (result == DreamValue.Null)
{
return(new DreamValue(haystackSubstring));
}
throw new ArgumentException("Replacement is not a string");
}
DreamValue DoTextReplace(string replacement)
{
string replaced = dreamRegex.Regex.Replace(haystackSubstring, replacement, dreamRegex.IsGlobal ? -1 : 1, start - 1);
if (end != 0)
{
replaced += haystackString.Substring(end - start + 1);
}
instance.SetVariable("text", new DreamValue(replaced));
return(new DreamValue(replaced));
}
}
public void OperatorIndexAssign(DreamObject dreamObject, DreamValue index, DreamValue value)
{
((DreamList)dreamObject).SetValue(index, value);
}
public override void OnVariableSet(DreamObject dreamObject, string variableName, DreamValue variableValue, DreamValue oldVariableValue)
{
base.OnVariableSet(dreamObject, variableName, variableValue, oldVariableValue);
if (variableName == "loc")
{
if (variableValue.TryGetValueAsDreamObjectOfType(DreamPath.Turf, out DreamObject replacedTurf))
{
DreamList contents = replacedTurf.GetVariable("contents").GetValueAsDreamList();
while (contents.GetLength() > 0) //Transfer all the old turf's contents
{
contents.GetValues()[0].GetValueAsDreamObjectOfType(DreamPath.Atom).SetVariable("loc", new DreamValue(dreamObject));
}
int x = replacedTurf.GetVariable("x").GetValueAsInteger();
int y = replacedTurf.GetVariable("y").GetValueAsInteger();
int z = replacedTurf.GetVariable("z").GetValueAsInteger();
Program.DreamMap.SetTurf(x, y, z, dreamObject);
}
}
}
public void OnVariableSet(DreamObject dreamObject, string varName, DreamValue value, DreamValue oldValue)
{
ParentType?.OnVariableSet(dreamObject, varName, value, oldValue);
if (varName == "len")
{
DreamList list = (DreamList)dreamObject;
value.TryGetValueAsInteger(out var newLen);
list.Resize(newLen);
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "fps")
{
return(new DreamValue((float)10.0 / dreamObject.GetVariable("tick_lag").GetValueAsNumber()));
}
else if (variableName == "timeofday")
{
return(new DreamValue((int)DateTime.UtcNow.TimeOfDay.TotalMilliseconds / 100));
}
else if (variableName == "time")
{
return(new DreamValue(dreamObject.GetVariable("tick_lag").GetValueAsNumber() * Program.TickCount));
}
else if (variableName == "realtime")
{
return(new DreamValue((DateTime.Now - new DateTime(2000, 1, 1)).Milliseconds / 100));
}
else if (variableName == "tick_usage")
{
long currentTime = new DateTimeOffset(DateTime.Now).ToUnixTimeMilliseconds();
long elapsedTime = (currentTime - Program.TickStartTime);
double tickLength = (dreamObject.GetVariable("tick_lag").GetValueAsNumber() * 100);
int tickUsage = (int)(elapsedTime / tickLength * 100);
return(new DreamValue(tickUsage));
}
else if (variableName == "maxx")
{
return(new DreamValue(Program.DreamMap.Width));
}
else if (variableName == "maxy")
{
return(new DreamValue(Program.DreamMap.Height));
}
else if (variableName == "maxz")
{
return(new DreamValue(Program.DreamMap.Levels.Count));
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "type")
{
return(new DreamValue(dreamObject.ObjectDefinition.Type));
}
else if (variableName == "parent_type")
{
return(new DreamValue(Program.DreamObjectTree.GetTreeEntryFromPath(dreamObject.ObjectDefinition.Type).ParentEntry.ObjectDefinition.Type));
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "x" || variableName == "y" || variableName == "z")
{
DreamObject location = dreamObject.GetVariable("loc").GetValueAsDreamObject();
if (location != null)
{
return(location.GetVariable(variableName));
}
else
{
return(new DreamValue(0));
}
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public override void ReturnedInto(DreamValue value)
{
// We don't call `_callTcs.SetResult` here because we're about to be resumed and can do it there.
_callResult = value;
}
