public void SetUp(LabelOptionItem selectedData, ushort buildingID)
{
_linkedEvent = selectedData.linkedEvent;
if (_linkedEvent != null && buildingID != 0 && _ticketSlider != null)
{
List <CityEventXmlIncentive> incentives = _linkedEvent.GetIncentives();
title = _linkedEvent.GetReadableName();
_ticketSlider.maxValue = _linkedEvent.GetCapacity();
_ticketSlider.minValue = Mathf.Min(_linkedEvent.GetCapacity(), 100);
_ticketSlider.value = _ticketSlider.minValue;
_incentiveList.rowsData.Clear();
foreach (CityEventXmlIncentive incentive in incentives)
{
IncentiveOptionItem optionItem = new IncentiveOptionItem()
{
cost = incentive._cost,
description = incentive._description,
negativeEffect = incentive._negativeEffect,
positiveEffect = incentive._positiveEffect,
returnCost = incentive._returnCost,
title = incentive._name,
ticketCount = _ticketSlider.value
};
optionItem.OnOptionItemChanged += OptionItem_OnOptionItemChanged;
_incentiveList.rowsData.Add(optionItem);
}
try
{
_incentiveList.DisplayAt(0);
_incentiveList.selectedIndex = 0;
_incentiveList.Show();
}
catch
{
LoggingWrapper.LogError("IncentiveList DisplayAt hit an error. Probably too few items in the list.");
}
_incentiveList.Refresh();
CalculateTotal();
TranslateInfoString();
PerformLayout();
LoggingWrapper.Log("Event capacity is " + _linkedEvent.GetCapacity().ToString() + ".");
LoggingWrapper.Log("Successfully set up the UserEventCreationWindow.");
}
else
{
LoggingWrapper.LogError("Linked event was invalid, or the building was 0!");
}
relativePosition = Vector3.zero;
}
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 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 static void startEvent(XmlEvent evt)
{
if (evt != null)
{
Event_Run event_Run = instance.gameObject.AddComponent <Event_Run>();
event_Run.SetEvent(evt);
}
}
/// <summary>
/// public delegate object GetRealTimeArgsFunc(String argName);
/// </summary>
///
public void RegisterEvent(String EventName, String ActionName, params String[] args)
{
XmlActionList list = new XmlDesigner.XmlActionList(); //xml에서 정의될 것을 코드상에서 가져온다..
list.Add(new XmlAction(ActionName, args));
XmlEvent evt = new XmlEvent(EventName, new XmlActionList[] { list }.ToList());
this.Events.Add(EventName, evt);
}
public void OnPointerUp(BaseEventData arg0)//点选目录视频,eventTrigger事件
{
XmlPic2D toggle = XmlStage.GetAsset2D(actButton.assetID);
if (toggle != null)
{
XmlEvent @event = XmlStage.GetEvent(strEvent);
EventMgr.startEvent(@event);
Image img = GetComponent <Image>();
img.sprite = toggle.PicNormal;
}
}
public void OnButtonClick(BaseEventData arg0)
{
XmlPic2D toggle = XmlStage.GetAsset2D(actButton.assetID);
if (toggle != null)
{
Image img = GetComponent <Image>();
img.sprite = toggle.PicNormal;
}
XmlEvent @event = XmlStage.GetEvent(strEvent);
EventMgr.startEvent(@event);
}
private static void CreateEventButton_eventClicked(UIComponent component, UIMouseEventParameter eventParam)
{
UIFastList eventSelection = component.parent.Find <UIFastList>("EventSelectionList");
ushort buildingID = lastInstanceID.Value.Building;
if (lastInstanceID != null && buildingID != 0)
{
BuildingManager _buildingManager = Singleton <BuildingManager> .instance;
Building _currentBuilding = _buildingManager.m_buildings.m_buffer[buildingID];
if ((_currentBuilding.m_flags & Building.Flags.Active) != Building.Flags.None)
{
List <CityEvent> userEvents = CityEventBuildings.instance.GetUserEventsForBuilding(ref _currentBuilding);
BuildDropdownList(component);
if (eventSelection.isVisible)
{
eventSelection.Hide();
}
else
{
eventSelection.selectedIndex = -1;
eventSelection.Show();
eventSelection.rowsData.Clear();
foreach (CityEvent userEvent in userEvents)
{
XmlEvent xmlUserEvent = userEvent as XmlEvent;
if (xmlUserEvent != null)
{
xmlUserEvent.SetUp(ref buildingID);
LabelOptionItem eventToInsert = new LabelOptionItem()
{
linkedEvent = xmlUserEvent, readableLabel = xmlUserEvent.GetReadableName()
};
eventSelection.rowsData.Add(eventToInsert);
LoggingWrapper.Log(xmlUserEvent.GetReadableName());
}
}
eventSelection.DisplayAt(0);
}
}
}
}
public void SetEvent(_run_event act)
{
actRun = act;
theEvent = XmlStage.GetEvent(actRun.eventID);
if (theEvent != null)
{
theEvent.Start();
}
else
{
Debug.Log("Event NULL");
}
}
public void SetEvent(XmlEvent evt)
{
actRun = null;
theEvent = evt;// AppMgr.getEvent(actRun.eventID);
if (theEvent != null)
{
theEvent.Start();
}
else
{
Debug.Log("Event NULL");
}
}
public static void RunEvent(IXmlItem comp, String evtType)
{
if (comp.Interface.Events.Keys.Contains(evtType) == false)
{
return;
}
XmlEvent evt = comp.Interface.Events[evtType];
for (int i = 0; i < evt.Actions.Count; i++)
{
XmlActionList actionList = evt.Actions[i];
if (actionList.Condition.GetCondition() && (actionList.ComCondition == null || actionList.ComCondition.GetCondition())) //condition이 true일 때..
{
for (int a = 0; a < actionList.Count; a++)
{
XmlAction action = actionList[a];
string funcName = action.Name;
if (GlobalVars.Funcs.Keys.Contains(funcName))
{
object[] args;
args = comp.Interface.GetRealTimeArgs(action.Args);
if (comp is Control)
{
Control control = comp as Control;
if (control.InvokeRequired)
{
GlobalVars.Funcs[funcName](comp, args);
}
else
{
GlobalVars.Funcs[funcName].Invoke(comp, args);
}
}
else
{
GlobalVars.Funcs[funcName](comp, args);
}
}
}
}
}
}
/// <summary>
/// Decodes and routes an event.
/// </summary>
/// <param name="element">The element.</param>
protected void DecodeAndRouteEvent(XElement element)
{
if (element.Name == XName.Get("json"))
{
try
{
var eventTypeElement = element.Element("type");
if (eventTypeElement == null)
{
return;
}
var eventDataElement = element.Element("data");
if (eventDataElement == null)
{
return;
}
var eventType = eventTypeElement
.Nodes()
.OfType <XCData>()
.FirstOrDefault()
.Value;
var eventData = eventDataElement
.Nodes()
.OfType <XCData>()
.FirstOrDefault()
.Value;
var eventBytes = System.Text.Encoding.UTF8.GetBytes(eventData);
var dictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
eventBytes, 0, eventBytes.Length, new XmlDictionaryReaderQuotas());
var fabricator = SchemaFabricator;
if (fabricator != null)
{
var fabricatorType = fabricator.GetType(eventType);
if (fabricatorType != null)
{
if (DataEvent != null)
{
var serializer = new DataContractJsonSerializer(fabricatorType);
var trueEntity = serializer.ReadObject(dictionaryReader);
DataEvent.Invoke(trueEntity);
}
return;
}
}
if (XmlEvent != null)
{
var dictionaryDocument = XDocument.Load(dictionaryReader);
dictionaryDocument.Root.Name = eventType;
XmlEvent.Invoke(dictionaryDocument.Root);
}
}
catch (EPException e)
{
}
}
else if (element.Name == XName.Get("xml"))
{
if (XmlEvent != null)
{
XmlEvent.Invoke(element.Elements().FirstOrDefault());
}
}
else if (element.Name == XName.Get("map"))
{
DictionaryEvent(
element.Attribute("name").Value,
element.Elements().FirstOrDefault().ToDictionary());
}
else
{
throw new ArgumentException(string.Format("Content type \"{0}\" is not recognized", element.Name));
}
}
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);
}
}
public static void startEvent(string evtName)
{
XmlEvent evt = XmlStage.GetEvent(evtName);
startEvent(evt);
}
