public override void OnReleased()
{
ChirpLog.Info("OnReleased");
ChirpLog.Flush();
_initialized = false;
_terminated = false;
base.OnReleased();
}
public override void OnCreated(IThreading threading)
{
ChirpLog.Info("OnCreated");
ChirpLog.Flush();
_initialized = false;
_terminated = false;
base.OnCreated(threading);
}
private void ProcessHumansUpdated()
{
//Nothing to do if we have no target
//if (m_tb == null) return;
uint[] entries = SkylinesOverwatch.Data.Instance.HumansUpdated;
if (entries.Length == 0)
{
return;
}
CitizenManager instance = Singleton <CitizenManager> .instance;
foreach (uint i in entries)
{
Citizen resident = instance.m_citizens.m_buffer[(int)i];
if (resident.Dead)
{
continue;
}
if ((resident.m_flags & Citizen.Flags.Created) == Citizen.Flags.None)
{
continue;
}
CitizenInfo info = resident.GetCitizenInfo(i);
if (info == null)
{
continue;
}
if (!(info.m_citizenAI is ResidentAI))
{
continue;
}
if (info.m_gender == Citizen.Gender.Female)
{
info.m_gender = Citizen.Gender.Male;
ChirpLog.Info("Updated resident: " + resident.ToString() + " " + i);
ChirpLog.Flush();
}
// Do something with resident
CitizenAI ai = (CitizenAI)info.GetAI();
// TODO: How to get the CitizenInstance ?
//ai.SetTarget(resident.m_instance, 0, m_tb);
}
}
public static void Warning(String message)
{
try {
DebugOutputPanel.AddMessage(ColossalFramework.Plugins.PluginManager.MessageType.Warning, prefix + message);
if (inFile)
{
ChirpLog.Warning(prefix + message);
}
} catch (Exception e) {
ChirpLog.Error("Error during Console.Warning: " + e);
}
}
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
{
if (_terminated)
{
return;
}
try
{
if (!_initialized)
{
if (!IsOverwatched())
{
ChirpLogger.ChirpLog.Error("Skylines Overwatch not found. Terminating...");
ChirpLog.Flush();
_terminated = true;
return;
}
SkylinesOverwatch.Settings.Instance.Enable.BuildingMonitor = true;
SkylinesOverwatch.Settings.Instance.Enable.HumanMonitor = true;
SkylinesOverwatch.Settings.Instance.Enable.Residents = true;
// TODO: Is this needed ?
SkylinesOverwatch.Settings.Instance.Debug.HumanMonitor = true;
_initialized = true;
}
else
{
ProcessHumansUpdated();
}
}
catch (Exception e)
{
string error = "Failed to initialize\r\n";
error += String.Format("Error: {0}\r\n", e.Message);
error += "\r\n";
error += "==== STACK TRACE ====\r\n";
error += e.StackTrace;
ChirpLog.Error(error);
ChirpLog.Flush();
_terminated = true;
}
base.OnUpdate(realTimeDelta, simulationTimeDelta);
}
public static void SetFieldValue(MonoBehaviour monoObject, string fieldName, object value)
{
try
{
BindingFlags bindingFlags = BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.Static;
FieldInfo fieldInfo = monoObject.GetType().GetField(fieldName, bindingFlags);
fieldInfo.SetValue(monoObject, value);
}
catch (Exception e)
{
ChirpLog.Error("Unable to set value:" + monoObject.GetType().Name + ":" + fieldName + ":" + e.Message);
ChirpLog.Flush();
}
}
private void ProcessBuildingsUpdated()
{
if (m_tb != null)
{
return;
}
ushort[] entries = SkylinesOverwatch.Data.Instance.BuildingsUpdated;
if (entries.Length == 0)
{
return;
}
BuildingManager instance = Singleton <BuildingManager> .instance;
foreach (ushort i in entries)
{
Building building = instance.m_buildings.m_buffer[(short)i];
m_tb = i;
ChirpLog.Info("Target building is: " + m_tb);
ChirpLog.Flush();
return;
}
}
public static object CallMethod(MonoBehaviour monoObject, string methodName, object[] value = null)
{
object returnValue = null;
try
{
MethodInfo[] methods = monoObject.GetType().GetMethods();
foreach (MethodInfo info in methods)
{
if (info.Name == methodName)
{
returnValue = info.Invoke(monoObject, value); // [2]
}
}
return(returnValue);
}
catch (Exception e)
{
ChirpLog.Error("Unable to Call Method: " + monoObject.GetType().Name + ":" + methodName + ":" + e.Message);
ChirpLog.Flush();
return(returnValue);
}
}
//Thread: Main
public override void OnCreated(ISerializableData serializedData)
{
ChirpLog.Debug("ISerialization Created");
}
//Thread: Main
public override void OnCreated(ILevelUp levelUp)
{
ChirpLog.Debug("ILevelUp Created");
}
//Thread: Main
public override void OnCreated(IChirper chirper)
{
ChirpLog.Debug("IChirper Created");
}
public void draw_lights(int mode)
{
ChirpLog.Debug("Start draw_lights");
Color kleur = Color.white;
Vector3 position = Vector3.zero;
Quaternion orientation = Quaternion.identity;
int i, j, d, m, ko;
var cam_info = Camera.main;
Light lightComp;
int n = 0;
float working = 0.0f;
Vector3 speed;
for (i = 0; i < vehicles.Length; i++)
{
if ((vehicles[i].m_flags & Vehicle.Flags.Spawned) != 0 && n < max_cars && (ushort)i == vehicles[i].GetFirstVehicle((ushort)i))
{
vehicles[i].GetSmoothPosition((ushort)i, out position, out orientation);
if (inrange(position))
{
Vector3 forward = orientation * Vector3.forward;
Vector3 up = orientation * Vector3.up;
float len = vehicles[i].CalculateTotalLength((ushort)i);
if (len > 10)
{
len = 10;
}
lichten[n].transform.position = position + 1f * up + len * forward * 0.5f;
lichten[n].transform.LookAt(position + len * forward * 1.0f);
lichten[n].SetActive(true);
lightComp = lichten[n].GetComponent <Light>();
lightComp.type = LightType.Spot;
lightComp.spotAngle = 50f;
lightComp.intensity = 8;
kleur.r = 1f;
kleur.g = 0.96f;
kleur.b = 0.9f;
kleur.a = 1f;
lightComp.color = kleur;
n++;
lightComp.range = 10f;
}
}
if ((vehicles[i].m_flags & Vehicle.Flags.Spawned) != 0 && n < max_cars && (ushort)i == vehicles[i].GetLastVehicle((ushort)i) && cam_info.transform.position.y < 300)
{
speed = vehicles[i].GetLastFrameVelocity();
vehicles[i].GetSmoothPosition((ushort)i, out position, out orientation);
if (inrange(position) && speed.magnitude < 6)
{
Vector3 forward = orientation * Vector3.forward;
Vector3 up = orientation * Vector3.up;
float len = vehicles[i].CalculateTotalLength((ushort)i);
if (len > 10)
{
len = 10;
}
lichten[n].transform.position = position + 1f * up - len * forward * 0.5f;
lichten[n].transform.LookAt(position - len * forward * 1.0f);
//lichten[n].transform.Rotate(right*20);
//lichten[n].transform.Rotate(forward*180);
lichten[n].SetActive(true);
lightComp = lichten[n].GetComponent <Light>();
lightComp.type = LightType.Spot;
lightComp.spotAngle = 60f;
//ChirpLog.Debug((speed.x+speed.y+speed.z) +" break?");
lightComp.intensity = 6 - speed.magnitude;
kleur = Color.red;
lightComp.color = kleur;
lightComp.range = 10f;
n++;
}
}
if (n == max_cars)
{
i = 100000;
}
}
ChirpLog.Debug(n + " Lights after cars");
//ChirpLog.Flush();
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, n + " Lights after cars");
Vector3 poss = Vector3.zero;
Vector3 pose = Vector3.zero;
Vector3 positions = Vector3.zero;
Vector3 positione = Vector3.zero;
Vector3 middlePos1 = Vector3.zero;
Vector3 middlePos2 = Vector3.zero;
float afstand, real_pitch;
float lamps;
//ChirpLog.Flush();
kleur.r = 1f;
kleur.g = 0.96f;
kleur.b = 0.9f;
kleur.a = 1f;
//ChirpLog.Debug(n + " cars");
for (d = 0; d < count_build_prop; d++)
{
i = build_props[d];
j = build_props[d + max_building_props];
if (buildings[i].Info != null)
{
var propsjes = buildings[i].Info.m_props;
if (propsjes[j].m_prop != null)
{
position = propsjes[j].m_position;
position.z = -position.z;
position = buildings[i].CalculatePosition(position);
if (inrange(position))
{
lichten[n].transform.position = position + new Vector3(0f, 3f, 0f);
lichten[n].transform.LookAt(position);
lichten[n].SetActive(true);
lightComp = lichten[n].GetComponent <Light>();
lightComp.type = LightType.Spot;
lightComp.intensity = 5;
lightComp.spotAngle = 170f;
lightComp.color = kleur;
lightComp.range = 10f;
n++;
}
}
}
if (n == max_cars)
{
d = 100000;
}
}
//ChirpLog.Debug(n + " Lights after props, lane props: " + count_lane_prop);
//ChirpLog.Flush();
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, n + " Lights after props, lane props: " + count_lane_prop);
//road lights
kleur.r = 1f;
kleur.g = 0.96f;
kleur.b = 0.7f;
kleur.a = 1f;
for (d = 0; d < count_lane_prop; d++)
{
//ChirpLog.Debug(d + " regel");
m = lane_props[d];
i = lane_props[d + max_lane_props];
j = lane_props[d + max_lane_props * 2];
if (segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_prop != null)
{
position = netMan.m_nodes.m_buffer[segments[m].m_startNode].m_position;
segments[m].GetClosestPositionAndDirection(position, out positions, out poss);
//poss = segments[m].m_startDirection;
position = netMan.m_nodes.m_buffer[segments[m].m_endNode].m_position;
segments[m].GetClosestPositionAndDirection(position, out positione, out pose);
//pose = segments[m].m_endDirection;
NetSegment.CalculateMiddlePoints(positions, poss, positione, pose, true, true, out middlePos1, out middlePos2, out afstand);
if (inrange(position))
{
if (segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_minLength < afstand)
{
//
afstand = afstand - segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_segmentOffset;
lamps = (int)((afstand) / (segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_repeatDistance) + 0.53f);
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, " Lamps: " + segments[m].Info.m_lanes[i].m_stopOffset);
real_pitch = (afstand + 0.5f * segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_repeatDistance) / lamps;
if ((segments[m].m_flags & NetSegment.Flags.End) == NetSegment.Flags.End)
{
working = real_pitch * 0.5f;
//afstand = afstand-real_pitch*0.5f;
real_pitch = (afstand + 0.5f * segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_repeatDistance - 10f) / lamps;
//lamps = 3;
}
else
{
working = 0;
real_pitch = (afstand + 0.5f * segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_repeatDistance - 20f) / lamps;
//lamps = 1;
}
for (ko = 0; ko < lamps; ko++)
{
//if(working > segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_segmentOffset){
//- segments[m].Info.m_lanes[i].m_lawneProps.m_props[j].m_position
if (lamps == 1)
{
//ChirpLog.Debug("Flags: " + segments[m].m_flags);
//ChirpLog.Debug("m_startDirection: " + segments[m].m_startDirection);
//ChirpLog.Debug("m_endDirection: " + segments[m].m_endDirection);
//ChirpLog.Debug("poss: " + poss);
//ChirpLog.Debug("pose: " + pose);
//ChirpLog.Debug("m_verticalOffset: " + segments[m].Info.m_lanes[i].m_verticalOffset);
if ((segments[m].m_flags & NetSegment.Flags.End) == NetSegment.Flags.End)
{
position = positions + ((afstand + 10f) / 2f) * segments[m].m_startDirection + segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_position;
}
else
{
position = positions + ((afstand) / 2f) * poss + ko * Vector3.forward + segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_position;
}
lichten[n].transform.position = position + new Vector3(0f, 7f, 0f);
lichten[n].transform.LookAt(position);
lichten[n].SetActive(true);
lightComp = lichten[n].GetComponent <Light>();
lightComp.type = LightType.Spot;
lightComp.intensity = 150;
lightComp.spotAngle = 150f;
lightComp.color = kleur;
lightComp.range = 15f;
n++;
}
//working = working - segments[m].Info.m_lanes[i].m_laneProps.m_props[j].m_repeatDistance;
if (lamps > 1)
{
//center at = (afstand)/2f
if ((segments[m].m_flags & NetSegment.Flags.End) == NetSegment.Flags.End)
{
position = positions + (afstand / 2f - real_pitch / 2f + real_pitch * ko + 5f) * poss;
}
else
{
position = positions + (afstand / 2f - real_pitch / 2f + real_pitch * ko) * poss;
}
lichten[n].transform.position = position + new Vector3(0f, 7f, 0f);
lichten[n].transform.LookAt(position);
lichten[n].SetActive(true);
lightComp = lichten[n].GetComponent <Light>();
lightComp.type = LightType.Spot;
lightComp.intensity = 6;
lightComp.spotAngle = 150f;
lightComp.color = kleur;
lightComp.range = 15f;
n++;
//working = working + real_pitch;
}
}
}
}
}
//}
if (n > max_cars)
{
d = 100000;
}
}
ChirpLog.Debug(n + " Lights !");
//ChirpLog.Flush();
for (i = n; n < 256; n++)
{
lichten[n].SetActive(false);
}
ChirpLog.Debug("Done");
//ChirpLog.Flush();
}
public void OnUpdate(float realTimeDelta, float simulationTimeDelta)
{
try
{
ChirpLog.Debug("Start with all");
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, " fps: " + 1f/realTimeDelta);
//check init
if (!_mod_loaded)
{
_mod = new MyIUserMod();
if (_mod.Dim_all() > 0)
{
//ChirpLog.Debug("StartGame");
//ChirpLog.Flush();
_mod.start_game();
_mod_loaded = true;
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, " Light level: " + _mod.get_info_main_light());
}
}
else
{
ChirpLog.Debug("Delta");
avg_fps = avg_fps * 0.97f + 1f / realTimeDelta * 0.03f;
if (_mod.max_cars < 200)
{
if (avg_fps > 35)
{
_mod.max_cars = _mod.max_cars + 1;
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, "Light max:" + _mod.max_cars);
}
}
if (_mod.max_cars > 32)
{
if (avg_fps < 30)
{
_mod.max_cars = _mod.max_cars - 1;
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, "Light max:" + _mod.max_cars + " reduced");
}
}
ChirpLog.Debug("A");
if (_mod.updated_segment_last < _mod.segments.Length && _mod.count_build_prop < _mod.max_lane_props)
{
_mod.road_props_list(_mod.updated_segment_last, _mod.updated_segment_last + 500);
_mod.updated_segment_last = _mod.updated_segment_last + 500;
//_mod.updated_segment_last = 0;
//_mod.count_build_prop = 0;
}
ChirpLog.Debug("B");
//DebugOutputPanel.AddMessage (ColossalFramework.Plugins.PluginManager.MessageType.Message, " Light level: " + _mod.get_info_main_light());
if (frame_counter > 10)
{
if (_mod.get_info_main_light() < 40)
{
night = true;
}
else
{
night = false;
}
frame_counter = 0;
}
frame_counter++;
if (night)
{
//slow road updater
ChirpLog.Debug("C");
_mod.Update();
}
else
{
_mod.day();
}
ChirpLog.Debug("Done with all");
//ChirpLog.Flush();
}
}catch
{
}
}
public void OnNewMessage(IChirperMessage message)
{
ChirpLog.Info("Chirper chirped: " + message.ToString());
}
public void OnReleased()
{
ChirpLog.Info("Chirp Logger Example Offline");
ChirpLog.Flush();
}
// Thread: Main
public void OnCreated(IMilestones milestones)
{
ChirpLog.Debug("IMilestones Created");
}
public void OnCreated(IChirper chirper)
{
ChirpLog.Info("Chirp Logger Example Online");
ChirpLog.Debug(DumpAllGameObjects());
}
//Thread: Main
public void OnCreated(IDemand demand)
{
ChirpLog.Debug("IDemand Created");
}
//Thread: Main
public void OnCreated(ITerrain terrain)
{
ChirpLog.Debug("ITerrain Created");
}
//Thread: Main
public override void OnCreated(IThreading threading)
{
ChirpLog.Debug("IThreading Created");
}
//Thread: Main
public void OnCreated(IAreas areas)
{
ChirpLog.Debug("IAreas Created");
}
// Thread: Main
public override void OnCreated(IEconomy economy)
{
ChirpLog.Debug("IEconomy Created");
}
// Thread: Main
public override void OnCreated(ILoading loading)
{
ChirpLog.Debug("ILoading Created");
}
public void OnLevelLoaded(LoadMode mode)
{
ChirpLog.Flush();
}
