public void SwitchToState(State newState)
{
switch (newState)
{
case State.Names:
if (MatchState >= State.Names)
{
return;
}
break;
case State.Roles:
if (MatchState != State.Names)
{
return;
}
AssignPlayerRoles();
break;
}
MatchState = newState;
MatchListener.OnMatchSwitchState(MatchState);
}
void PregameTimerThread()
{
MRKToSLogger.LogInfo("Pregame timer thread started");
while (true)
{
if (PregameTimer.Enabled)
{
MatchListener.OnPregameTimerStateChanged(new MRKToSTimerEvent(PregameTimer, MRKTosTimerEventState.Updated));
if (PregameTimer.RelativeCurrent <= 0)
{
MRKToSLogger.LogInfo("Pregame timer ended");
Players = new List <MRKToSPlayer>();
foreach (MRKToSUser user in m_QueuedUsers)
{
Players.Add(new MRKToSPlayer(user, this, Players.Count + 1));
}
SwitchToState(State.Names);
break;
}
}
Thread.Sleep(200); // i like to sleep for 200 mils
}
}
/// <summary>
/// Add a user to the queue
/// </summary>
/// <param name="user"></param>
public bool QueueUser(MRKToSUser user)
{
if (MatchState != State.Waiting)
{
MRKToSLogger.LogError($"Can not queue {user.Username} to the match, match has already started or is still idle");
return(false);
}
if (FindQueuedUser(user.Username) != null)
{
MRKToSLogger.LogWarning($"User {user.Username} is already queued");
return(false);
}
if (m_QueuedUsers.Count >= Settings.MaximumPlayerCount)
{
MRKToSLogger.LogWarning($"Can not que {user.Username} to the match, match has maximum player count");
return(false);
}
m_QueuedUsers.Add(user);
MRKToSLogger.LogInfo($"User {user.Username} has been added to the queue");
LogQueueCount();
MatchListener.OnQueueUserAdded(user);
UpdatePregame();
return(true);
}
/// <summary>
/// Updates the pregame counter
/// </summary>
void UpdatePregame()
{
if (Settings.MinimumPlayerCount > m_QueuedUsers.Count)
{
if (PregameTimer.Enabled)
{
//disable timer
PregameTimer.Stop();
MatchListener.OnPregameTimerStateChanged(new MRKToSTimerEvent(PregameTimer, MRKTosTimerEventState.Stopped));
MRKToSLogger.LogInfo("Pregame timer state: start -> stop due to 0");
}
}
else if (m_QueuedUsers.Count >= Settings.MinimumPlayerCount)
{
if (!PregameTimer.Enabled)
{
//start timer
PregameTimer.Max = Settings.MinimumStartTime * 1000;
PregameTimer.Start();
MatchListener.OnPregameTimerStateChanged(new MRKToSTimerEvent(PregameTimer, MRKTosTimerEventState.Started));
MRKToSLogger.LogInfo("Pregame timer state: stop -> start due to 1");
}
if (m_QueuedUsers.Count == Settings.MaximumPlayerCount)
{
if (PregameTimer.Max == Settings.MinimumStartTime * 1000)
{
PregameTimer.Max = Settings.MaximumStartTime * 1000;
PregameTimer.Reset();
MatchListener.OnPregameTimerStateChanged(new MRKToSTimerEvent(PregameTimer, MRKTosTimerEventState.Changed));
MRKToSLogger.LogInfo("Pregame timer state: reset due to 2");
}
}
else
{
if (PregameTimer.Max == Settings.MaximumStartTime * 1000)
{
PregameTimer.Max = Settings.MinimumStartTime * 1000;
PregameTimer.Reset();
MatchListener.OnPregameTimerStateChanged(new MRKToSTimerEvent(PregameTimer, MRKTosTimerEventState.Changed));
MRKToSLogger.LogInfo("Pregame timer state: reset due to 3");
}
}
}
if (m_PregameTimerThread == null)
{
(m_PregameTimerThread = new Thread(PregameTimerThread)).Start();
}
}
/// <summary>
/// Assings roles for players
/// </summary>
void AssignPlayerRoles()
{
Random rnd = new Random();
List <MRKToSPlayer> unassigned = new List <MRKToSPlayer>();
foreach (MRKToSPlayer player in Players)
{
unassigned.Add(player);
}
foreach (MRKToSRoleID role in Settings.Gamemode.RoleList)
{
Dictionary <MRKToSPlayer, RoleAssignmentContext> ctx = new Dictionary <MRKToSPlayer, RoleAssignmentContext>();
int totalLots = 1;
int[] playerMap = new int[unassigned.Count];
int idx = 0;
foreach (MRKToSPlayer player in unassigned)
{
MRKToSScroll scroll = player.GetScroll(role);
int playerLots = 10 * (scroll.Count > 0 ? Settings.ScrollMultiplier : 1);
playerMap[idx++] = totalLots;
totalLots += playerLots;
ctx[player] = new RoleAssignmentContext {
Lots = playerLots,
Scroll = scroll
};
}
int num = rnd.Next(totalLots) + 1;
int playerIdxForRole = -1;
for (int i = unassigned.Count - 1; i > -1; i--)
{
if (num > playerMap[i])
{
playerIdxForRole = i;
break;
}
}
MRKToSPlayer __player = unassigned[playerIdxForRole];
if (ctx[__player].Scroll.Count > 0)
{
ctx[__player].Scroll.Count--;
}
__player.Role = (MRKToSRole)Activator.CreateInstance(ms_RoleAssignmentMap[role], __player);
unassigned.Remove(__player);
}
MatchListener.OnMatchRolesAssigned();
}
public void TestSensorQuery()
{
var configuration = Setup();
configuration.EngineDefaults.ViewResourcesConfig.IsAllowMultipleExpiryPolicies = true;
var epService = EPServiceProviderManager.GetDefaultProvider(configuration);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var listener = new MatchListener();
var stmtString =
"SELECT max(high.type) as type, \n" +
" max(high.measurement) as highMeasurement, max(high.confidence) as confidenceOfHigh, max(high.device) as deviceOfHigh\n" +
",min(low.measurement) as lowMeasurement, min(low.confidence) as confidenceOfLow, min(low.device) as deviceOfLow\n" +
"FROM\n" +
" Sensor.std:groupwin(type).win:time(1 hour).std:unique(device).ext:sort(1, measurement desc) as high " +
",Sensor.std:groupwin(type).win:time(1 hour).std:unique(device).ext:sort(1, measurement asc) as low ";
var stmt = epService.EPAdministrator.CreateEPL(stmtString);
log.Info(stmtString);
stmt.Events += listener.Update;
var runtime = epService.EPRuntime;
IList <Sensor> events = new List <Sensor>();
events.Add(new Sensor("Temperature", "Device1", 68.0, 96.5));
events.Add(new Sensor("Temperature", "Device2", 65.0, 98.5));
events.Add(new Sensor("Temperature", "Device1", 62.0, 95.3));
events.Add(new Sensor("Temperature", "Device2", 71.3, 99.3));
foreach (var theEvent in events)
{
LogEvent(theEvent);
runtime.SendEvent(theEvent);
}
var lastEvent = listener.LastEventBean;
Assert.IsTrue(lastEvent != null);
Assert.AreEqual(62.0, lastEvent.Get("lowMeasurement"));
Assert.AreEqual("Device1", lastEvent.Get("deviceOfLow"));
Assert.AreEqual(95.3, lastEvent.Get("confidenceOfLow"));
Assert.AreEqual(71.3, lastEvent.Get("highMeasurement"));
Assert.AreEqual("Device2", lastEvent.Get("deviceOfHigh"));
Assert.AreEqual(99.3, lastEvent.Get("confidenceOfHigh"));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
epService.Dispose();
}
public void TestSensorQuery()
{
Configuration configuration = GetConfiguration();
configuration.EngineDefaults.ViewResourcesConfig.IsAllowMultipleExpiryPolicies = true;
EPServiceProvider epService = EPServiceProviderManager.GetProvider("testSensorQuery", configuration);
epService.Initialize();
MatchListener listener = new MatchListener();
String stmtString =
"SELECT max(high.type) as type, \n" +
" max(high.measurement) as highMeasurement, max(high.confidence) as confidenceOfHigh, max(high.device) as deviceOfHigh\n" +
",min(low.measurement) as lowMeasurement, min(low.confidence) as confidenceOfLow, min(low.device) as deviceOfLow\n" +
"FROM\n" +
" Sensor.std:groupwin(type).win:time(1 hour).std:unique(device).ext:sort(1, measurement desc) as high " +
",Sensor.std:groupwin(type).win:time(1 hour).std:unique(device).ext:sort(1, measurement asc) as low ";
EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtString);
Log.Info(stmtString);
stmt.Events += (sender, args) => listener.Update(args.NewEvents, args.OldEvents);
EPRuntime runtime = epService.EPRuntime;
List <Sensor> events = new List <Sensor>();
events.Add(new Sensor("Temperature", "Device1", 68.0, 96.5));
events.Add(new Sensor("Temperature", "Device2", 65.0, 98.5));
events.Add(new Sensor("Temperature", "Device1", 62.0, 95.3));
events.Add(new Sensor("Temperature", "Device2", 71.3, 99.3));
foreach (Sensor theEvent in events)
{
LogEvent(theEvent);
runtime.SendEvent(theEvent);
}
EventBean lastEvent = listener.LastEventBean;
Assert.IsTrue(lastEvent != null);
Assert.AreEqual(62.0, lastEvent.Get("lowMeasurement"));
Assert.AreEqual("Device1", lastEvent.Get("deviceOfLow"));
Assert.AreEqual(95.3, lastEvent.Get("confidenceOfLow"));
Assert.AreEqual(71.3, lastEvent.Get("highMeasurement"));
Assert.AreEqual("Device2", lastEvent.Get("deviceOfHigh"));
Assert.AreEqual(99.3, lastEvent.Get("confidenceOfHigh"));
epService.Dispose();
}
public override void Run(EPServiceProvider epService)
{
var listener = new MatchListener();
string stmtString =
"SELECT max(high.type) as type, \n" +
" max(high.measurement) as highMeasurement, max(high.confidence) as confidenceOfHigh, max(high.device) as deviceOfHigh\n" +
",min(low.measurement) as lowMeasurement, min(low.confidence) as confidenceOfLow, min(low.device) as deviceOfLow\n" +
"FROM\n" +
" Sensor#groupwin(type)#time(1 hour)#unique(device)#sort(1, measurement desc) as high " +
",Sensor#groupwin(type)#time(1 hour)#unique(device)#sort(1, measurement asc) as low ";
EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtString);
Log.Info(stmtString);
stmt.Events += listener.Update;
EPRuntime runtime = epService.EPRuntime;
var events = new List <Sensor>();
events.Add(new Sensor("Temperature", "Device1", 68.0, 96.5));
events.Add(new Sensor("Temperature", "Device2", 65.0, 98.5));
events.Add(new Sensor("Temperature", "Device1", 62.0, 95.3));
events.Add(new Sensor("Temperature", "Device2", 71.3, 99.3));
foreach (Sensor theEvent in events)
{
runtime.SendEvent(theEvent);
}
EventBean lastEvent = listener.LastEventBean;
Assert.IsTrue(lastEvent != null);
Assert.AreEqual(62.0, lastEvent.Get("lowMeasurement"));
Assert.AreEqual("Device1", lastEvent.Get("deviceOfLow"));
Assert.AreEqual(95.3, lastEvent.Get("confidenceOfLow"));
Assert.AreEqual(71.3, lastEvent.Get("highMeasurement"));
Assert.AreEqual("Device2", lastEvent.Get("deviceOfHigh"));
Assert.AreEqual(99.3, lastEvent.Get("confidenceOfHigh"));
}
/// <summary>
/// Remove a user from the queue
/// </summary>
/// <param name="user"></param>
public bool DequeueUser(MRKToSUser user)
{
if (MatchState != State.Waiting)
{
MRKToSLogger.LogError($"Can not dequeue {user.Username} to the match, match has already started or is still idle");
return(false);
}
if (FindQueuedUser(user.Username) == null)
{
MRKToSLogger.LogWarning($"User {user.Username} is not queued");
return(false);
}
m_QueuedUsers.Remove(user);
MRKToSLogger.LogInfo($"User {user.Username} has been removed from the queue");
LogQueueCount();
MatchListener.OnQueueUserRemoved(user);
UpdatePregame();
return(true);
}
public void OnMessageReceived(BacktoryListener backtoryListener)
{
MatchListener matchListener = (MatchListener)backtoryListener;
matchListener.OnJoinedWebhookMessage(this);
}
public void SetMatchListener(MatchListener matchListener)
{
backtoryMatchApi.SetMatchListener(matchListener);
}
public void OnMessageReceived(BacktoryListener backtoryListener)
{
MatchListener matchListener = (MatchListener)backtoryListener;
matchListener.OnMatchChatMessage(this);
}
public void SetMatchListener(MatchListener matchListener)
{
this.MatchListener = matchListener;
}
