public CityEvent GetEventForBuilding(ref Building thisBuilding, List <CityEventXml> xmlEvents)
{
CityEvent _buildingEvent = null;
List <CityEventXmlContainer> _validEvents = new List <CityEventXmlContainer>();
SimulationManager _simulationManager = Singleton <SimulationManager> .instance;
foreach (CityEventXml xmlEvent in xmlEvents)
{
foreach (CityEventXmlContainer containedEvent in xmlEvent._containedEvents)
{
if (containedEvent._eventBuildingClassName == thisBuilding.Info.name && containedEvent._supportsRandomEvents)
{
_validEvents.Add(containedEvent);
}
}
}
if (_validEvents.Count > 0)
{
CityEventXmlContainer pickedEvent = _validEvents[_simulationManager.m_randomizer.Int32((uint)_validEvents.Count)];
if (pickedEvent != null)
{
_buildingEvent = new XmlEvent(pickedEvent);
}
}
else
{
CimTools.CimToolsHandler.CimToolBase.DetailedLogger.Log("Couldn't find any events for " + thisBuilding.Info.name);
}
return(_buildingEvent);
}
public void AddEvent(CityEvent eventToAdd)
{
if (eventToAdd != null)
{
BuildingManager buildingManager = Singleton <BuildingManager> .instance;
Building monument = buildingManager.m_buildings.m_buffer[eventToAdd.m_eventData.m_eventBuilding];
if ((monument.m_flags & Building.Flags.Active) != Building.Flags.None && (monument.m_flags & Building.Flags.Created) != Building.Flags.None)
{
m_nextEvents.Add(eventToAdd);
string message = eventToAdd.GetCitizenMessageInitialised();
if (message != "")
{
MessageManager _messageManager = Singleton <MessageManager> .instance;
_messageManager.QueueMessage(new CitizenCustomMessage(_messageManager.GetRandomResidentID(), message));
}
LoggingWrapper.Log("Event created at " + monument.Info.name + " for " + eventToAdd.m_eventData.m_eventStartTime.ToShortDateString() + ". Current date: " + CITY_TIME.ToShortDateString());
Debug.Log("Event starting at " + eventToAdd.m_eventData.m_eventStartTime.ToLongTimeString() + ", " + eventToAdd.m_eventData.m_eventStartTime.ToShortDateString());
Debug.Log("Event building is " + monument.Info.name);
Debug.Log("Current date: " + CITY_TIME.ToLongTimeString() + ", " + CITY_TIME.ToShortDateString());
}
else
{
LoggingWrapper.LogError("Couldn't create an event, as the building is inactive or not created!");
}
}
else
{
LoggingWrapper.LogError("Couldn't create an event, as it was null!");
}
}
public CityEvent GetXmlEventFromData(CityEventData data)
{
CityEvent dataEvent = null;
if (data.m_eventName != "")
{
foreach (CityEventXml xmlEvent in CityEventManager.instance.m_xmlEvents)
{
foreach (CityEventXmlContainer containedEvent in xmlEvent._containedEvents)
{
if ("XMLEvent-" + containedEvent._name == data.m_eventName)
{
dataEvent = new XmlEvent(containedEvent);
dataEvent.m_eventData = data;
CimTools.CimToolsHandler.CimToolBase.DetailedLogger.Log("Created an XML event: " + data.m_eventName);
break;
}
}
if (dataEvent != null)
{
break;
}
}
}
return(dataEvent);
}
public bool EventStartsWithin(ushort buildingID, double hours, bool countStarted = false)
{
for (int index = 0; index < m_nextEvents.Count; ++index)
{
CityEvent thisEvent = m_nextEvents[index];
if (thisEvent.m_eventData.m_eventBuilding == buildingID && (thisEvent.EventStartsWithin(hours) || (countStarted && thisEvent.m_eventData.m_eventStarted)))
{
return(true);
}
}
return(false);
}
public bool EventStartsBetween(DateTime date, TimeSpan length)
{
for (int index = 0; index < m_nextEvents.Count; ++index)
{
CityEvent thisEvent = m_nextEvents[index];
if (thisEvent.EventActiveBetween(date, length))
{
return(true);
}
}
return(false);
}
public FastList <CityEvent> EventsThatStartWithin(double hours, bool countStarted = false)
{
FastList <CityEvent> _eventsWithin = new FastList <CityEvent>();
for (int index = 0; index < m_nextEvents.Count; ++index)
{
CityEvent thisEvent = m_nextEvents[index];
if (thisEvent.EventStartsWithin(hours) || (countStarted && thisEvent.m_eventData.m_eventStarted))
{
_eventsWithin.Add(thisEvent);
}
}
return(_eventsWithin);
}
public int EventStartsWithin(uint citizenID, ref Citizen person, double hours, bool countStarted = false)
{
int foundEventIndex = -1;
for (int index = 0; index < m_nextEvents.Count; ++index)
{
CityEvent thisEvent = m_nextEvents[index];
if ((thisEvent.EventStartsWithin(hours) && thisEvent.CitizenCanGo(citizenID, ref person)) || (countStarted && thisEvent.m_eventData.m_eventStarted))
{
foundEventIndex = index;
break;
}
}
return(foundEventIndex);
}
public void ClearDeadEvents()
{
bool clearAllEvents = false;
CimTools.CimToolsHandler.CimToolBase.ModPanelOptions.GetOptionValue("ClearEvents", ref clearAllEvents);
if (clearAllEvents)
{
CimTools.CimToolsHandler.CimToolBase.ModPanelOptions.SetOptionValue("ClearEvents", false);
}
if (m_nextEvents.Count > 0)
{
for (int index = 0; index < m_nextEvents.Count; ++index)
{
bool clearEvent = false || clearAllEvents;
CityEvent thisEvent = m_nextEvents[index];
if ((thisEvent.m_eventData.m_eventEnded && (CITY_TIME - thisEvent.m_eventData.m_eventFinishTime).TotalHours > _eventEndBuffer))
{
clearEvent = true;
Debug.Log("Event finished");
LoggingWrapper.Log("Event finished");
}
else if (!thisEvent.m_eventData.m_eventStarted && !thisEvent.m_eventData.m_eventEnded && !thisEvent.EventStartsWithin(24 * 7))
{
clearEvent = true;
Debug.LogWarning("Event had more than a week of buffer. Removed.");
LoggingWrapper.LogWarning("Event had more than a week of buffer. Removed.");
}
if (clearEvent)
{
m_nextEvents.RemoveAt(index);
--index;
}
else
{
m_nextEvents[index].Update();
}
}
}
}
public CityEvent GetEventForBuilding(ref Building thisBuilding)
{
CityEvent buildingEvent = null;
if (!Experiments.ExperimentsToggle.UseXMLEvents)
{
switch (thisBuilding.Info.name)
{
//No longer supported
}
}
else
{
buildingEvent = GetEventForBuilding(ref thisBuilding, CityEventManager.instance.m_xmlEvents);
}
return(buildingEvent);
}
public CityEvent GetEventFromData(CityEventData data)
{
CityEvent dataEvent = null;
if (data.m_eventName != "")
{
if (data.m_eventName.Substring(0, 9) != "XMLEvent-")
{
try
{
Type foundType = Assembly.GetExecutingAssembly().GetType(data.m_eventName);
if (foundType != null)
{
dataEvent = Activator.CreateInstance(foundType) as CityEvent;
if (dataEvent != null)
{
dataEvent.m_eventData = data;
CimTools.CimToolsHandler.CimToolBase.DetailedLogger.Log("Created a normal event: " + data.m_eventName);
}
}
}
catch
{
dataEvent = null;
}
}
else
{
CimTools.CimToolsHandler.CimToolBase.DetailedLogger.Log("Found an XML event, rerouting.");
dataEvent = GetXmlEventFromData(data);
}
}
return(dataEvent);
}
public CityEvent GetEventForBuilding(ref Building thisBuilding)
{
CityEvent buildingEvent = null;
if (!Experiments.ExperimentsToggle.UseXMLEvents)
{
switch (thisBuilding.Info.name)
{
case "Modern Art Museum":
buildingEvent = new ArtExhibit();
break;
case "Grand Mall":
buildingEvent = new ShopOpening();
break;
case "Library":
buildingEvent = new BookSigning();
break;
case "ExpoCenter":
switch (Singleton <SimulationManager> .instance.m_randomizer.Int32(5))
{
case 0:
buildingEvent = new BusinessExpo();
break;
case 1:
buildingEvent = new CaravanExpo();
break;
case 2:
buildingEvent = new ComicExpo();
break;
case 3:
buildingEvent = new ElectronicExpo();
break;
case 4:
buildingEvent = new GameExpo();
break;
}
break;
case "Stadium":
buildingEvent = new FootballGame();
break;
case "Opera House":
buildingEvent = new OperaEvent();
break;
case "Posh Mall":
buildingEvent = new ShopOpening();
break;
case "Observatory":
//coming soon
break;
case "Official Park":
//buildingEvent = new Memorial();
break;
case "Theater of Wonders":
buildingEvent = new TheaterEvent();
break;
case "Trash Mall":
buildingEvent = new ShopOpening();
break;
case "SeaWorld":
buildingEvent = new AquariumEvent();
break;
}
}
else
{
buildingEvent = GetEventForBuilding(ref thisBuilding, CityEventManager.instance.m_xmlEvents);
}
return(buildingEvent);
}
public void CreateEvents()
{
SimulationManager _simulationManager = Singleton <SimulationManager> .instance;
BuildingManager _buildingManager = Singleton <BuildingManager> .instance;
PrintMonuments();
if (m_forcedEvent != null)
{
m_nextEvents.Clear();
}
FastList <ushort> allBuildings = CityEventBuildings.instance.GetPotentialEventBuildings();
if (allBuildings.m_size > 0)
{
if (m_forcedEvent != null)
{
for (int index = 0; index < allBuildings.m_size; ++index)
{
ushort buildingId = allBuildings[index];
Building monument = _buildingManager.m_buildings.m_buffer[buildingId];
if (monument.Info.name == m_forcedEvent._eventBuildingClassName)
{
CityEvent xmlEvent = new XmlEvent(m_forcedEvent);
xmlEvent.SetUp(ref buildingId);
xmlEvent.m_eventData.m_eventStartTime = CITY_TIME.AddHours(4d);
xmlEvent.m_eventData.m_eventFinishTime = xmlEvent.m_eventData.m_eventStartTime.AddHours(xmlEvent.GetEventLength());
AddEvent(xmlEvent);
LoggingWrapper.Log("Forced event created at " + monument.Info.name + " for " + xmlEvent.m_eventData.m_eventStartTime.ToShortTimeString() + ". Current date: " + CITY_TIME.ToShortTimeString());
}
else
{
LoggingWrapper.Log(monument.Info.name + " != " + m_forcedEvent._eventBuildingClassName);
}
}
}
else
{
for (int count = 0; count < 10; ++count)
{
ushort randomMonumentId = allBuildings.m_buffer[_simulationManager.m_randomizer.UInt32((uint)allBuildings.m_size)];
if (randomMonumentId < _buildingManager.m_buildings.m_size)
{
Building monument = _buildingManager.m_buildings.m_buffer[randomMonumentId];
CityEvent foundEvent = CityEventBuildings.instance.GetEventForBuilding(ref monument);
if (foundEvent != null && (monument.m_flags & Building.Flags.Active) != Building.Flags.None)
{
foundEvent.SetUp(ref randomMonumentId);
AddEvent(foundEvent);
break;
}
else
{
Debug.Log("No event scheduled just yet. Checking again soon.");
}
}
}
}
}
m_forcedEvent = null;
if (!ExperimentsToggle.ForceEventToHappen)
{
m_nextEventCheck = CITY_TIME.AddHours(3);
}
}
