public static DreamValue NativeProc_Insert(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
int index = arguments.GetArgument(0, "Index").GetValueAsInteger(); //1-indexed
DreamList list = (DreamList)instance;
if (arguments.OrderedArguments.Count < 2)
{
throw new Exception("No value given to insert");
}
for (int i = 1; i < arguments.OrderedArguments.Count; i++)
{
DreamValue item = arguments.OrderedArguments[i];
if (item.TryGetValueAsDreamList(out DreamList valueList))
{
foreach (DreamValue value in valueList.GetValues())
{
list.Insert(index++, value);
}
}
else
{
list.Insert(index++, item);
}
}
return(new DreamValue(index));
}
public DMProcState(DMProc proc, DreamThread thread, int maxStackSize, DreamObject instance, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
_proc = proc;
_stack = _stackPool.Rent(maxStackSize);
Instance = instance;
Usr = usr;
ArgumentCount = Math.Max(arguments.ArgumentCount, proc.ArgumentNames?.Count ?? 0);
_localVariables = _dreamValuePool.Rent(256);
//TODO: Positional arguments must precede all named arguments, this needs to be enforced somehow
//Positional arguments
for (int i = 0; i < ArgumentCount; i++)
{
_localVariables[i] = (i < arguments.OrderedArguments.Count) ? arguments.OrderedArguments[i] : DreamValue.Null;
}
//Named arguments
foreach ((string argumentName, DreamValue argumentValue) in arguments.NamedArguments)
{
int argumentIndex = proc.ArgumentNames?.IndexOf(argumentName) ?? -1;
if (argumentIndex == -1)
{
throw new Exception($"Invalid argument name \"{argumentName}\"");
}
_localVariables[argumentIndex] = argumentValue;
}
}
public override void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
base.OnObjectCreated(dreamObject, creationArguments);
_dreamManager.WorldContentsList = dreamObject.GetVariable("contents").GetValueAsDreamList();
DreamValue log = dreamObject.ObjectDefinition.Variables["log"];
dreamObject.SetVariable("log", log);
DreamValue fps = dreamObject.ObjectDefinition.Variables["fps"];
if (fps.Value != null)
{
_cfg.SetCVar(CVars.NetTickrate, fps.GetValueAsInteger());
}
DreamValue view = dreamObject.ObjectDefinition.Variables["view"];
if (view.TryGetValueAsString(out string viewString))
{
_viewRange = new ViewRange(viewString);
}
else
{
_viewRange = new ViewRange(view.GetValueAsInteger());
}
}
private DreamProcArguments ConstructClickArguments(DreamObject atom, EntityClickedEvent e)
{
NameValueCollection paramsBuilder = HttpUtility.ParseQueryString(String.Empty);
if (e.Shift)
{
paramsBuilder.Add("shift", "1");
}
if (e.Ctrl)
{
paramsBuilder.Add("ctrl", "1");
}
if (e.Alt)
{
paramsBuilder.Add("alt", "1");
}
//TODO: "icon-x", "icon-y", "screen-loc"
return(new DreamProcArguments(new() {
new DreamValue(atom),
DreamValue.Null,
DreamValue.Null,
new DreamValue(paramsBuilder.ToString())
}));
}
public void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
ParentType?.OnObjectCreated(dreamObject, creationArguments);
_dreamManager.WorldContentsList = dreamObject.GetVariable("contents").GetValueAsDreamList();
DreamValue log = dreamObject.ObjectDefinition.Variables["log"];
dreamObject.SetVariable("log", log);
DreamValue fps = dreamObject.ObjectDefinition.Variables["fps"];
if (fps.TryGetValueAsInteger(out var fpsValue))
{
_cfg.SetCVar(CVars.NetTickrate, fpsValue);
}
DreamValue view = dreamObject.ObjectDefinition.Variables["view"];
if (view.TryGetValueAsString(out string viewString))
{
_viewRange = new ViewRange(viewString);
}
else
{
if (!view.TryGetValueAsInteger(out var viewInt))
{
Logger.Warning("world.view did not contain a valid value. A default of 5 is being used.");
viewInt = 5;
}
_viewRange = new ViewRange(viewInt);
}
}
public override void OnVariableSet(DreamObject dreamObject, string variableName, DreamValue variableValue, DreamValue oldVariableValue)
{
base.OnVariableSet(dreamObject, variableName, variableValue, oldVariableValue);
if (variableName == "key" || variableName == "ckey")
{
DreamConnection newClientConnection = Program.DreamServer.GetConnectionFromCKey(variableValue.GetValueAsString());
newClientConnection.MobDreamObject = dreamObject;
}
else if (variableName == "client" && variableValue != oldVariableValue)
{
DreamObject newClient = variableValue.GetValueAsDreamObject();
DreamObject oldClient = oldVariableValue.GetValueAsDreamObject();
if (newClient != null)
{
Program.ClientToConnection[newClient].MobDreamObject = dreamObject;
}
else if (oldClient != null)
{
Program.ClientToConnection[oldClient].MobDreamObject = null;
}
}
}
public void OnVariableSet(DreamObject dreamObject, string varName, DreamValue value, DreamValue oldValue)
{
ParentType?.OnVariableSet(dreamObject, varName, value, oldValue);
switch (varName)
{
case "fps":
if (!value.TryGetValueAsInteger(out var fps))
{
fps = 10;
}
_cfg.SetCVar(CVars.NetTickrate, fps);
break;
case "maxz":
value.TryGetValueAsInteger(out var maxz);
_dreamMapManager.SetZLevels(maxz);
break;
case "log":
if (value.TryGetValueAsString(out var logStr))
{
dreamObject.SetVariableValue("log", new DreamValue(_dreamRscMan.LoadResource(logStr)));
}
else if (!value.TryGetValueAsDreamResource(out _))
{
dreamObject.SetVariableValue("log", new DreamValue(new ConsoleOutputResource()));
}
break;
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
if (variableName == "key" || variableName == "ckey")
{
DreamObject clientObject = dreamObject.GetVariable("client").GetValueAsDreamObject();
if (clientObject != null && clientObject.IsSubtypeOf(DreamPath.Client))
{
return(clientObject.GetVariable(variableName));
}
else
{
return(DreamValue.Null);
}
}
else if (variableName == "client")
{
DreamConnection connection = Program.DreamServer.GetConnectionFromMob(dreamObject);
if (connection != null && connection.ClientDreamObject != null)
{
return(new DreamValue(connection.ClientDreamObject));
}
else
{
return(DreamValue.Null);
}
}
else
{
return(base.OnVariableGet(dreamObject, variableName, variableValue));
}
}
public override void OnVariableSet(DreamObject dreamObject, string variableName, DreamValue variableValue, DreamValue oldVariableValue)
{
base.OnVariableSet(dreamObject, variableName, variableValue, oldVariableValue);
if (variableName == "key" || variableName == "ckey")
{
if (_playerManager.TryGetSessionByUsername(variableValue.GetValueAsString(), out var session))
{
var connection = _dreamManager.GetConnectionBySession(session);
connection.MobDreamObject = dreamObject;
}
}
else if (variableName == "see_invisible")
{
//TODO
}
else if (variableName == "client" && variableValue != oldVariableValue)
{
var newClient = variableValue.GetValueAsDreamObject();
var oldClient = oldVariableValue.GetValueAsDreamObject();
if (newClient != null)
{
_dreamManager.GetConnectionFromClient(newClient).MobDreamObject = dreamObject;
}
else if (oldClient != null)
{
_dreamManager.GetConnectionFromClient(oldClient).MobDreamObject = null;
}
}
}
public static DreamListVars Create(DreamObject dreamObject)
{
var list = new DreamListVars(dreamObject);
list.InitSpawn(new DreamProcArguments(null));
return(list);
}
public DMProcState(DMProc proc, DreamThread thread, int maxStackSize, DreamObject instance, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
_proc = proc;
_stack = _stackPool.Rent(maxStackSize);
Instance = instance;
Usr = usr;
Arguments = arguments;
LocalVariables = _dreamValuePool.Rent(256);
// args -> locals
for (int i = 0; i < proc.ArgumentNames.Count; i++)
{
string argumentName = proc.ArgumentNames[i];
if (Arguments.NamedArguments.TryGetValue(argumentName, out DreamValue argumentValue))
{
LocalVariables[i] = argumentValue;
}
else if (i < Arguments.OrderedArguments.Count)
{
LocalVariables[i] = Arguments.OrderedArguments[i];
}
else
{
LocalVariables[i] = DreamValue.Null;
}
}
}
public InitDreamObjectState(DreamThread thread, DreamObject dreamObject, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
_dreamObject = dreamObject;
_usr = usr;
_arguments = arguments;
}
public void AddAtomCreation(DreamObject atom, ServerIconAppearance appearance)
{
AtomType atomType = AtomType.Atom;
if (atom.IsSubtypeOf(DreamPath.Area))
{
atomType = AtomType.Area;
}
else if (atom.IsSubtypeOf(DreamPath.Turf))
{
atomType = AtomType.Turf;
}
else if (atom.IsSubtypeOf(DreamPath.Mob))
{
atomType = AtomType.Movable;
}
else if (atom.IsSubtypeOf(DreamPath.Obj))
{
atomType = AtomType.Movable;
}
lock (_dreamStateManagerLock) {
_currentDeltaState.AddAtomCreation(DreamMetaObjectAtom.AtomIDs[atom], atomType, appearance.GetID());
}
}
public override DreamValue OperatorOutput(DreamValue a, DreamValue b)
{
DreamObject client = a.GetValueAsDreamObjectOfType(DreamPath.Mob).GetVariable("client").GetValueAsDreamObjectOfType(DreamPath.Client);
DreamConnection connection = Program.ClientToConnection[client];
connection.OutputDreamValue(b);
return(new DreamValue(0));
}
public override void OnObjectDeleted(DreamObject dreamObject)
{
base.OnObjectDeleted(dreamObject);
lock (Mobs) {
Mobs.Remove(dreamObject);
}
}
public InitDreamObjectState(DreamThread thread, DreamObject dreamObject, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
IoCManager.InjectDependencies(this);
_dreamObject = dreamObject;
_usr = usr;
_arguments = arguments;
}
public override DreamValue OperatorOutput(DreamValue a, DreamValue b)
{
DreamObject client = a.GetValueAsDreamObjectOfType(DreamPath.Mob).GetVariable("client").GetValueAsDreamObjectOfType(DreamPath.Client);
DreamConnection connection = _dreamManager.GetConnectionFromClient(client);
connection.OutputDreamValue(b);
return(new DreamValue(0));
}
public override void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
base.OnObjectCreated(dreamObject, creationArguments);
ContentsList = dreamObject.GetVariable("contents").GetValueAsDreamList();
//New() is not called here
}
// Execute this proc. This will behave as if the proc has `set waitfor = 0`
public DreamValue Spawn(DreamObject src, DreamProcArguments arguments, DreamObject usr = null)
{
var context = new DreamThread();
var state = CreateState(context, src, usr, arguments);
context.PushProcState(state);
return(context.Resume());
}
public State(NativeProc proc, DreamThread thread, DreamObject src, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
_proc = proc;
Src = src;
Usr = usr;
Arguments = arguments;
}
public override void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
base.OnObjectCreated(dreamObject, creationArguments);
lock (Mobs) {
Mobs.Add(dreamObject);
}
}
public override DreamValue OnVariableGet(DreamObject dreamObject, string variableName, DreamValue variableValue)
{
switch (variableName)
{
case "tick_lag":
return(new DreamValue(_gameTiming.TickPeriod.TotalMilliseconds / 100));
case "fps":
return(new DreamValue(_gameTiming.TickRate));
case "timeofday":
return(new DreamValue((int)DateTime.UtcNow.TimeOfDay.TotalMilliseconds / 100));
case "time":
return(new DreamValue(_gameTiming.CurTime.TotalMilliseconds / 100));
case "realtime":
return(new DreamValue((DateTime.Now - new DateTime(2000, 1, 1)).Milliseconds / 100));
case "tick_usage": {
var tickUsage = (_gameTiming.RealTime - _gameTiming.LastTick) / _gameTiming.TickPeriod;
return(new DreamValue(tickUsage * 100));
}
case "maxx":
return(new DreamValue(_dreamMapManager.Size.X));
case "maxy":
return(new DreamValue(_dreamMapManager.Size.Y));
case "maxz":
return(new DreamValue(_dreamMapManager.Levels));
//case "address":
// return new(Runtime.Server.Address.ToString());
//case "port":
// return new(Runtime.Server.Port);
//case "url":
// return new("opendream://" + Runtime.Server.Address + ":" + Runtime.Server.Port);
case "system_type": {
//system_type value should match the defines in Defines.dm
if (Environment.OSVersion.Platform is PlatformID.Unix or PlatformID.MacOSX or PlatformID.Other)
{
return(new DreamValue(0));
}
//Windows
return(new DreamValue(1));
}
case "view": {
//Number if square & centerable, string representation otherwise
return(new DreamValue((_viewRange.IsSquare && _viewRange.IsCenterable) ? _viewRange.Width : _viewRange.ToString()));
}
default:
return(base.OnVariableGet(dreamObject, variableName, 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.0 / variableValue.GetValueAsInteger()));
}
}
public static DreamValue NativeProc_Find(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
DreamValue element = arguments.GetArgument(0, "Elem");
int start = arguments.GetArgument(1, "Start").GetValueAsInteger(); //1-indexed
int end = arguments.GetArgument(2, "End").GetValueAsInteger(); //1-indexed
DreamList list = (DreamList)instance;
return(new(list.FindValue(element, start, end)));
}
public static DreamValue NativeProc_Cut(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
int start = arguments.GetArgument(0, "Start").GetValueAsInteger(); //1-indexed
int end = arguments.GetArgument(1, "End").GetValueAsInteger(); //1-indexed
DreamList list = (DreamList)instance;
list.Cut(start, end);
return(DreamValue.Null);
}
public static DreamValue NativeProc_Copy(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
int start = arguments.GetArgument(0, "Start").GetValueAsInteger(); //1-indexed
int end = arguments.GetArgument(1, "End").GetValueAsInteger(); //1-indexed
DreamList list = (DreamList)instance;
DreamList listCopy = list.CreateCopy(start, end);
return(new DreamValue(listCopy));
}
public static DreamValue NativeProc_Swap(DreamObject instance, DreamObject usr, DreamProcArguments arguments)
{
DreamList list = (DreamList)instance;
int index1 = arguments.GetArgument(0, "Index1").GetValueAsInteger();
int index2 = arguments.GetArgument(1, "Index2").GetValueAsInteger();
list.Swap(index1, index2);
return(DreamValue.Null);
}
public State(AsyncNativeProc proc, Func <State, Task <DreamValue> > taskFunc, DreamThread thread, DreamObject src, DreamObject usr, DreamProcArguments arguments)
: base(thread)
{
_proc = proc;
_taskFunc = taskFunc;
Src = src;
Usr = usr;
Arguments = arguments;
}
public void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
if (!dreamObject.IsSubtypeOf(DreamPath.Atom)) // Atoms are in world.contents
{
_dreamManager.Datums.Add(dreamObject);
}
ParentType?.OnObjectCreated(dreamObject, creationArguments);
}
public override void OnObjectCreated(DreamObject dreamObject, DreamProcArguments creationArguments)
{
base.OnObjectCreated(dreamObject, creationArguments);
if (creationArguments.GetArgument(0, "Size").TryGetValueAsInteger(out int size))
{
((DreamList)dreamObject).Resize(size);
}
}
