void ColorChanged(EventInfo eventInfo)
{
ColorEventInfo info = (ColorEventInfo)eventInfo;
currentColor = info.newColor;
SetCurrentMaterials();
}
protected override IEnumerator<object> OnPreferencesChanged(EventInfo evt, string[] prefNames)
{
string prefsJson = null;
yield return Preferences.GetAllJson().Bind(() => prefsJson);
yield return CallFunction("weaponhelper", "notifyPrefsChanged", prefsJson);
}
public void EventReceivedHandler(object sender, EventInfo eventInfo)
{
if (eventInfo.Type == EventInfo.EventTypes.TAG_REPORT)
{
var tagid = eventInfo.GetParameter(EventInfo.EventTagReportParams.TagId);
var antenna = eventInfo.GetParameter(EventInfo.EventTagReportParams.Antenna);
var time = eventInfo.GetParameter(EventInfo.EventTagReportParams.Time);
var phase = eventInfo.GetParameter(EventInfo.EventTagReportParams.Phase);
var frequency = eventInfo.GetParameter(EventInfo.EventTagReportParams.Frequency);
var rssi = eventInfo.GetParameter(EventInfo.EventTagReportParams.Rssi);
var phaseAngle = _phaseUtils.PhaseAngle(phase);
if (tagid != null)
{
var reading = new Reading
{
TagId = tagid,
Antenna = antenna,
PhaseAngle = phaseAngle,
Frequency = frequency,
Rssi = rssi,
Time = time
};
//Console.WriteLine(reading);
Readings.Add(reading);
}
}
}
public override EventInfo[] __GetDeclaredEvents()
{
foreach (int i in module.EventMap.Filter(this.MetadataToken))
{
int evt = module.EventMap.records[i].EventList - 1;
int end = module.EventMap.records.Length > i + 1 ? module.EventMap.records[i + 1].EventList - 1 : module.Event.records.Length;
EventInfo[] events = new EventInfo[end - evt];
if (module.EventPtr.RowCount == 0)
{
for (int j = 0; evt < end; evt++, j++)
{
events[j] = new EventInfoImpl(module, this, evt);
}
}
else
{
for (int j = 0; evt < end; evt++, j++)
{
events[j] = new EventInfoImpl(module, this, module.EventPtr.records[evt] - 1);
}
}
return events;
}
return Empty<EventInfo>.Array;
}
public override EventInfo[] __GetDeclaredEvents()
{
int token = this.MetadataToken;
// TODO use binary search?
for (int i = 0; i < module.EventMap.records.Length; i++)
{
if (module.EventMap.records[i].Parent == token)
{
int evt = module.EventMap.records[i].EventList - 1;
int end = module.EventMap.records.Length > i + 1 ? module.EventMap.records[i + 1].EventList - 1 : module.Event.records.Length;
EventInfo[] events = new EventInfo[end - evt];
if (module.EventPtr.RowCount == 0)
{
for (int j = 0; evt < end; evt++, j++)
{
events[j] = new EventInfoImpl(module, this, evt);
}
}
else
{
for (int j = 0; evt < end; evt++, j++)
{
events[j] = new EventInfoImpl(module, this, module.EventPtr.records[evt] - 1);
}
}
return events;
}
}
return Empty<EventInfo>.Array;
}
private void BroadcastStateChange(EventInfo eventInfo)
{
Debug.Log ("Broadcasting state change.");
foreach (ScreenController screenController in screenControllers) {
screenController.MatchStateChanged (eventInfo);
}
}
protected override IEnumerator<object> OnPreferencesChanged(EventInfo evt, string[] prefNames)
{
long fontScale = 100, fontWidth = 100;
yield return Preferences.Get<long>("FontScale").Bind(() => fontScale);
yield return Preferences.Get<long>("FontWidth").Bind(() => fontWidth);
yield return CallFunction("fontsizer", "setFontSize", fontScale / 100.0f, fontWidth / 100.0f);
}
public void PlayerDied(EventInfo eventInfo)
{
PlayerController playerController = ((PlayerSpawnedEventInfo)eventInfo).player;
switch (playerController.Id)
{
case 1: target1 = null; break;
case 2: target2 = null; break;
}
}
/// <summary>
/// Creates an event handler for the specified event
/// </summary>
/// <param Name="Info">The event info class of the event</param>
/// <returns>The created event handler help class.</returns>
public object GetEventHandler(EventInfo Info)
{
Type eventHandlerType = emitter.GetEventHandlerType(Info);
// Call constructor of event handler type to create event handler
ConstructorInfo myCtor = eventHandlerType.GetConstructor(new Type[] { typeof(EventInfo) });
object[] ctorArgs = new object[] { Info };
object eventHandler = myCtor.Invoke(ctorArgs);
return eventHandler;
}
//Test function
void ColorChanged(EventInfo eventInfo)
{
switch (((ColorEventInfo)eventInfo).newColor)
{
case ChromaColor.RED: RenderSettings.skybox.SetColor("_Tint", Color.red); break;
case ChromaColor.GREEN: RenderSettings.skybox.SetColor("_Tint", Color.green); break;
case ChromaColor.BLUE: RenderSettings.skybox.SetColor("_Tint", Color.blue); break;
case ChromaColor.YELLOW: RenderSettings.skybox.SetColor("_Tint", Color.yellow); break;
}
}
// ReSharper disable InconsistentNaming
public void TaskSheduler_ResourceHistory_ShouldConstructCorrectly()
// ReSharper restore InconsistentNaming
{
var a = new List<IDebugState>();
var b = new EventInfo(new DateTime(2001, 01, 01), new TimeSpan(1, 0, 0), new DateTime(2001, 01, 01), ScheduleRunStatus.Error, "sdf");
var res = new ResourceHistory("output", a, b, "bob");
Assert.AreEqual(a, res.DebugOutput);
Assert.AreEqual(b, res.TaskHistoryOutput);
Assert.AreEqual("bob", res.UserName);
}
/// <summary>
/// Emits dynamically a event handler with a given signature, which fills all arguments of the event in an object array
/// and calls a common event.
/// </summary>
/// <returns></returns>
public Type GetEventHandlerType(EventInfo Info)
{
string handlerName = assemblyName + Info.Name;
Type tpEventHandler = (Type)handlerTypes[handlerName];
if (tpEventHandler == null)
{
// Create the type
tpEventHandler = EmitHelperClass(handlerName, Info);
handlerTypes.Add(handlerName, tpEventHandler);
}
return tpEventHandler;
}
public void TestMethod1()
{
EventInfo eventinfo = new EventInfo();
eventinfo.Name = "1";
eventinfo.Root = "helo";
eventinfo.Description = "helloo";
eventinfo.Save();
eventinfo = EventInfo.Load(1);
eventinfo.DeleteOnSave();
}
public static string ArrayToCommaList(EventInfo[] ArrayToConvert)
{
string returnString = "";
if (ArrayToConvert.Length > 0)
{
returnString = ArrayToConvert[0].ToString();
for (int i = 1; i < ArrayToConvert.Length; i++)
{
returnString += ", " + ArrayToConvert[i].ToString();
}
}
return returnString;
}
public void TaskSheduler_EventInfo_ShouldconstructCorrectly()
{
EventInfo ie = new EventInfo(new DateTime(2000, 1, 1), TimeSpan.MaxValue, new DateTime(2001, 1, 1),ScheduleRunStatus.Error,
"12345");
Assert.AreEqual(new DateTime(2000, 1, 1), ie.StartDate);
Assert.AreEqual(new DateTime(2001, 1, 1), ie.EndDate);
Assert.AreEqual(TimeSpan.MaxValue, ie.Duration);
Assert.AreEqual(ScheduleRunStatus.Error, ie.Success);
Assert.AreEqual("12345", ie.EventId);
}
public STElementInfo(JSONNode stJson)
{
string spriteName = stJson["sprite"];
m_alwaysSeen = stJson["doShow"].AsBool;
JSONNode color = stJson["color"];
Color col = Color.white;
if(color != null) {
col = new Color(color["r"].AsFloat, color["g"].AsFloat, color["b"].AsFloat);
}
m_spriteName = spriteName;
m_spriteColor = col;
m_eventInfo = new EventInfo(stJson);
}
public void LoadEventInfo(MobManager mobManager, Storytrack storyTrack, EventInfo info)
{
ClearMobs();
m_st = storyTrack;
m_info = info;
foreach(string mobName in m_info.mobs) {
MobInfo mobInfo = mobManager.GetMobByName(mobName);
Mob mob = CreateMob(mobInfo, transform.position);
if(mob == null) continue;
m_mobs.Add(mob);
}
MoveMobsToSpawns();
}
private Delegate GetEventHandler(EventInfo ei, Type eaType, string fieldToAssign)
{
ParameterExpression senderParam = Expression.Parameter(typeof(object), "sender");
ParameterExpression eventArgsParam = Expression.Parameter(eaType, "e");
Delegate handler = Expression.Lambda(ei.EventHandlerType,
Expression.Assign(
Expression.Field(Expression.Constant(this), this.GetType().GetField(fieldToAssign)),
Expression.Property(eventArgsParam, eaType.GetProperty("Value").GetGetMethod())
),
senderParam,
eventArgsParam
).Compile();
return handler;
}
public void AddEventHandler_RemoveEventHandler(EventInfo eventInfo, EI_Class target, Delegate handler, int expectedStaticVariable)
{
// Add and make sure we bound the event.
eventInfo.AddEventHandler(target, handler);
target?.InvokeAllEvents();
EI_Class.InvokeStaticEvent();
Assert.Equal(expectedStaticVariable, EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable);
EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable = 0; // Reset
// Remove and make sure we unbound the event.
eventInfo.RemoveEventHandler(target, handler);
target?.InvokeAllEvents();
EI_Class.InvokeStaticEvent();
Assert.Equal(0, EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable);
}
private void AddEventInfo_Click(object sender, RoutedEventArgs e)
{
EventInfo p = new EventInfo();
if (p.ShowDialog().Value)
{
Event AddEvent = new Event();
AddEvent.EventName = p.EName.Text;
AddEvent.EventCost = Decimal.Parse(p.ECost.Text);
AddEvent.UserID = userId;
infoContext.Events.AddObject(AddEvent);
saveMeToDataBase();
fetchUserData(infoContext);
}
}
private IEnumerable<IEventInfo> GetEventInfosBase(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
{
var dateRange = hierarchicalItem.SourceItem as IDateRange;
var roundedRange = state.Rounder.Round(dateRange);
var taskRange = new Range<long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);
if (taskRange.IntersectsWith(state.VisibleTimeRange))
{
var eventInfo = new EventInfo(taskRange, index, 1, new Range<int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
{
OriginalEvent = hierarchicalItem.SourceItem
};
yield return eventInfo;
}
}
static Delegate GetHandler(Type componentType, EventInfo eventInfo)
{
var handlerType = eventInfo.EventHandlerType;
var eventName = eventInfo.Name;
var key = new EventKey(componentType, handlerType, eventName);
var handler = (Delegate)null;
if (!_eventHandlers.TryGetValue(key, out handler))
{
var parameters = handlerType.GetMethod("Invoke")
.GetParameters()
.Select(p => Expression.Parameter(p.ParameterType, p.Name))
.ToArray();
var formatStringBuilder = new StringBuilder();
formatStringBuilder.AppendFormat(
"<b>{0}[</b><color=navy>{{0}}</color><b>]</b>.<color=purple>{1}</color>",
componentType.Name, eventName);
if (parameters.Length > 0)
{
formatStringBuilder.Append(": ");
}
for (int i = 0; i < parameters.Length; ++i)
{
formatStringBuilder.AppendFormat(
"[<color=blue>{0} = {{{1}}}</color>] ",
parameters[i].Name, i + 1);
}
var method = typeof(EventLogger).GetMethod("LogFormat",
BindingFlags.Public | BindingFlags.Static,
null,
new[] { typeof(string), typeof(string), typeof(object[]) },
null);
var nameArg = Expression.Parameter(typeof(string), "gameObjectName");
var lambda = Expression.Lambda(
Expression.Lambda(handlerType,
Expression.Call(method,
Expression.Constant(formatStringBuilder.ToString()),
nameArg,
Expression.NewArrayInit(typeof(object),
parameters.Select(p =>
Expression.Convert(p, typeof(object))).ToArray())),
parameters),
nameArg);
handler = lambda.Compile();
_eventHandlers[key] = handler;
}
return handler;
}
public void PlayerSpawned(EventInfo eventInfo)
{
PlayerController playerController = ((PlayerSpawnedEventInfo)eventInfo).player;
switch(playerController.Id)
{
case 1:
target1 = playerController.transform;
player1 = playerController;
break;
case 2:
target2 = playerController.transform;
player2 = playerController;
break;
}
}
void NetworkWorker()
{
while (true) {
try {
string address = config.address;
int port = config.port;
TcpClient tcpClient = new TcpClient (address, port);
tcpClient.ReceiveTimeout = 5 * 60 * 1000;
Stream networkStream = tcpClient.GetStream();
BinaryReader reader = new BinaryReader(networkStream);
Debug.Log ("Connected to overlord.");
while (true) {
Debug.Log("Waiting for message...");
byte[] eventBytes = reader.ReadBytes(4);
byte[] matchIdBytes = reader.ReadBytes(4);
if (BitConverter.IsLittleEndian) {
Array.Reverse (eventBytes);
Array.Reverse (matchIdBytes);
}
EventType eventType = (EventType)BitConverter.ToInt32 (eventBytes, 0);
if (eventType == EventType.Ping) {
Debug.Log ("Received ping.");
} else {
int matchId = BitConverter.ToInt32 (matchIdBytes, 0);
Debug.Log ("Received message: " + eventType + " " + matchId);
EventInfo eventInfo = new EventInfo(eventType, matchId);
OnMessageReceived(eventInfo);
}
}
} catch (Exception ex) {
Debug.Log ("Network exception: " + ex);
} finally {
Thread.Sleep (5000);
}
}
}
void PlayerSpawned(EventInfo eventInfo)
{
PlayerController player = ((PlayerSpawnedEventInfo)eventInfo).player;
switch(player.Id)
{
case 1:
player1 = player;
player1HealthTxt.enabled = true;
player1EnergyTxt.enabled = true;
break;
case 2:
player2 = player;
player2HealthTxt.enabled = true;
player2EnergyTxt.enabled = true;
break;
}
}
public void MatchStateChanged(EventInfo eventInfo)
{
EventType receivedEventType = eventInfo.eventType;
if (gameObject.activeInHierarchy && receivedEventType != eventType) {
if (deactivationEffect != null)
{
deactivationEffect.EnqueueToScheduler();
}
OnDeactivation ();
} else if (!gameObject.activeInHierarchy && receivedEventType == eventType) {
this.eventInfo = eventInfo;
if (activationEffect != null)
{
activationEffect.EnqueueToScheduler();
}
OnActivation ();
}
}
public void Count()
{
int count = 0;
var scheduler = EventScheduler.New(LogFile.Console);
scheduler.Start();
var info = new EventInfo
{
NextShot = DateTime.UtcNow + 20.Milliseconds(),
RepeatAfter = 1.Milliseconds(),
Count = 2
};
scheduler.Schedule(info, () => count++);
Assert.That(() => count, Is.EqualTo(2).After(200));
scheduler.Stop();
}
public void InitializeInn(EventInfo info)
{
characters.Clear();
chars = level.characterManager;
m_info = info;
foreach(string name in m_info.mobs) {
CharacterInfo c = chars.GetCharacterByName(name);
if(c != null) {
Debug.Log("Found character named: " + name);
characters.Add(c);
}
}
for(int i = 0; i < 3; i++) {
slots[i].ToggleSlot(false);
}
for(int i = 0; i < characters.Count && i < 3; i++) {
slots[i].InitializeSlot(characters[i]);
}
}
private void ZonePlanFinished(EventInfo eventInfo)
{
ZonePlanEndedInfo info = (ZonePlanEndedInfo)eventInfo;
switch (info.planId)
{
//open door 01
case 101:
wallZone01.SetActive(false);
break;
case 102:
wallZone02.SetActive(false);
wallZone03.SetActive(false);
break;
case 103:
break;
}
}
void ColorChanged(EventInfo eventInfo)
{
ColorChangedEventInfo info = (ColorChangedEventInfo)eventInfo;
switch (info.newColor)
{
case ChromaColor.RED:
thisRenderer.material = colorRed;
break;
case ChromaColor.GREEN:
thisRenderer.material = colorGreen;
break;
case ChromaColor.BLUE:
thisRenderer.material = colorBlue;
break;
case ChromaColor.YELLOW:
thisRenderer.material = colorYellow;
break;
}
}
public ICollection GetCompatibleMethods(EventInfo edesc)
{
return(new object[] {});
}
public static Task <object[]> FromEvent <T>(this T obj, string eventName)
{
var tcs = new TaskCompletionSource <object[]>();
var tcsh = new TaskCompletionSourceHolder(tcs);
EventInfo eventInfo = obj.GetType().GetEvent(eventName);
Type eventDelegateType = eventInfo.EventHandlerType;
DynamicMethod handler;
if (!s_emittedHandlers.TryGetValue(eventDelegateType, out handler))
{
Type returnType;
List <Type> parameterTypes;
GetDelegateParameterAndReturnTypes(eventDelegateType,
out parameterTypes, out returnType);
if (returnType != typeof(void))
{
throw new NotSupportedException();
}
Type tcshType = tcsh.GetType();
MethodInfo setResultMethodInfo = tcshType.GetMethod(
"SetResult", BindingFlags.NonPublic | BindingFlags.Instance);
// I'm going to create an instance-like method
// so, first argument must an instance itself
// i.e. TaskCompletionSourceHolder *this*
parameterTypes.Insert(0, tcshType);
Type[] parameterTypesAr = parameterTypes.ToArray();
handler = new DynamicMethod("unnamed",
returnType, parameterTypesAr, tcshType);
ILGenerator ilgen = handler.GetILGenerator();
// declare local variable of type object[]
LocalBuilder arr = ilgen.DeclareLocal(typeof(object[]));
// push array's size onto the stack
ilgen.Emit(OpCodes.Ldc_I4, parameterTypesAr.Length - 1);
// create an object array of the given size
ilgen.Emit(OpCodes.Newarr, typeof(object));
// and store it in the local variable
ilgen.Emit(OpCodes.Stloc, arr);
// iterate thru all arguments except the zero one (i.e. *this*)
// and store them to the array
for (int i = 1; i < parameterTypesAr.Length; i++)
{
// push the array onto the stack
ilgen.Emit(OpCodes.Ldloc, arr);
// push the argument's index onto the stack
ilgen.Emit(OpCodes.Ldc_I4, i - 1);
// push the argument onto the stack
ilgen.Emit(OpCodes.Ldarg, i);
// check if it is of a value type
// and perform boxing if necessary
if (parameterTypesAr[i].IsValueType)
{
ilgen.Emit(OpCodes.Box, parameterTypesAr[i]);
}
// store the value to the argument's array
ilgen.Emit(OpCodes.Stelem, typeof(object));
}
// load zero-argument (i.e. *this*) onto the stack
ilgen.Emit(OpCodes.Ldarg_0);
// load the array onto the stack
ilgen.Emit(OpCodes.Ldloc, arr);
// call this.SetResult(arr);
ilgen.Emit(OpCodes.Call, setResultMethodInfo);
// and return
ilgen.Emit(OpCodes.Ret);
s_emittedHandlers.Add(eventDelegateType, handler);
}
Delegate dEmitted = handler.CreateDelegate(eventDelegateType, tcsh);
tcsh.Target = obj;
tcsh.EventInfo = eventInfo;
tcsh.Delegate = dEmitted;
eventInfo.AddEventHandler(obj, dEmitted);
return(tcs.Task);
}
private void detachEventHandler(EventInfo @event, Delegate d, object realButton)
{
@event.GetRemoveMethod().Invoke(realButton, new object[] { d });
}
public void OnIncomplete(EventInfo info)
{
Fade(false);
}
private static IEnumerable <ReflectedClassDto> GetCustomEventHandlers(IService serviceInstance, EventInfo eventInfo)
{
var fi = GetEventField(serviceInstance, eventInfo);
if (fi != null)
{
var del = fi.GetValue(serviceInstance) as Delegate;
if (del != null)
{
return(del.GetInvocationList()
.Where(x => !x.Method.DeclaringType.FullName.ToLower().StartsWith("umbraco."))
.Select(x => new ReflectedClassDto
{
Name = x.Method.Name,
Namespace = x.Method.DeclaringType.FullName,
}));
}
}
return(null);
}
public void Events(SuspendPolicy suspend_policy, EventInfo[] events)
{
var l = new List <Event> ();
for (int i = 0; i < events.Length; ++i)
{
EventInfo ei = events [i];
int req_id = ei.ReqId;
long thread_id = ei.ThreadId;
long id = ei.Id;
long loc = ei.Location;
switch (ei.EventType)
{
case EventType.VMStart:
vm.notify_vm_event(EventType.VMStart, suspend_policy, req_id, thread_id, null);
break;
case EventType.VMDeath:
vm.notify_vm_event(EventType.VMDeath, suspend_policy, req_id, thread_id, null);
break;
case EventType.ThreadStart:
l.Add(new ThreadStartEvent(vm, req_id, id));
break;
case EventType.ThreadDeath:
l.Add(new ThreadDeathEvent(vm, req_id, id));
break;
case EventType.AssemblyLoad:
l.Add(new AssemblyLoadEvent(vm, req_id, thread_id, id));
break;
case EventType.AssemblyUnload:
l.Add(new AssemblyUnloadEvent(vm, req_id, thread_id, id));
break;
case EventType.TypeLoad:
l.Add(new TypeLoadEvent(vm, req_id, thread_id, id));
break;
case EventType.MethodEntry:
l.Add(new MethodEntryEvent(vm, req_id, thread_id, id));
break;
case EventType.MethodExit:
l.Add(new MethodExitEvent(vm, req_id, thread_id, id));
break;
case EventType.Breakpoint:
l.Add(new BreakpointEvent(vm, req_id, thread_id, id, loc));
break;
case EventType.Step:
l.Add(new StepEvent(vm, req_id, thread_id, id, loc));
break;
case EventType.Exception:
l.Add(new ExceptionEvent(vm, req_id, thread_id, id, loc));
break;
case EventType.AppDomainCreate:
l.Add(new AppDomainCreateEvent(vm, req_id, thread_id, id));
break;
case EventType.AppDomainUnload:
l.Add(new AppDomainUnloadEvent(vm, req_id, thread_id, id));
break;
case EventType.UserBreak:
l.Add(new UserBreakEvent(vm, req_id, thread_id));
break;
case EventType.UserLog:
l.Add(new UserLogEvent(vm, req_id, thread_id, ei.Level, ei.Category, ei.Message));
break;
default:
break;
}
}
if (l.Count > 0)
{
vm.queue_event_set(new EventSet(vm, suspend_policy, l.ToArray()));
}
}
public EventObject(EventInfo info)
{
this.name = info.Name;
this.info = info;
}
protected string ProcessAttributes(XmlNode node, object ret, Type t)
{
string refName = String.Empty;
// process attributes
foreach (XmlAttribute attr in node.Attributes)
{
string pname = attr.Name;
string pvalue = attr.Value;
// it's either a property or an event. Allow assignment to protected / private properties.
PropertyInfo pi = t.GetProperty(pname, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
EventInfo ei = t.GetEvent(pname);
if (pi != null)
{
// it's a property!
if (pvalue.StartsWith("{") && pvalue.EndsWith("}"))
{
// And the value is a reference to an instance!
// Get the referenced object. Late binding is not supported!
OnAssignReference(pi, StringHelpers.Between(pvalue, '{', '}'), ret);
}
else
{
// it's string, so use a type converter.
if (pi.PropertyType.FullName == "System.Object")
{
OnAssignProperty(pi, ret, pvalue, pvalue);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(pi.PropertyType);
if (tc.CanConvertFrom(typeof(string)))
{
object val = tc.ConvertFrom(pvalue);
try
{
OnAssignProperty(pi, ret, val, pvalue);
}
catch (Exception e)
{
Trace.Fail("Property setter for " + pname + " failed:\r\n" + e.Message);
}
}
else
{
if (!OnCustomAssignProperty(pi, ret, pvalue))
{
Trace.Fail("Property setter for " + pname + " cannot be converted to property type " + pi.PropertyType.FullName + ".");
}
}
}
}
// auto-add to our object collection
if ((pname == "Name") || (pname == "def:Name"))
{
refName = pvalue;
// AddInstance(pvalue, ret);
}
}
else if (ei != null)
{
// it's an event!
string src = pvalue;
string methodName = String.Empty;
object sink = eventSink;
if ((StringHelpers.BeginsWith(src, '{')) && (StringHelpers.EndsWith(src, '}')))
{
src = StringHelpers.Between(src, '{', '}');
}
if (src.IndexOf('.') != -1)
{
string[] handler = src.Split('.');
src = handler[0];
methodName = handler[1];
sink = GetInstance(src);
}
else
{
methodName = src;
}
OnAssignEvent(ei, ret, sink, src, methodName);
}
else
{
// auto-add to our object collection
if ((pname == "Name") || (pname == "def:Name"))
{
refName = pvalue;
// AddInstance(pvalue, ret);
}
else if (pname == "ref:Name")
{
// Do nothing.
}
else
{
if (!OnUnknownProperty(pname, ret, pvalue))
{
// who knows what it is???
Trace.Fail("Failed acquiring property information for '" + pname + "' with value '" + pvalue + "'");
}
}
}
}
return(refName);
}
/// <summary>
/// Initializes a new instance of the <see cref="AvaloniaEventHandlerItem"/> class
/// with the specified element name, element, event name, routed event, event information,
/// event handler, and a value that indicates whether to register the handler such that
/// it is invoked even when the event is marked handled in its event data.
/// </summary>
/// <param name="elementName">The name of the element that raises the event.</param>
/// <param name="element">The element that raises the event.</param>
/// <param name="eventName">The name of the event.</param>
/// <param name="routedEvent">The routed event that is raised.</param>
/// <param name="eventInfo">The information of the event that is raised</param>
/// <param name="handler">The handler of the event.</param>
/// <param name="handledEventsToo">
/// <c>true</c> to register the handler such that it is invoked even when the
/// event is marked handled in its event data; <c>false</c> to register the
/// handler with the default condition that it will not be invoked if the event
/// is already marked handled.
/// </param>
public AvaloniaEventHandlerItem(string elementName, StyledElement element, string eventName, RoutedEvent routedEvent, EventInfo eventInfo, Delegate handler, bool handledEventsToo) : base(elementName, element, eventName, handler, handledEventsToo)
{
this.routedEvent = routedEvent;
this.eventInfo = eventInfo;
}
/// <summary>
/// Erstellt Drähte zwischen Client- und Server-Komponente (wenn im Korrelationssatz angegeben).
/// </summary>
/// <param name="type">Implementierungstyp der Server-Komponente</param>
/// <param name="instance">Instanz der Serverkomponente</param>
/// <param name="delegateCorrelationSet">Korrelationssatz mit Verdrahtungsinformationen</param>
/// <param name="wiringList">Auflistung mit gespeicherten Verdrahtungen</param>
private void CreateClientServerWires(Type type, object instance, List <DelegateCorrelationInfo> delegateCorrelationSet, Dictionary <Guid, Delegate> wiringList)
{
// Wenn kein Korrelationssatz angegeben wurde ...
if (delegateCorrelationSet == null)
{
// Prozedur abbrechen
return;
}
// Alle Einträge des Korrelationssatzes durchlaufen
foreach (DelegateCorrelationInfo correlationInfo in delegateCorrelationSet)
{
// Wenn mit diesem Korrelationsschlüssel schon verdrahtet wurde ...
if (wiringList.ContainsKey(correlationInfo.CorrelationID))
{
// Mit dem nächsten Eintrag weitermachen
continue;
}
// Dynamischen Draht erzeugen
object dynamicWire = DynamicWireFactory.Instance.CreateDynamicWire(type, correlationInfo.DelegateMemberName, correlationInfo.IsEvent);
// Typ des dynamischen Drahtes ermitteln
Type dynamicWireType = dynamicWire.GetType();
// Dynamischen Draht mit Client-Fernsteuerung verdrahten
dynamicWireType.GetProperty("Interceptor").SetValue(dynamicWire, correlationInfo.ClientDelegateInterceptor, null);
// wenn es sich um ein Ereignis handelt ...
if (correlationInfo.IsEvent)
{
// Metadaten des Ereignisses abufen
EventInfo eventInfo = type.GetEvent(correlationInfo.DelegateMemberName);
// Zusatzinformationen übergeben
dynamicWireType.GetProperty("ServerEventInfo").SetValue(dynamicWire, eventInfo, null);
dynamicWireType.GetProperty("Component").SetValue(dynamicWire, instance, null);
// Delegat zu dynamischem Draht erzeugen
Delegate dynamicWireDelegate = Delegate.CreateDelegate(eventInfo.EventHandlerType, dynamicWire, dynamicWireType.GetMethod("In"));
// Ausgehende Nachrichten mit passender Abfangvorrichtung verdrahten
eventInfo.AddEventHandler(instance, dynamicWireDelegate);
// Verdrahtung speichern
wiringList.Add(correlationInfo.CorrelationID, dynamicWireDelegate);
}
else
{
// Metadaten des aktuellen Ausgabe-Pins abufen
PropertyInfo outputPinMetaData = type.GetProperty(correlationInfo.DelegateMemberName);
// Delegat zu dynamischem Draht erzeugen
Delegate dynamicWireDelegate = Delegate.CreateDelegate(outputPinMetaData.PropertyType, dynamicWire, dynamicWireType.GetMethod("In"));
// Ausgehende Nachrichten mit passender Abfangvorrichtung verdrahten
outputPinMetaData.SetValue(instance, dynamicWireDelegate, null);
// Verdrahtung speichern
wiringList.Add(correlationInfo.CorrelationID, dynamicWireDelegate);
}
}
}
private void detachEventHandler(EventInfo @event, Delegate d, object realButton)
{
@event.RemoveEventHandler(realButton, d);
}
public LuaCSFunction GetEventWrap(Type type, string eventName)
{
if (!methodsCache.ContainsKey(type))
{
methodsCache[type] = new Dictionary <string, LuaCSFunction>();
}
var methodsOfType = methodsCache[type];
if (!methodsOfType.ContainsKey(eventName))
{
{
EventInfo eventInfo = type.GetEvent(eventName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static);
if (eventInfo == null)
{
throw new Exception(type.Name + " has no event named: " + eventName);
}
int start_idx = 0;
MethodInfo add = eventInfo.GetAddMethod();
MethodInfo remove = eventInfo.GetRemoveMethod();
bool is_static = add != null ? add.IsStatic : remove.IsStatic;
if (!is_static)
{
start_idx = 1;
}
methodsOfType[eventName] = (L) =>
{
object obj = null;
if (!is_static)
{
obj = translator.GetObject(L, 1, type);
if (obj == null)
{
return(LuaAPI.luaL_error(L, "invalid #1, needed:" + type));
}
}
try
{
Delegate handlerDelegate = translator.CreateDelegateBridge(L, eventInfo.EventHandlerType, start_idx + 2);
if (handlerDelegate == null)
{
return(LuaAPI.luaL_error(L, "invalid #" + (start_idx + 2) + ", needed:" + eventInfo.EventHandlerType));
}
switch (LuaAPI.lua_tostring(L, start_idx + 1))
{
case "+":
if (add == null)
{
return(LuaAPI.luaL_error(L, "no add for event " + eventName));
}
add.Invoke(obj, new object[] { handlerDelegate });
break;
case "-":
if (remove == null)
{
return(LuaAPI.luaL_error(L, "no remove for event " + eventName));
}
remove.Invoke(obj, new object[] { handlerDelegate });
break;
default:
return(LuaAPI.luaL_error(L, "invalid #" + (start_idx + 1) + ", needed: '+' or '-'" + eventInfo.EventHandlerType));
}
}
catch (System.Exception e)
{
return(LuaAPI.luaL_error(L, "c# exception:" + e + ",stack:" + e.StackTrace));
}
return(0);
};
}
}
return(methodsOfType[eventName]);
}
public override void Read()
{
EventInfo.Read(_worldPacket);
MaxSize = _worldPacket.ReadUInt32();
}
public void MergeFrom(GymGetInfoResponse other)
{
if (other == null)
{
return;
}
if (other.gymStatusAndDefenders_ != null)
{
if (gymStatusAndDefenders_ == null)
{
gymStatusAndDefenders_ = new global::POGOProtos.Data.Gym.GymStatusAndDefenders();
}
GymStatusAndDefenders.MergeFrom(other.GymStatusAndDefenders);
}
if (other.Name.Length != 0)
{
Name = other.Name;
}
if (other.Url.Length != 0)
{
Url = other.Url;
}
if (other.Result != 0)
{
Result = other.Result;
}
if (other.Description.Length != 0)
{
Description = other.Description;
}
if (other.SecondaryUrl.Length != 0)
{
SecondaryUrl = other.SecondaryUrl;
}
if (other.awardedGymBadge_ != null)
{
if (awardedGymBadge_ == null)
{
awardedGymBadge_ = new global::POGOProtos.Data.Badge.AwardedGymBadge();
}
AwardedGymBadge.MergeFrom(other.AwardedGymBadge);
}
if (other.CheckinImageUrl.Length != 0)
{
CheckinImageUrl = other.CheckinImageUrl;
}
if (other.eventInfo_ != null)
{
if (eventInfo_ == null)
{
eventInfo_ = new global::POGOProtos.Data.Raid.EventInfo();
}
EventInfo.MergeFrom(other.EventInfo);
}
if (other.displayWeather_ != null)
{
if (displayWeather_ == null)
{
displayWeather_ = new global::POGOProtos.Map.Weather.DisplayWeather();
}
DisplayWeather.MergeFrom(other.DisplayWeather);
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
/// <summary>
/// Reads a <see cref="System.Reflection.MemberInfo"/>, including referenced objects.
/// </summary>
/// <param name="dataType">The <see cref="Duality.Serialization.DataType"/> of the object to read.</param>
/// <returns>The object that has been read.</returns>
protected MemberInfo ReadMemberInfo(DataType dataType)
{
uint objId = this.reader.ReadUInt32();
MemberInfo result = null;
try
{
#region Version 1
if (this.dataVersion <= 1)
{
if (dataType == DataType.Type)
{
string typeString = this.reader.ReadString();
Type type = this.ResolveType(typeString);
result = type;
}
else if (dataType == DataType.FieldInfo)
{
bool isStatic = this.reader.ReadBoolean();
string declaringTypeString = this.reader.ReadString();
string fieldName = this.reader.ReadString();
Type declaringType = this.ResolveType(declaringTypeString);
FieldInfo field = declaringType.GetField(fieldName, isStatic ? ReflectionHelper.BindStaticAll : ReflectionHelper.BindInstanceAll);
result = field;
}
else if (dataType == DataType.PropertyInfo)
{
bool isStatic = this.reader.ReadBoolean();
string declaringTypeString = this.reader.ReadString();
string propertyName = this.reader.ReadString();
string propertyTypeString = this.reader.ReadString();
int paramCount = this.reader.ReadInt32();
string[] paramTypeStrings = new string[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypeStrings[i] = this.reader.ReadString();
}
Type declaringType = this.ResolveType(declaringTypeString);
Type propertyType = this.ResolveType(propertyTypeString);
Type[] paramTypes = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypes[i] = this.ResolveType(paramTypeStrings[i]);
}
PropertyInfo property = declaringType.GetProperty(
propertyName,
isStatic ? ReflectionHelper.BindStaticAll : ReflectionHelper.BindInstanceAll,
null,
propertyType,
paramTypes,
null);
result = property;
}
else if (dataType == DataType.MethodInfo)
{
bool isStatic = this.reader.ReadBoolean();
string declaringTypeString = this.reader.ReadString();
string methodName = this.reader.ReadString();
int paramCount = this.reader.ReadInt32();
string[] paramTypeStrings = new string[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypeStrings[i] = this.reader.ReadString();
}
Type declaringType = this.ResolveType(declaringTypeString);
Type[] paramTypes = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypes[i] = this.ResolveType(paramTypeStrings[i]);
}
MethodInfo method = declaringType.GetMethod(methodName, isStatic ? ReflectionHelper.BindStaticAll : ReflectionHelper.BindInstanceAll, null, paramTypes, null);
result = method;
}
else if (dataType == DataType.ConstructorInfo)
{
bool isStatic = this.reader.ReadBoolean();
string declaringTypeString = this.reader.ReadString();
int paramCount = this.reader.ReadInt32();
string[] paramTypeStrings = new string[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypeStrings[i] = this.reader.ReadString();
}
Type declaringType = this.ResolveType(declaringTypeString);
Type[] paramTypes = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
{
paramTypes[i] = this.ResolveType(paramTypeStrings[i]);
}
ConstructorInfo method = declaringType.GetConstructor(isStatic ? ReflectionHelper.BindStaticAll : ReflectionHelper.BindInstanceAll, null, paramTypes, null);
result = method;
}
else if (dataType == DataType.EventInfo)
{
bool isStatic = this.reader.ReadBoolean();
string declaringTypeString = this.reader.ReadString();
string eventName = this.reader.ReadString();
Type declaringType = this.ResolveType(declaringTypeString);
EventInfo e = declaringType.GetEvent(eventName, isStatic ? ReflectionHelper.BindStaticAll : ReflectionHelper.BindInstanceAll);
result = e;
}
else
{
throw new ApplicationException(string.Format("Invalid DataType '{0}' in ReadMemberInfo method.", dataType));
}
}
#endregion
else if (this.dataVersion >= 2)
{
if (dataType == DataType.Type)
{
string typeString = this.reader.ReadString();
result = this.ResolveType(typeString, objId);
}
else
{
string memberString = this.reader.ReadString();
result = this.ResolveMember(memberString, objId);
}
}
}
catch (Exception e)
{
result = null;
this.SerializationLog.WriteError(
"An error occurred in deserializing MemberInfo object Id {0} of type '{1}': {2}",
objId,
Log.Type(dataType.ToActualType()),
Log.Exception(e));
}
// Prepare object reference
this.idManager.Inject(result, objId);
return(result);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void ProcessMouse()
{
// get current position and delta pos
Vector2 lastPointerPos = mouseState.currentPos;
mouseState.currentPos = Input.mousePosition;
Vector2 deltaPos = mouseState.currentPos - lastPointerPos;
// get current mouse button
exUIEvent.MouseButtonFlags lastButtons = mouseState.currentButtons;
exUIEvent.MouseButtonFlags buttonDown = exUIEvent.MouseButtonFlags.None;
exUIEvent.MouseButtonFlags buttonUp = exUIEvent.MouseButtonFlags.None;
// handle pressed
mouseState.currentButtons = exUIEvent.MouseButtonFlags.None;
if (Input.anyKey)
{
if (Input.GetMouseButton(0))
{
mouseState.currentButtons |= exUIEvent.MouseButtonFlags.Left;
}
if (Input.GetMouseButton(1))
{
mouseState.currentButtons |= exUIEvent.MouseButtonFlags.Right;
}
if (Input.GetMouseButton(2))
{
mouseState.currentButtons |= exUIEvent.MouseButtonFlags.Middle;
}
}
// handle press
if (Input.anyKeyDown)
{
if (Input.GetMouseButtonDown(0))
{
buttonDown = exUIEvent.MouseButtonFlags.Left;
}
else if (Input.GetMouseButtonDown(1))
{
buttonDown = exUIEvent.MouseButtonFlags.Right;
}
else if (Input.GetMouseButtonDown(2))
{
buttonDown = exUIEvent.MouseButtonFlags.Middle;
}
}
// handle release
if (lastButtons != mouseState.currentButtons)
{
if (Input.GetMouseButtonUp(0))
{
buttonUp = exUIEvent.MouseButtonFlags.Left;
}
else if (Input.GetMouseButtonUp(1))
{
buttonUp = exUIEvent.MouseButtonFlags.Right;
}
else if (Input.GetMouseButtonUp(2))
{
buttonUp = exUIEvent.MouseButtonFlags.Middle;
}
}
// get hot element
exUIElement lastHotElement = mouseState.hotElement;
mouseState.hotElement = PickElement(mouseState.currentPos);
// process hover event
if (lastHotElement != mouseState.hotElement)
{
// add hover-in event
if (mouseState.hotElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Mouse;
e.type = exUIEvent.Type.MouseEnter;
e.position = mouseState.currentPos;
e.delta = deltaPos;
e.buttons = mouseState.currentButtons;
EventInfo info = new EventInfo();
info.primaryElement = mouseState.hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
// add hover-out event
if (lastHotElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Mouse;
e.type = exUIEvent.Type.MouseExit;
e.position = mouseState.currentPos;
e.delta = deltaPos;
e.buttons = mouseState.currentButtons;
EventInfo info = new EventInfo();
info.primaryElement = lastHotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
}
// add pointer-move event
if ((mouseState.hotElement != null || mouseState.focusElement != null) && deltaPos != Vector2.zero)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Mouse;
e.type = exUIEvent.Type.MouseMove;
e.position = mouseState.currentPos;
e.delta = deltaPos;
e.buttons = mouseState.currentButtons;
EventInfo info = new EventInfo();
info.primaryElement = (mouseState.focusElement != null) ? mouseState.focusElement : mouseState.hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
// add pointer-press event
if (mouseState.hotElement != null && buttonDown != exUIEvent.MouseButtonFlags.None)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Mouse;
e.type = exUIEvent.Type.MouseDown;
e.position = mouseState.currentPos;
e.delta = deltaPos;
e.buttons = buttonDown;
EventInfo info = new EventInfo();
info.primaryElement = mouseState.hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
// add pointer-release event
if (mouseState.focusElement != null && buttonUp != exUIEvent.MouseButtonFlags.None)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Mouse;
e.type = exUIEvent.Type.MouseUp;
e.position = mouseState.currentPos;
e.delta = deltaPos;
e.buttons = buttonUp;
EventInfo info = new EventInfo();
info.primaryElement = mouseState.focusElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
}
void ReadObjectBaseTypeMembers(object obj, Type objectType, BindingFlags flags)
{
var numFields = Reader.ReadInt32();
for (var iField = 0; iField < numFields; iField++)
{
var fieldName = Reader.ReadString();
var fieldValue = Read();
if (objectType != null)
{
var fieldInfo = objectType.GetField(fieldName, flags);
if (fieldInfo != null && !fieldInfo.IsLiteral && (obj == null) == fieldInfo.IsStatic)
{
fieldInfo.SetValue(obj, fieldValue);
}
}
}
var numEvents = Reader.ReadInt32();
for (var iEvent = 0; iEvent < numEvents; iEvent++)
{
var eventName = Reader.ReadString();
if (Reader.ReadBoolean())
{
var delegateType = ReadType();
var functionCount = Reader.ReadInt32();
EventInfo eventInfo = objectType != null?objectType.GetEvent(eventName, flags) : null;
for (int i = 0; i < functionCount; i++)
{
var methodInfo = Read() as MethodInfo;
var target = Read();
Delegate parsedDelegate;
if (target != null)
{
parsedDelegate = Delegate.CreateDelegate(delegateType, target, methodInfo);
}
else
{
parsedDelegate = Delegate.CreateDelegate(delegateType, methodInfo);
}
if (eventInfo != null)
{
var addMethod = eventInfo.GetAddMethod(true);
addMethod.Invoke(obj, new[] { parsedDelegate });
}
}
}
}
if (objectType != null)
{
// Special case, always get native pointers for SWIG director types
var swigCPtr = objectType.GetField("swigCPtr", flags);
if (swigCPtr != null)
{
// Start with director handling, aka support for cross-language polymorphism
var swigDirectorConnect = objectType.GetMethod("SwigDirectorConnect", flags);
if (swigDirectorConnect != null)
{
var swigCMemOwn = objectType.GetField("swigCMemOwn", flags);
// Should not be null, if it is we need to check if something is wrong
var constructor = objectType.GetConstructor(Type.EmptyTypes);
var newObj = constructor.Invoke(null);
swigCMemOwn.SetValue(newObj, false);
swigCMemOwn.SetValue(obj, true);
var handleReference = new HandleRef(obj, ((HandleRef)swigCPtr.GetValue(newObj)).Handle);
swigCPtr.SetValue(obj, handleReference);
swigDirectorConnect.Invoke(obj, null);
}
else // Support for other types, such as Vec3 (where we should simply take ownership of the native pointer
{
var handleReference = new HandleRef(obj, ((HandleRef)swigCPtr.GetValue(obj)).Handle);
swigCPtr.SetValue(obj, handleReference);
}
}
}
}
public EmptyXamlMember(EventInfo eventInfo, XamlSchemaContext context)
: base(eventInfo, context)
{
}
public Event VisitEvent(EventInfo @event)
{
throw new NotImplementedException();
}
/// <summary> /// Determines whether this event is equal to the given event. /// </summary> /// <param name="other">Other event to compare.</param> /// <returns><see langword="true"/> if this object reflects the same event as the specified object; otherwise, <see langword="false"/>.</returns> public bool Equals(EventInfo other) => other is Event <D> @event ? this.@event == @event.@event : this.@event == other;
public void TestTeamCompetition()
{
var eventInfo = new EventInfo {
eventType = EventType.Team, roundInfos = TeamNormal()
};
var hillInfo = new HillInfo(123, 140, 5.5m, 6.66m, 4.2m, 0.79m);
const int competitorsCount = 5, competitorsCount2 = 3;
var orderedParticipants = GetMockParticipantsTeam(competitorsCount);
var resultsManager = new ResultsManager(eventInfo, orderedParticipants, hillInfo);
resultsManager.RoundInit();
resultsManager.SubroundInit();
// bibs 1st round
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Bibs[0]).ToList(),
Enumerable.Range(1, competitorsCount).Reverse().ToList()));
// 1st round 1st group
Assert.IsTrue(ListEqual(resultsManager.StartList,
Enumerable.Range(0, competitorsCount).Reverse().ToList()));
RegisterJumps(resultsManager, Enumerable.Repeat(123m, competitorsCount));
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount).Select(it => resultsManager.GetIdByRank(it)).ToList(),
Enumerable.Range(0, competitorsCount).ToList()));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
1, 1, 1, 1, 1
}));
resultsManager.SubroundFinish();
// 1st round 2nd group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList,
Enumerable.Range(0, competitorsCount).Reverse().ToList()));
RegisterJumps(resultsManager, new List <decimal> {
123, 124, 125, 124, 123
});
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
2, 1, 3, 0, 4
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
4, 2, 1, 2, 4
}));
resultsManager.SubroundFinish();
// 1st round 3rd group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList,
Enumerable.Range(0, competitorsCount).Reverse().ToList()));
RegisterJumps(resultsManager, new List <decimal> {
123, 124, 125, 126, 127
});
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount).Select(it => resultsManager.GetIdByRank(it)).ToList(),
Enumerable.Range(0, competitorsCount).ToList()));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
1, 1, 1, 4, 5
}));
resultsManager.SubroundFinish();
// start list 1st round 4th group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList,
Enumerable.Range(0, competitorsCount).Reverse().ToList()));
RegisterJumps(resultsManager, new List <decimal> {
130, 123, 123, 124, 124
});
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
4, 0, 1, 2, 3
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
2, 2, 4, 5, 1
}));
resultsManager.SubroundFinish();
resultsManager.RoundFinish();
resultsManager.RoundInit();
resultsManager.SubroundInit();
// bibs 2nd round
Assert.IsTrue(resultsManager.StartList.Select(it => resultsManager.Results[it])
.Any(it => it.Bibs[0] == it.Bibs[1]));
// 2nd round 1st group
Assert.IsTrue(ListEqual(resultsManager.StartList, new List <int> {
4, 1, 0
}));
RegisterJumps(resultsManager, Enumerable.Repeat(123m, competitorsCount2));
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount2).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
4, 0, 1
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
2, 2, 4, 5, 1
}));
resultsManager.SubroundFinish();
// 2nd round 2nd group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList, new List <int> {
4, 1, 0
}));
RegisterJumps(resultsManager, Enumerable.Repeat(123m, competitorsCount2));
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount2).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
4, 0, 1
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
2, 2, 4, 5, 1
}));
resultsManager.SubroundFinish();
// 2nd round 3rd group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList, new List <int> {
4, 1, 0
}));
RegisterJumps(resultsManager, new List <decimal> {
129, 131, 129
});
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount2).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
1, 4, 0
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
3, 1, 4, 5, 1
}));
resultsManager.SubroundFinish();
// 2nd round 4th group
resultsManager.SubroundInit();
Assert.IsTrue(ListEqual(resultsManager.StartList, new List <int> {
0, 4, 1
}));
RegisterJumps(resultsManager, new List <decimal> {
135, 131, 131
});
Assert.IsTrue(ListEqual(
Enumerable.Range(0, competitorsCount2).Select(it => resultsManager.GetIdByRank(it)).ToList(),
new List <int> {
0, 1, 4
}));
Assert.IsTrue(ListEqual(resultsManager.Results.Select(it => it.Rank).ToList(),
new List <int> {
1, 2, 4, 5, 2
}));
}
public Type EmitInterfaceImpl(Type to_be_impl)
{
if (!to_be_impl.IsInterface)
{
throw new InvalidOperationException("interface expected, but got " + to_be_impl);
}
if (!gen_interfaces.Contains(to_be_impl))
{
throw new InvalidCastException("This type must add to CSharpCallLua: " + to_be_impl);
}
TypeBuilder impl_type_builder = CodeEmitModule.DefineType("XLuaGenInterfaceImpl" + (genID++), TypeAttributes.Public | TypeAttributes.Class, typeof(LuaBase), new Type[] { to_be_impl });
foreach (var member in to_be_impl.GetMembers())
{
if (member.MemberType == MemberTypes.Method)
{
MethodInfo method = member as MethodInfo;
if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_") ||
method.Name.StartsWith("add_") || method.Name.StartsWith("remove_"))
{
continue;
}
var method_builder = defineImplementMethod(impl_type_builder, method,
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual);
genImpl(method, method_builder.GetILGenerator(), true);
}
else if (member.MemberType == MemberTypes.Property)
{
PropertyInfo property = member as PropertyInfo;
PropertyBuilder prop_builder = impl_type_builder.DefineProperty(property.Name, property.Attributes, property.PropertyType, Type.EmptyTypes);
if (property.Name == "Item")
{
if (property.CanRead)
{
var getter_buildler = defineImplementMethod(impl_type_builder, property.GetGetMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(getter_buildler.GetILGenerator(), property.PropertyType);
prop_builder.SetGetMethod(getter_buildler);
}
if (property.CanWrite)
{
var setter_buildler = defineImplementMethod(impl_type_builder, property.GetSetMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(setter_buildler.GetILGenerator(), property.PropertyType);
prop_builder.SetSetMethod(setter_buildler);
}
continue;
}
if (property.CanRead)
{
MethodBuilder getter_buildler = impl_type_builder.DefineMethod("get_" + property.Name,
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
property.PropertyType, Type.EmptyTypes);
ILGenerator il = getter_buildler.GetILGenerator();
LocalBuilder L = il.DeclareLocal(typeof(RealStatePtr));
LocalBuilder oldTop = il.DeclareLocal(typeof(int));
LocalBuilder translator = il.DeclareLocal(typeof(ObjectTranslator));
LocalBuilder ret = il.DeclareLocal(property.PropertyType);
// L = LuaBase.L;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_L_getter);
il.Emit(OpCodes.Stloc, L);
//oldTop = LuaAPI.lua_gettop(L);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Call, LuaAPI_lua_gettop);
il.Emit(OpCodes.Stloc, oldTop);
//translator = LuaBase.translator;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_translator_getter);
il.Emit(OpCodes.Stloc, translator);
//LuaAPI.lua_getref(L, luaReference);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaReference);
il.Emit(OpCodes.Call, LuaAPI_lua_getref);
//LuaAPI.lua_pushstring(L, "xxx");
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldstr, property.Name);
il.Emit(OpCodes.Call, LuaAPI_lua_pushstring);
//LuaAPI.xlua_pgettable(L, -2)
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-2);
il.Emit(OpCodes.Call, LuaAPI_xlua_pgettable);
Label gettable_no_exception = il.DefineLabel();
il.Emit(OpCodes.Brfalse, gettable_no_exception);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
il.Emit(OpCodes.Ldloc, oldTop);
il.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
il.MarkLabel(gettable_no_exception);
il.Emit(OpCodes.Ldloc, translator);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-1);
il.Emit(OpCodes.Ldtoken, property.PropertyType);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle); // typeof(type)
il.Emit(OpCodes.Callvirt, ObjectTranslator_GetObject);
if (property.PropertyType.IsValueType)
{
Label not_null = il.DefineLabel();
Label null_done = il.DefineLabel();
LocalBuilder local_new = il.DeclareLocal(property.PropertyType);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Brtrue_S, not_null);
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Ldloca, local_new);
il.Emit(OpCodes.Initobj, property.PropertyType);
il.Emit(OpCodes.Ldloc, local_new);
il.Emit(OpCodes.Br_S, null_done);
il.MarkLabel(not_null);
il.Emit(OpCodes.Unbox_Any, property.PropertyType);
il.MarkLabel(null_done);
}
else if (property.PropertyType != typeof(object))
{
il.Emit(OpCodes.Castclass, property.PropertyType);
}
il.Emit(OpCodes.Stloc, ret);
//LuaAPI.lua_pop(L, 2);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)2);
il.Emit(OpCodes.Call, LuaAPI_lua_pop);
il.Emit(OpCodes.Ldloc, ret);
il.Emit(OpCodes.Ret);
prop_builder.SetGetMethod(getter_buildler);
}
if (property.CanWrite)
{
MethodBuilder setter_builder = impl_type_builder.DefineMethod("set_" + property.Name,
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null, new Type[] { property.PropertyType });
ILGenerator il = setter_builder.GetILGenerator();
LocalBuilder L = il.DeclareLocal(typeof(RealStatePtr));
LocalBuilder oldTop = il.DeclareLocal(typeof(int));
LocalBuilder translator = il.DeclareLocal(typeof(ObjectTranslator));
// L = LuaBase.L;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_L_getter);
il.Emit(OpCodes.Stloc, L);
//oldTop = LuaAPI.lua_gettop(L);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Call, LuaAPI_lua_gettop);
il.Emit(OpCodes.Stloc, oldTop);
//translator = LuaBase.translator;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_translator_getter);
il.Emit(OpCodes.Stloc, translator);
//LuaAPI.lua_getref(L, luaReference);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaReference);
il.Emit(OpCodes.Call, LuaAPI_lua_getref);
//LuaAPI.lua_pushstring(L, "xxx");
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldstr, property.Name);
il.Emit(OpCodes.Call, LuaAPI_lua_pushstring);
//translator.Push(L, value);
il.Emit(OpCodes.Ldloc, translator);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_1);
if (property.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, property.PropertyType);
}
il.Emit(OpCodes.Callvirt, ObjectTranslator_PushAny);
//LuaAPI.xlua_psettable(L, -2)
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-3);
il.Emit(OpCodes.Call, LuaAPI_xlua_psettable);
Label settable_no_exception = il.DefineLabel();
il.Emit(OpCodes.Brfalse, settable_no_exception);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
il.Emit(OpCodes.Ldloc, oldTop);
il.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
il.MarkLabel(settable_no_exception);
//LuaAPI.lua_pop(L, 1);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)1);
il.Emit(OpCodes.Call, LuaAPI_lua_pop);
il.Emit(OpCodes.Ret);
prop_builder.SetSetMethod(setter_builder);
}
}
else if (member.MemberType == MemberTypes.Event)
{
EventInfo event_info = member as EventInfo;
EventBuilder event_builder = impl_type_builder.DefineEvent(event_info.Name, event_info.Attributes, event_info.EventHandlerType);
if (event_info.GetAddMethod() != null)
{
var add_buildler = defineImplementMethod(impl_type_builder, event_info.GetAddMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(add_buildler.GetILGenerator(), typeof(void));
event_builder.SetAddOnMethod(add_buildler);
}
if (event_info.GetRemoveMethod() != null)
{
var remove_buildler = defineImplementMethod(impl_type_builder, event_info.GetRemoveMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(remove_buildler.GetILGenerator(), typeof(void));
event_builder.SetRemoveOnMethod(remove_buildler);
}
}
}
// Constructor
var ctor_param_types = new Type[] { typeof(int), typeof(LuaEnv) };
ConstructorInfo parent_ctor = typeof(LuaBase).GetConstructor(ctor_param_types);
var ctor_builder = impl_type_builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctor_param_types);
var cg = ctor_builder.GetILGenerator();
cg.Emit(OpCodes.Ldarg_0);
cg.Emit(OpCodes.Ldarg_1);
cg.Emit(OpCodes.Ldarg_2);
cg.Emit(OpCodes.Call, parent_ctor);
cg.Emit(OpCodes.Ret);
return(impl_type_builder.CreateType());
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void ProcessTouch()
{
for (int i = 0; i < Input.touches.Length; ++i)
{
Touch touch = Input.touches[i];
if (touch.fingerId >= 10)
{
continue;
}
TouchState touchState = null;
exUIElement hotElement = PickElement(touch.position);
//
if (touch.phase == TouchPhase.Began)
{
if (hotElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Touch;
e.type = exUIEvent.Type.TouchDown;
e.position = touch.position;
e.delta = touch.deltaPosition;
e.touchID = touch.fingerId;
EventInfo info = new EventInfo();
info.primaryElement = hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
// NOTE: it must be null
SetTouchFocus(touch.fingerId, null);
touchStateList[touch.fingerId].hotElement = hotElement;
}
else
{
// find the touch state
touchState = touchStateList[touch.fingerId];
// set the last and current hot element
exUIElement focusElement = null;
exUIElement lastHotElement = null;
if (touchState != null)
{
lastHotElement = touchState.hotElement;
touchState.hotElement = hotElement;
focusElement = touchState.focusElement;
}
if (touch.phase == TouchPhase.Ended)
{
if (touchState != null)
{
if (focusElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Touch;
e.type = exUIEvent.Type.TouchUp;
e.position = touch.position;
e.delta = touch.deltaPosition;
e.touchID = touch.fingerId;
EventInfo info = new EventInfo();
info.primaryElement = focusElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
}
}
else if (touch.phase == TouchPhase.Canceled)
{
if (touchState != null)
{
SetTouchFocus(touch.fingerId, null);
}
}
else if (touch.phase == TouchPhase.Moved)
{
// process hover event
if (lastHotElement != hotElement)
{
// add hover-in event
if (hotElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Touch;
e.type = exUIEvent.Type.TouchEnter;
e.position = touch.position;
e.delta = touch.deltaPosition;
e.touchID = touch.fingerId;
EventInfo info = new EventInfo();
info.primaryElement = hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
// add hover-out event
if (lastHotElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Touch;
e.type = exUIEvent.Type.TouchExit;
e.position = touch.position;
e.delta = touch.deltaPosition;
e.touchID = touch.fingerId;
EventInfo info = new EventInfo();
info.primaryElement = lastHotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
}
//
if (hotElement != null || focusElement != null)
{
exUIEvent e = new exUIEvent();
e.category = exUIEvent.Category.Touch;
e.type = exUIEvent.Type.TouchMove;
e.position = touch.position;
e.delta = touch.deltaPosition;
e.touchID = touch.fingerId;
EventInfo info = new EventInfo();
info.primaryElement = (focusElement != null) ? focusElement : hotElement;
info.uiEvent = e;
eventInfoList.Add(info);
}
}
}
}
}
public AutoCompleteItem(EventInfo eventInfo)
: this(eventInfo.Name, eventInfo.Name, eventInfo.MemberType, eventInfo.EventHandlerType)
{
}
private Event(EventInfo @event)
: base(@event)
{
addMethod = @event.AddMethod?.CreateDelegate <Action <D> >();
removeMethod = @event.RemoveMethod?.CreateDelegate <Action <D> >();
}
public static MethodInfo?GetRemoveMethod(EventInfo eventInfo, bool nonPublic)
{
Requires.NotNull(eventInfo, nameof(eventInfo));
return(eventInfo.GetRemoveMethod(nonPublic));
}
private protected EventBase(EventInfo @event)
{
this.@event = @event;
}
public static MethodInfo?GetRaiseMethod(EventInfo eventInfo)
{
Requires.NotNull(eventInfo, nameof(eventInfo));
return(eventInfo.GetRaiseMethod());
}
protected override EventInfo MapEventCore(EventInfo eventInfo) => new ProjectedReflectionTableEventInfo(eventInfo, this);
public void OnComplete(EventInfo info)
{
transform.position = spawnPoint;
transform.rotation = spawnRotation;
Fade(true);
}
