/// <summary>
/// Handle "Camera" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// TODO
/// </remarks>
public void OnCameraMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "get":
SendAll();
break;
case "set":
HandleMove(msg, false);
break;
case "move":
HandleMove(msg, true);
break;
case "lookAt":
HandleLookAt(msg);
break;
case "updateInterval": {
updateInterval = msg.GetFloat("interval");
break;
}
default:
throw new ArgumentException($"Invalid method {action}");
}
}
public void OnClientMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "gimme":
economyManager.AddResource(
EconomyManager.Resource.RewardAmount,
msg.GetInt("amount"),
(ItemClass)ScriptableObject.CreateInstance("ItemClass"));
break;
case "payLoan": {
var r = economyManager.PayLoanNow(msg.GetInt("id"));
if (r == null)
{
Log($"PayLoanNow returns null");
}
else
{
Log($"PayLoanNow returns: {r}");
}
break;
}
//case "setBudget": {
// //TODO, also set tax rate
// //economyManager.SetBudget();
// break;
// }
default:
throw new ArgumentException($"Invalid method {action}");
}
}
/// <summary>
/// Handle "Citizen" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// <c>get</c>: building ID => get info about specified building
/// <c>list</c>: (anything) => get list of valid IDs
/// </remarks>
public void OnClientMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "get":
SendCitizen(msg.GetInt("id"));
break;
default:
throw new ArgumentException($"Invalid method {action}");
}
}
/// <summary>
/// Handle "District" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// <c>get</c>: district ID => get info about specified district
/// <c>list</c>: (anything) => get list of valid IDs
/// </remarks>
public void OnDistrictMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "get":
SendJson(GetDistrict(msg.GetInt("id")), "District");
break;
case "list":
SendDistrictList();
break;
default:
throw new ArgumentException($"Invalid method {action}");
}
}
/// <summary>
/// Handle "Instances" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// TODO
/// </remarks>
public void OnClientMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "AudioManager":
SendJson(GetAudio(), "Instances.AudioManager");
break;
case "BuildingManager":
SendJson(GetBuildings(), "Instances.BuildingManager");
break;
case "CitizenManager":
SendJson(GetCitizens(), "Instances.CitizenManager");
break;
case "DisasterManager":
SendJson(GetDisasters(), "Instances.DisasterManager");
break;
case "DistrictManager":
SendJson(GetDistricts(), "Instances.DistrictManager");
break;
case "EconomyManager":
SendJson(GetEconomy(), "Instances.EconomyManager");
break;
case "ElectricityManager":
SendJson(GetElectricity(), "Instances.ElectricityManager");
break;
case "EventManager":
SendJson(GetEvents(), "Instances.EventManager");
break;
case "GameAreaManager":
SendJson(GetGameAreas(), "Instances.GameAreaManager");
break;
case "NetManager":
SendJson(GetNetworks(), "Instances.NetManager");
break;
case "PathManager":
SendJson(GetPaths(), "Instances.PathManager");
break;
case "PropManager":
SendJson(GetProps(), "Instances.PropManager");
break;
case "RenderManager":
SendJson(GetRender(), "Instances.RenderManager");
break;
case "SimulationManager":
SendJson(GetSimulation(), "Instances.SimulationManager");
break;
case "TerrainManager":
SendJson(GetTerrain(), "Instances.TerrainManager");
break;
case "TransferManager":
SendJson(GetTransfers(), "Instances.TransferManager");
break;
case "TransportManager":
SendJson(GetTransport(), "Instances.TransportManager");
break;
case "TreeManager":
SendJson(GetTrees(), "Instances.TreeManager");
break;
case "VehicleManager":
SendJson(GetVehicles(), "Instances.VehicleManager");
break;
case "WeatherManager":
SendJson(GetWeather(), "Instances.WeatherManager");
break;
case "ZoneManager":
SendJson(GetZones(), "Instances.ZoneManager");
break;
default:
throw new ArgumentException($"Invalid method {action}");
}
}
/// <summary>
/// Handle "Building" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// <c>get</c>: building ID => get info about specified building
/// <c>list</c>: (anything) => get list of valid IDs
/// </remarks>
public void OnClientMessage(ClientMessage msg)
{
string action = msg.GetString("action");
switch (action)
{
case "get": {
SendBuilding(msg.GetInt("id"));
break;
}
case "getByProblem": {
//This could be just a ulong parameter but nope,
//apparently you can't use ulong in json for reasons
string flags = msg.GetString("problem");
if (flags == null || (!ProblemFlags.ContainsKey(flags) &&
!ProblemFlagNames.ContainsKey(flags)))
{
throw new ArgumentException("Invalid problem name");
}
if (ProblemFlags.ContainsKey(flags))
{
SendProblems(ProblemFlags[flags]);
}
else
{
SendFlags(ProblemFlagNames[flags]);
}
break;
}
case "list":
SendList();
break;
case "destroy":
DestroyBuilding(msg.GetInt("id"));
break;
case "canRebuild": {
int id = msg.GetInt("id");
bool ok = CanRebuild(msg.GetInt("id"), out string status);
SendJson(new Dictionary <string, string> {
{ "canRebuild", ok.ToString() },
{ "id", id.ToString() },
{ "status", status },
}, "canRebuild");
break;
}
case "rebuild": {
int id = msg.GetInt("id");
bool force = msg.HasKey("force") && msg.GetBool("force");
bool ok = RebuildBuilding(msg.GetInt("id"),
out string status, force);
SendJson(new Dictionary <string, string> {
{ "rebuild", ok.ToString() },
{ "id", id.ToString() },
{ "status", status },
}, "rebuild");
break;
}
default:
throw new ArgumentException($"Invalid method {action}");
}
}
/// <summary>
/// Handle "Reflection" message from client.
/// </summary>
/// <param name="msg">Message.</param>
/// <remarks>Expects a dict with one of the keys:
/// TODO
/// </remarks>
public void OnClientMessage(ClientMessage msg)
{
string[] targetName;
string parentName = "<none>", objectName = "<none>";
string action;
Response resp;
try {
targetName = msg.GetStringArray("object");
action = msg.GetString("action");
resp = new Response {
targetName = targetName,
action = action,
};
}
catch (KeyNotFoundException) {
SendErrorResponse(HttpStatusCode.BadRequest);
return;
}
try {
object target, parent = null;
try {
objectName = targetName[0];
target = GetManager(targetName[0]);
for (int i = 1; i < targetName.Length; i++)
{
parent = target;
parentName = objectName;
objectName = targetName[i];
//Log($"[{i}] Object={objectName} parent={parentName}");
target = target.GetType().GetField(targetName[i]).GetValue(target);
}
if (target == null)
{
throw new NullReferenceException();
}
}
catch (NullReferenceException) {
resp.error = $"Not found '{objectName}' in '{parentName}'";
SendJson(resp);
return;
}
Log($"Object={objectName} parent={parentName} action={action}");
switch (action)
{
case null:
SendErrorResponse(HttpStatusCode.BadRequest);
return;
case "GetFields": {
var fields = target.GetType().GetFields(
BindingFlags.FlattenHierarchy | BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static);
var dict = new Dictionary <string, Dictionary <string, object> >();
foreach (FieldInfo field in fields)
{
dict[field.Name] = new Dictionary <string, object> {
{ "IsAssembly", field.IsAssembly },
{ "IsFamily", field.IsFamily },
{ "IsInitOnly", field.IsInitOnly },
{ "IsLiteral", field.IsLiteral },
{ "IsPrivate", field.IsPrivate },
{ "IsPublic", field.IsPublic },
{ "IsStatic", field.IsStatic },
{ "Type", field.GetType().FullName },
{ "DeclaringType", field.DeclaringType.FullName },
};
}
resp.result = dict;
break;
}
case "GetMethods": {
var methods = target.GetType().GetMethods(
BindingFlags.FlattenHierarchy | BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static);
var dict = new Dictionary <string, Dictionary <string, object> >();
foreach (MethodInfo method in methods)
{
var paramList = new List <Dictionary <string, object> >();
foreach (var paramInfo in method.GetParameters())
{
paramList.Add(GetParamInfo(paramInfo));
}
dict[method.Name] = new Dictionary <string, object> {
{ "ContainsGenericParameters", method.ContainsGenericParameters },
{ "IsAbstract", method.IsAbstract },
{ "IsAssembly", method.IsAssembly },
{ "IsConstructor", method.IsConstructor },
{ "IsFamily", method.IsFamily },
{ "IsFinal", method.IsFinal },
{ "IsGenericMethod", method.IsGenericMethod },
{ "IsPrivate", method.IsPrivate },
{ "IsPublic", method.IsPublic },
{ "IsStatic", method.IsStatic },
{ "IsVirtual", method.IsVirtual },
{ "Parameters", paramList },
{ "ReturnParameter", method.ReturnParameter },
{ "ReturnType", method.ReturnType.FullName },
//{ "Type", method.GetType().FullName },
{ "DeclaringType", method.DeclaringType.FullName },
};
}
resp.result = dict;
break;
}
case "GetProperties": {
var props = target.GetType().GetProperties(
BindingFlags.FlattenHierarchy | BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static);
var dict = new Dictionary <string, Dictionary <string, object> >();
foreach (PropertyInfo prop in props)
{
dict[prop.Name] = new Dictionary <string, object> {
{ "CanRead", prop.CanRead },
{ "CanWrite", prop.CanWrite },
{ "Type", prop.GetType().FullName },
{ "DeclaringType", prop.DeclaringType.FullName },
};
}
resp.result = dict;
break;
}
case "GetType":
resp.result = target.GetType(); //.FullName;
break;
case "GetValue": {
string field = msg.GetString("field");
object[] index = msg.GetObjectArray("index");
var prop = target.GetType().GetProperty(field);
if (prop == null)
{
resp.error = $"No field '{field}' in object '{objectName}'";
}
else
{
resp.result = prop.GetValue(target, index);
}
break;
}
case "Invoke":
//XXX cast args to appropriate types...
resp.result = target.GetType().GetMethod(
msg.GetString("field")).Invoke(
target, msg.GetObjectArray("args"));
break;
case "SetValue": {
string field = msg.GetString("field");
object value = msg.GetObject("value");
object[] index = msg.GetObjectArray("index");
Log($"Set field '{field}' of '{objectName}' to value '{value}'");
var prop = target.GetType().GetProperty(field);
if (prop == null)
{
resp.error = $"No field '{field}' in object '{objectName}'";
}
else
{
prop.SetValue(target, value, index);
}
break;
}
default:
throw new ArgumentException($"Invalid method {action}");
}
SendJson(resp);
}
catch (Exception ex) {
resp.error = ex.ToString();
SendJson(resp);
}
}