public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.PrefChange:
PrefChange(message as PrefChange); break;
case EventType.UserChange:
UserChange(message as UserChange); break;
case EventType.TeamJoin:
TeamJoin(message as TeamJoin); break;
case EventType.TeamPrefChange:
TeamPrefChange(message as TeamPrefChange); break;
case EventType.TeamDomainChange:
TeamDomainChange(message as TeamDomainChange); break;
case EventType.TeamRename:
TeamRename(message as TeamRename); break;
case EventType.EmailDomainChanged:
EmailDomainChanged(message as EmailDomainChanged); break;
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.ChannelArchive:
ChannelArchive(message as ChannelArchive); break;
case EventType.ChannelCreated:
ChannelCreated(message as ChannelCreated); break;
case EventType.ChannelDeleted:
ChannelDeleted(message as ChannelDeleted); break;
case EventType.ChannelJoined:
ChannelJoined(message as ChannelJoined); break;
case EventType.ChannelLeft:
ChannelLeft(message as ChannelLeft); break;
case EventType.ChannelMarked:
ChannelMarked(message as ChannelMarked); break;
case EventType.ChannelRename:
ChannelRename(message as ChannelRename); break;
case EventType.ChannelUnarchive:
ChannelUnarchive(message as ChannelUnarchive); break;
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
private async void OfferMessageToHandlersAsync(EventMessageBase message, string originalMessage)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (this.MessageHandlers == null)
{
return;
}
var interestedHandlers = this.MessageHandlers.Where(h => SafelyHandles(h, message, originalMessage));
foreach (var handler in interestedHandlers)
{
try
{
this.Logger.Debug($"{handler.GetType().Name} handling: {message.Type}");
var result = await handler.HandleMessageAsync(message);
if (result == ProcessingChainResult.Stop)
{
break;
}
}
catch (Exception ex)
{
this.Logger.Error($"{handler.GetType().Name} threw exception when handling message: {originalMessage}", ex);
}
}
}
public void OnMessage(EventMessageBase message)
{
if (message.eventMessageModel == EventMessageModel.eEventMessageModel_PLAY_ATTACK_STATE)
{
m_blood -= message.eventMessageAction;
if (m_blood <= 0)
{
m_stateMachine.ChangeState(MonsterDeathState.GetInstance());
}
else
{
m_stateMachine.ChangeState(MonsterInjurtState.GetInstance());
}
Debug.Log("monster blood =" + m_blood.ToString());
}
else
{
if (message.eventMessageAction == (int)EnitityCommon.EnitityAction.ENITITY_ACTION_FIGHT_FINISH)
{
m_stateMachine.ChangeState(MonsterIdelState.GetInstance());
}
}
m_stateMachine.OnMessage(message);
}
public bool CanHandle(EventMessageBase message)
{
return(message.IsOneOf(EventType.ImClose,
EventType.ImCreated,
EventType.ImMarked,
EventType.ImOpen));
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.GroupArchive:
GroupArchive(message as GroupArchive); break;
case EventType.GroupJoined:
GroupJoined(message as GroupJoined); break;
case EventType.GroupLeft:
GroupLeft(message as GroupLeft); break;
case EventType.GroupMarked:
GroupMarked(message as GroupMarked); break;
case EventType.GroupRename:
GroupRename(message as GroupRename); break;
case EventType.GroupUnarchive:
GroupUnarchive(message as GroupUnarchive); break;
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
void MonAttOver()
{
EventMessageBase message = new EventMessageBase();
message.eventMessageAction = (int)EnitityCommon.EnitityAction.ENITITY_ACTION_FIGHT_FINISH;
message.eventMessageModel = EventMessageModel.eEventMessageModel_PLAY_STATE;
CCearcueMgr.GetInstance().player.OnMessage(message);
}
void RunOver()
{
EventMessageBase message = new EventMessageBase();
message.eventMessageAction = (int)EnitityCommon.EnitityAction.ENITITY_ACTION_MOVEOVER;
message.eventMessageModel = EventMessageModel.eEventMessageModel_PLAY_MOVE_STATE;
CCearcueMgr.GetInstance().player.OnMessage(message);
}
void Hero_Injurt()
{
EventMessageBase message = new EventMessageBase();
message.eventMessageAction = 5;
message.eventMessageModel = EventMessageModel.eEventMessageModel_PLAY_STATE;
CCearcueMgr.GetInstance().player.OnMessage(message);
}
void Hero_Injurt()
{
EventMessageBase message = new EventMessageBase();
message.eventMessageModel = EventMessageModel.eEventMessageModel_PLAY_ATTACK_STATE;
message.eventMessageAction = 20;
CCearcueMgr.GetInstance().MonsterBeAttack(CCearcueMgr.GetInstance().player.GetAttackArea(), message);
}
public static bool IsOneOf(this EventMessageBase message, params EventType[] types)
{
if (message == null || types == null)
{
return(false);
}
return(types.Contains(message.Type));
}
void injurtOver()
{
EventMessageBase message = new EventMessageBase();
message.eventMessageAction = (int)EnitityCommon.EnitityAction.ENITITY_ACTION_FIGHT_FINISH;
message.eventMessageModel = EventMessageModel.eEventMessageModel_MONSTER_STATE;
message.modleId = int.Parse(this.name);
CCearcueMgr.GetInstance().MonsterOnMessage(message);
}
public bool CanHandle(EventMessageBase message)
{
return(message.IsOneOf(EventType.GroupArchive,
EventType.GroupJoined,
EventType.GroupLeft,
EventType.GroupMarked,
EventType.GroupRename,
EventType.GroupUnarchive));
}
private async void RunHandler(EventMessageBase message, Mock <IBotState> mockState)
{
var handler = new ChannelHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
public void MonsterOnMessage(EventMessageBase message)
{
foreach (CMonster monster in m_monsterEntity)
{
if (monster.GetId() == message.modleId)
{
monster.OnMessage(message);
}
}
}
public bool CanHandle(EventMessageBase message)
{
return(message.IsOneOf(EventType.PrefChange,
EventType.UserChange,
EventType.TeamJoin,
EventType.TeamPrefChange,
EventType.TeamRename,
EventType.TeamDomainChange,
EventType.EmailDomainChanged));
}
public static bool MatchesText(this EventMessageBase message, string pattern, RegexOptions options = RegexOptions.None)
{
if (!IsActivePlainMessage(message))
{
return(false);
}
var messageBase = CastTo <MessageBase>(message);
return(Regex.IsMatch(messageBase.Text, pattern, options));
}
public bool CanHandle(EventMessageBase message)
{
return(message.IsOneOf(EventType.ChannelArchive,
EventType.ChannelCreated,
EventType.ChannelDeleted,
EventType.ChannelJoined,
EventType.ChannelLeft,
EventType.ChannelMarked,
EventType.ChannelRename,
EventType.ChannelUnarchive));
}
public static T CastTo <T>(this EventMessageBase message) where T : EventMessageBase
{
var castMessage = message as T;
if (castMessage == null)
{
throw new InvalidCastException($"message is not a valid {typeof(T).Name}");
}
return(castMessage);
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var presenceMessage = message.CastTo <PresenceChange>();
var user = base.BotState.Users.FirstOrDefault(u => u.Id == presenceMessage.User);
if (user != null)
{
user.Presence = presenceMessage.Presence;
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
private bool SafelyHandles(IMessageHandler handler, EventMessageBase message, string originalMessage)
{
var handles = false;
try
{
handles = handler.CanHandle(message);
}
catch (Exception ex)
{
this.Logger.Error($"{handler.GetType().Name} threw exception in CanHandle() with message: {originalMessage}", ex);
}
return(handles);
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var messageBase = message.CastTo <MessageBase>();
var response = "pong";
if (!message.IsIm(base.BotState))
{
response = $"<@{messageBase.User}>: {response}";
}
base.BotServices.SendMessage(messageBase.Channel, response);
return(Task.FromResult(ProcessingChainResult.Continue));
}
public void MonsterBeAttack(int[] area, EventMessageBase message)
{
foreach (int i in area)
{
foreach (CMonster monster in m_monsterEntity)
{
Debug.Log(NavigationMgr.GetInstance().GetGrid().GetCellIndex(monster.GetRenderObject().transform.localPosition).ToString() +
" =========== monster Index");
Debug.Log(i.ToString() + " =========== attack Index");
if (NavigationMgr.GetInstance().GetGrid().GetCellIndex(monster.GetRenderObject().transform.localPosition) == i)
{
monster.OnMessage(message);
}
}
}
}
public static bool IsActivePlainMessage(this EventMessageBase message)
{
if (message?.Type != EventType.Message)
{
return(false);
}
var messageBase = CastTo <MessageBase>(message);
if (messageBase.Subtype != MessageSubType.PlainMessage)
{
return(false);
}
return(CastTo <PlainMessage>(message).Historic == false);
}
public override void Loop(string[] args)
{
if (EventSubscription.Queue.Any())
{
EventMessageBase item = EventSubscription.Queue.Dequeue();
foreach (Action <EventMessageBase> action in EventSubscription.Subscriptions[item.Key])
{
action(item);
}
}
else
{
Thread.Sleep(500);
}
}
public static bool IsToMe(this EventMessageBase message, IBotState botState)
{
if (!IsActivePlainMessage(message))
{
return(false);
}
if (IsIm(message, botState))
{
return(true);
}
var messageBase = CastTo <MessageBase>(message);
return((messageBase.Text ?? "").StartsWith($"<@{botState.Self.Id}>:"));
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var rtmStartResponse = message.CastTo <RtmStartResponse>();
base.BotState.Bots = rtmStartResponse.Bots;
base.BotState.CacheVersion = rtmStartResponse.CacheVersion;
base.BotState.Channels = rtmStartResponse.Channels;
base.BotState.Groups = rtmStartResponse.Groups;
base.BotState.Ims = rtmStartResponse.Ims;
base.BotState.LatestEventTs = rtmStartResponse.LatestEventTs;
base.BotState.Self = rtmStartResponse.Self;
base.BotState.Team = rtmStartResponse.Team;
base.BotState.Users = rtmStartResponse.Users;
return(Task.FromResult(ProcessingChainResult.Continue));
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var botModel = (message as BotAdded)?.Bot ?? (message as BotChanged)?.Bot;
if (botModel != null)
{
var existingBotIndex = base.BotState.Bots.FindIndex(b => b.Id == botModel.Id);
if (existingBotIndex >= 0)
{
base.BotState.Bots.RemoveAt(existingBotIndex);
}
base.BotState.Bots.Add(botModel);
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
private EventMessageBase ParseMessageResponse(JObject jsonObject)
{
EventMessageBase eventMessage = null;
var properties = jsonObject.Properties();
if (properties.Any(p => p.Name == "ok") && properties.Any(p => p.Name == "reply_to"))
{
if ((bool)jsonObject["ok"])
{
eventMessage = jsonObject.ToObject <MessageAck>(this.jsonSerializer);
}
else
{
eventMessage = jsonObject.ToObject <MessageError>(this.jsonSerializer);
}
}
return(eventMessage);
}
public Task <ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.ImClose:
ImClose(message as ImClose); break;
case EventType.ImCreated:
ImCreated(message as ImCreated); break;
case EventType.ImMarked:
ImMarked(message as ImMarked); break;
case EventType.ImOpen:
ImOpen(message as ImOpen); break;
}
return(Task.FromResult(ProcessingChainResult.Continue));
}
