IEnumerator _init()
{
#if UNITY_EDITOR
Debug.unityLogger.logEnabled = true;
#else
Debug.unityLogger.logEnabled = false;
#endif
AssetManager.Instance.InitMode(GameConfigs.LoadAssetMode);
UIManager.Instance.OpenView(ViewID.PrepareView, null);
yield return(new WaitForEndOfFrame());
Debug.Log("跳过版本检测...");
//UpdateVersionManager.Instance.CheckVersion((bool needUpdate) => {
// if (needUpdate) {
// MsgBox.SetActive(true);
// } else {
// UpdateAssetManager.Instance.CheckAsset(() => {
// MsgDispatcher.GetInstance().Fire(GameEvents.Msg_DownloadFinish);
// });
// }
//});
// load and parse config data
MsgDispatcher.GetInstance().Fire(GameEvents.UpdateAsset.ShowUpdateAssetInfo, "加载配置...");
ConfigManager.Instance.ParseConfigData(AssetManager.Instance.LoadAsset <TextAsset>(GameConfigs.GetConfigPath("DataConfig")).bytes);
MsgDispatcher.GetInstance().Fire(GameEvents.UpdateAsset.UpdateAssetFinish);
yield return(null);
}
/// <summary>
/// 将预存的预制件放入冷却列表中，仅CardManager内部使用，产生冷却池变动消息
/// </summary>
/// <param name="cardId">要冷却的卡牌的预制件引用</param>
/// <param name="controlCd">默认值为-1，表示按卡牌cd值进行冷却，设定其他值则按设定值冷却</param>
private void CooldownCard(string cardId, int controlCd = -1)
{
// 如果控制cd的参数值小于等于0，表示按卡牌cd值进行冷却
if (controlCd <= 0)
{
// 读取数据库得到冷却回合数
int roundAmount = (int)_cardsData[cardId]["cd"];
// 若卡牌自身的cd值为负数，则直接销毁，并进入弃牌堆
if (roundAmount < 0)
{
_garbageCards.Add(cardId);
return;
}
// 初始化BaseCard脚本内剩余回合数的counter
_cooldownCards.Add(new cdObject(roundAmount, cardId));
}
else // 按controlCd值进行冷却
{
_cooldownCards.Add(new cdObject(controlCd, cardId));
}
// 发送冷却池变动消息
MsgDispatcher.SendMsg((int)MessageType.CooldownlistChange);
}
/// <summary>
/// 如果伤害请求优先级相同，则伤害判定流程会特殊一些
/// </summary>
public void ExcuteSameTime()
{
//CheckWhosTurn(_attacker, _attackedUnit);
Damage.TakeDamage(_attackedUnit, Damage.GetDamage(_attacker));
SetInjurer(_attackedUnit); SetInjuredUnit(_attacker);
MsgDispatcher.SendMsg((int)TriggerType.Damage);
MsgDispatcher.SendMsg((int)TriggerType.BeDamaged);
Damage.TakeDamage(_attacker, Damage.GetDamage(_attackedUnit));
SetInjurer(_attacker); SetInjuredUnit(_attackedUnit);
MsgDispatcher.SendMsg((int)TriggerType.Damage);
MsgDispatcher.SendMsg((int)TriggerType.BeDamaged);
if (_attacker.IsDead())
{
SetKiller(_attackedUnit); SetKilledAndDeadUnit(_attacker);
MsgDispatcher.SendMsg((int)TriggerType.Kill);
MsgDispatcher.SendMsg((int)TriggerType.Dead);
}
if (_attackedUnit.IsDead())
{
SetKiller(_attacker); SetKilledAndDeadUnit(_attackedUnit);
MsgDispatcher.SendMsg((int)TriggerType.Kill);
MsgDispatcher.SendMsg((int)TriggerType.Dead);
}
}
IEnumerator progress(UnityAction <bool> onComplate)
{
//拉取服务器版本
MsgDispatcher.GetInstance().Fire(GameEvents.UpdateAsset.ShowUpdateAssetInfo, "检测版本号...");
UnityWebRequest req = UnityWebRequest.Get(GameConfigs.ServerVersionUrl);
yield return(req.SendWebRequest());
if (req.isHttpError || req.isNetworkError)
{
Debug.LogError(req.error);
yield break;
}
onlineVersion = new System.Version(req.downloadHandler.text);
curVersion = new System.Version(Application.version);
if (onlineVersion != curVersion)
{
Debug.LogFormat("当前版本不是最新版本({0}),请及时更新到最新版本({1})", curVersion, onlineVersion);
IsNeedUpdate = true;
}
Debug.Log("版本检测完成!");
if (onComplate != null)
{
onComplate(IsNeedUpdate);
}
yield return(null);
}
private void Start()
{
//创建Trigger实例，传入技能的发动者
trigger = new TRegeneration(GetComponent <GameUnit.GameUnit>().GetMsgReceiver());
//注册Trigger进消息中心
MsgDispatcher.RegisterMsg(trigger, "Regeneration");
}
protected override void TakeRemote()
{
var session = paramGetter.GetSession();
if (session == null)
{
ErrorCode = 10000;
ErrorInfo = "Sessin is null.";
return;
}
switch (_type)
{
case NoticeMode.AllService:
{
var sessionlist = GameSession.GetAll();
foreach (var on in sessionlist)
{
if (on.Connected && !on.IsRemote)
{
MsgData data = new MsgData();
data.Type = MsgType.Notice;
data.UserId = on.UserId;
var parameters = new Parameters();
parameters["Type"] = NoticeMode.AllService;
parameters["ServerID"] = _serverID;
parameters["Content"] = _content;
data.Param = parameters;
MsgDispatcher.Push(data);
}
}
}
break;
case NoticeMode.World:
{
var cache = new MemoryCacheStruct <ChatUser>();
var list = cache.FindAll(t => t.ServerID == _serverID);
foreach (var v in list)
{
var sess = GameSession.Get(v.UserId);
if (sess != null && sess.Connected && !sess.IsRemote)
{
MsgData data = new MsgData();
data.Type = MsgType.Notice;
data.UserId = sess.UserId;
var parameters = new Parameters();
parameters["Type"] = NoticeMode.World;
parameters["ServerID"] = _serverID;
parameters["Content"] = _content;
data.Param = parameters;
MsgDispatcher.Push(data);
}
}
}
break;
}
}
private void Start()
{
//创建Trigger实例，传入技能的发动者
trigger = new TCourage(this.GetCardReceiver(this));
//注册Trigger进消息中心
MsgDispatcher.RegisterMsg(trigger, "Courage");
}
public void MsgDispatcherPhysical_ExplicitHandlers()
{
MsgDispatcher dispatcher;
dispatcher = new MsgDispatcher();
dispatcher.AddPhysical(new MsgHandlerDelegate(OnExplicit1), typeof(_DispatchMsg1), null);
dispatcher.AddPhysical(new MsgHandlerDelegate(OnExplicit2), typeof(_DispatchMsg2), null);
dispatcher.AddPhysical(new MsgHandlerDelegate(OnExplicit3), typeof(_DispatchMsg3), null);
Clear();
dispatcher.Dispatch(new _DispatchMsg1());
Thread.Sleep(DispatchWait);
Assert.IsTrue(onExplicit1);
Assert.IsFalse(onExplicit2);
Assert.IsFalse(onExplicit3);
Clear();
dispatcher.Dispatch(new _DispatchMsg2());
Thread.Sleep(DispatchWait);
Assert.IsFalse(onExplicit1);
Assert.IsTrue(onExplicit2);
Assert.IsFalse(onExplicit3);
Clear();
dispatcher.Dispatch(new _DispatchMsg3());
Thread.Sleep(DispatchWait);
Assert.IsFalse(onExplicit1);
Assert.IsFalse(onExplicit2);
Assert.IsTrue(onExplicit3);
}
public void MsgDispatcherLogical_DynamicEP()
{
MsgDispatcher dispatcher;
MsgRouter router;
ChannelEP target;
dispatcher = new MsgDispatcher();
router = new MsgRouter(dispatcher);
router.Dispatcher.AddTarget(this, "foo", new Munger(), null);
router.RouterEP = MsgEP.Parse("physical://foo.com/" + Helper.NewGuid().ToString());
router.Start(IPAddress.Any, null, new IPEndPoint(IPAddress.Any, 0), new IPEndPoint(IPAddress.Any, 0), 5, TimeSpan.FromSeconds(60));
target = new ChannelEP(Transport.Udp, router.UdpEP);
try
{
Clear();
router.Transmit(target, new _DispatchMsg1("logical://MungedDynamic"));
Thread.Sleep(DispatchWait);
Assert.IsTrue(dispatchDynamic);
}
finally
{
router.Stop();
}
}
private void Start()
{
// 注册函数响应抽牌信息
MsgDispatcher.RegisterMsg(
this.GetMsgReceiver(),
(int)MessageType.DrawCard,
canDoExtractAction,
() => { ExtractCards(); },
"Extract cards Trigger"
);
// 注册函数响应回合结束信息
MsgDispatcher.RegisterMsg(
this.GetMsgReceiver(),
(int)MessageType.EP,
canDoCoolDownAction,
HandleCooldownEvent,
"Cooldown cards Trigger"
);
MsgDispatcher.RegisterMsg(
this.GetMsgReceiver(),
(int)MessageType.Dead,
canSendToCoolDownList,
HandleCardOnMapToCooldown,
"Map Unit cooldown Trigger"
);
ExtractCards(3);
}
public void MsgDispatcherPhysical_MultipleHandlers()
{
MsgDispatcher dispatcher;
try
{
new MsgDispatcher().AddTarget(new Target4());
Assert.Fail("Expected the detection of multiple handlers with the same message type.");
}
catch (MsgException)
{
}
try
{
dispatcher = new MsgDispatcher();
dispatcher.AddTarget(new Target2());
dispatcher.AddPhysical(new MsgHandlerDelegate(OnExplicit1), typeof(_DispatchMsg1), null);
Assert.Fail("Expected the detection of multiple handlers with the same message type.");
}
catch (MsgException)
{
}
}
public override void Excute()
{
MsgDispatcher.SendMsg((int)MessageType.AnnounceAttack);
//根据伤害优先级对伤害请求排序
DamageRequestList = DamageRequest.CaculateDamageRequestList(_Attacker, _AttackedUnit);
for (int i = 0; i < DamageRequestList.Count; i++)
{
//优先级相同并且两方互打的伤害请求作为同时处理
if (i != DamageRequestList.Count - 1 && DamageRequestList[i].priority == DamageRequestList[i + 1].priority &&
DamageRequestList[i]._attacker == DamageRequestList[i + 1]._attackedUnit &&
DamageRequestList[i]._attackedUnit == DamageRequestList[i + 1]._attacker)
{
//判断被攻击者的反击距离
if (JudgeStrikeBack())
{
DamageRequestList[i].ExcuteSameTime();
}
else
{
DamageRequestList[i].Excute(); //距离不够，无法进行反击
}
i++;
}
else if (!_AttackedUnit.IsDead() && !_Attacker.IsDead() && JudgeStrikeBack()) //符合反击要求
{
DamageRequestList[i].Excute();
}
else if (!_AttackedUnit.IsDead() && !_Attacker.IsDead() && !JudgeStrikeBack()) //距离不够，无法进行反击
{
DamageRequestList[i].Excute();
i++;
}
}
}
public void MsgDispatcherLogical_Multi_Handlers_Grouped()
{
Target4A target1 = new Target4A();
Target4B target2 = new Target4B();
MsgDispatcher dispatcher = new MsgDispatcher();
// I'm going to test whether the handlers for the two targets
// were grouped properly in the routing table by sending
// instances of the two message types to logical://Foo.
//
// The message receive counts should match the number
// of messages sent if grouping worked properly. If
// grouping didn't work, we'd expect to see messages
// routed randomly to one target or the other with
// messages that aren't handled by each target being
// dropped.
dispatcher.AddTarget(target1, null, null, target1);
dispatcher.AddTarget(target2, null, null, target1);
for (int i = 0; i < 10; i++)
{
dispatcher.Dispatch(new _DispatchMsg1("logical://Foo"));
dispatcher.Dispatch(new _DispatchMsg2("logical://Foo"));
}
Thread.Sleep(1000);
Assert.AreEqual(10, target1.Count);
Assert.AreEqual(10, target2.Count);
}
private void Start()
{
//创建Trigger实例，传入技能的发动者
trigger = new TInstantIdea(this.GetUnitReceiver(this));
//注册Trigger进消息中心
MsgDispatcher.RegisterMsg(trigger, "Ponder");
}
/// <summary>
/// 用于将卡牌插入手牌中，会根据参数产生手牌变动消息
/// </summary>
/// <param name="cardId">要插入的卡牌的ID</param>
/// <param name="sendMsg">是否发送手牌变动消息，默认发送，若连续调用请设置false并自己发送消息</param>
public void InsertIntoHandCard(string cardId, bool sendMsg = true)
{
// 实例化卡牌到不可见区域，并绑定脚本再初始化
GameObject cardInstance = Instantiate(emptyObject);
JsonData cardData = GetCardJsonData(cardId);
//根据json数据中卡牌分类挂载不同脚本
if (cardData["type"].ToString().Equals("Order"))
{
cardInstance.AddComponent <OrderCard>().Init(cardId, cardData);
}
else if (cardData["type"].ToString().Equals("Unit"))
{
cardInstance.AddComponent <UnitCard>().Init(cardId, cardData);
}
else
{
cardInstance.AddComponent <BaseCard>().Init(cardId, cardData);
}
// 将实例放入对应位置的list中
_handcardsInstance.Add(cardInstance);
// 更新手牌list
_handcards.Add(cardId);
if (sendMsg)
{
// 发送手牌变动消息
MsgDispatcher.SendMsg((int)MessageType.HandcardChange);
}
}
/// <summary>
/// 广播执行
/// </summary>
private void Dispatch()
{
if (dispacherQueue.Count > 0)
{
lock (locker)
{
int count = dispacherQueue.Count;
for (int i = 0; i < count; i++)
{
MsgDispatcher dispacher = dispacherQueue.Dequeue();
Msg msg = dispacher.msg;
object[] param = dispacher.param;
if (msg_dic.ContainsKey(msg))
{
Dictionary <object, MsgRegister> dic = msg_dic[msg];
IEnumerator iter = dic.GetEnumerator();
while (iter.MoveNext()) //迭代器模式
{
KeyValuePair <object, MsgRegister> pair = (KeyValuePair <object, MsgRegister>)iter.Current;
MsgRegister register = pair.Value;
register.Invoke(param);
}
}
}
}
}
}
/// <summary>
/// 冷却处理函数，响应EP消息，处理卡牌冷却，根据情况产生冷却池变动消息，卡牌堆变动消息
/// </summary>
public void HandleCooldownEvent()
{
List <cdObject> toRemove = new List <cdObject>();
for (int i = 0; i < _cooldownCards.Count; i++)
{
int leftRounds = _cooldownCards[i].ReduceCd();
if (leftRounds == 0)
{
toRemove.Add(_cooldownCards[i]);
}
}
for (int i = 0; i < toRemove.Count; i++)
{
// 将冷却完毕的id重新放回牌堆
_cardsSets.Add(toRemove[i].objectId);
// 将其从冷却列表中移除
_cooldownCards.Remove(toRemove[i]);
}
// 发送冷却池变动消息
MsgDispatcher.SendMsg((int)MessageType.CooldownlistChange);
if (toRemove.Count > 0)
{
// 发送卡牌堆变动消息
MsgDispatcher.SendMsg((int)MessageType.CardsetChange);
}
}
void Update()
{
if (Input.GetMouseButtonDown(1))
{
MsgDispatcher.SendMsg("HelloWorld", "HelloWorld");
}
}
void Button3Click()
{
id = 3;
if (effect3 == 0)
{
effect3 = GameFrameEntry.GetModule <EffectModule>().Show(3, Button3.transform);
}
else
{
GameFrameEntry.GetModule <EffectModule>().Close(effect3);
effect3 = 0;
}
MsgDispatcher.SendMessage(GlobalEventType.TaskFinish, id);
if (infoUI == 0)
{
GameFrameEntry.GetModule <UIModule>().Show <InfoUI>();
infoUI = 1;
}
else
{
GameFrameEntry.GetModule <UIModule>().Close <InfoUI>();
infoUI = 0;
}
Refresh();
}
void Button2Click()
{
id = 2;
GameFrameEntry.GetModule <EffectModule>().Show(2, Button2.transform);
MsgDispatcher.SendMessage(GlobalEventType.TaskFinish, id);
Refresh();
}
private int DispatchWait = 250; // # of milliseconds to wait for messages
// dispatches to be handled on worker threads
/// <summary>
/// Handles the dispatching of a message via a dispatcher and then
/// waits a bit of time to give the background threads to actually
/// process the message.
/// </summary>
/// <param name="dispatcher"></param>
/// <param name="msg"></param>
/// <returns></returns>
private bool Dispatch(MsgDispatcher dispatcher, Msg msg)
{
bool result;
result = dispatcher.Dispatch(msg);
Thread.Sleep(DispatchWait);
return(result);
}
private void RemoveListener()
{
MsgDispatcher.UnRegisterMsg((int)ROOM_REPLY.ActorAddReply, OnActorAddReply);
MsgDispatcher.UnRegisterMsg((int)ROOM_REPLY.ActorRemoveReply, OnActorRemoveReply);
MsgDispatcher.UnRegisterMsg((int)ROOM_REPLY.ActorMoveReply, OnActorMoveReply);
MsgDispatcher.UnRegisterMsg((int)ROOM_REPLY.CityAddReply, OnCityAddReply);
MsgDispatcher.UnRegisterMsg((int)ROOM_REPLY.CityRemoveReply, OnCityRemoveReply);
}
void Button4Click()
{
id = 4;
Button4.transform.DOLocalMoveY(400f, 0.3f).SetLoops(2, LoopType.Yoyo);
MsgDispatcher.SendMessage(GlobalEventType.TaskFinish, id);
Refresh();
ChangeState();
}
public static MsgDispatcher Instance()
{
if (_instance == null)
{
_instance = new MsgDispatcher();
}
return(_instance);
}
/// <summary>
/// 添加到消息队列
/// </summary>
/// <param name="msg"></param>
/// <param name="param"></param>
public void Broadcast(Msg msg, object[] param)
{
lock (locker)
{
MsgDispatcher dispacher = new MsgDispatcher(msg, param);
dispacherQueue.Enqueue(dispacher);
}
}
protected internal override void OnEnter(ProcedureOwner procedureOwner)
{
base.OnEnter(procedureOwner);
DBTSDK.AppUserManager.Instance.ShowAntiAddiction(true, 1);
MsgDispatcher.AddEventListener(GameFramework.GlobalEventType.MainPanel_StartGame, MainPanel_StartGame);
ShowMainPanelOrStarGame();
}
public static MsgDispatcher GetInstance()
{
if (m_Ins == null)
{
m_Ins = new MsgDispatcher();
}
return(m_Ins);
}
public override void Enter(RoundProcessController roundProcessController)
{
base.Enter(roundProcessController);
MsgDispatcher.SendMsg((int)MessageType.AI);
Gameplay.Instance().singleBattle.battleState = AI.BattleState.Prepare;
Gameplay.Instance().singleBattle.Run();
}
public static void ProcessMsg(byte[] bytes, int size)
{
if (size < 4)
{
Debug.Log($"ROOM - ProcessMsg Error - invalid data size:{size}");
return;
}
byte[] recvHeader = new byte[4];
Array.Copy(bytes, 0, recvHeader, 0, 4);
byte[] recvData = new byte[size - 4];
Array.Copy(bytes, 4, recvData, 0, size - 4);
int msgId = System.BitConverter.ToInt32(recvHeader, 0);
switch ((ROOM_REPLY)msgId)
{
case ROOM_REPLY.PlayerEnterReply:
PLAYER_ENTER_REPLY(recvData);
break;
case ROOM_REPLY.UploadMapReply:
UPLOAD_MAP_REPLY(recvData);
break;
case ROOM_REPLY.DownloadMapReply:
DOWNLOAD_MAP_REPLY(recvData);
break;
case ROOM_REPLY.EnterRoomReply:
ENTER_ROOM_REPLY(recvData);
break;
case ROOM_REPLY.LeaveRoomReply:
LEAVE_ROOM_REPLY(recvData);
break;
case ROOM_REPLY.DownloadCitiesReply:
DOWNLOAD_CITIES_REPLY(recvData);
break;
case ROOM_REPLY.DownloadActorsReply:
break;
case ROOM_REPLY.DownloadResCellReply:
DOWNLOAD_RESCELL_REPLY(recvData);
break;
case ROOM_REPLY.ChangeAiRightsReply:
CHANGE_AI_RIGHTS_REPLY(recvData);
break;
default:
// 通用消息处理器，别的地方要想响应找个消息，应该调用MsgDispatcher.RegisterMsg()来注册消息处理事件
MsgDispatcher.ProcessMsg(bytes, size);
break;
}
}
/// <summary>
/// AI移动
/// 一格一格移动处理函数
/// </summary>
/// <returns></returns>
public IEnumerator moveStepByStepAI(Unit unit, List <Vector2> paths, System.Action callback)
{
#region 测试一哈 先固定（0.0）为灼烧块，（0.1）为粘滞块
List <Vector2> vector2s = new List <Vector2>();
vector2s.Add(new Vector2(0, 0));
BattleMap.Instance().debuffBM.SetBattleMapBlockBurning(vector2s);
List <Vector2> vector22s = new List <Vector2>();
vector22s.Add(new Vector2(1, 1));
BattleMap.Instance().debuffBM.SetBattleMapBlockRetrad(vector22s);
#endregion
Vector2 tempVector;
BattleMapBlock battleMap;
bool isRetire = false;
for (int i = paths.Count - 2; i >= 0; i--)
{
//移除上一步的地图块儿下面的units_on_me
tempVector = new Vector2((int)paths[i + 1].x, (int)paths[i + 1].y);
battleMap = BattleMap.Instance().GetSpecificMapBlock(tempVector);
battleMap.RemoveUnit(unit);
//添加当前unit到地图块儿下面的units_on_me内
tempVector = new Vector2((int)paths[i].x, (int)paths[i].y);
battleMap = BattleMap.Instance().GetSpecificMapBlock(tempVector);
if (i != 0)
{
battleMap.AddUnit(unit);
}
else
{
battleMap.AddUnit(unit, false);
}
unit.transform.localPosition = Vector3.zero;
if (battleMap.blockType == EMapBlockType.Burnning)//如果经过灼烧块
{
BattleMap.Instance().debuffBM.UnitEnterBurning(tempVector);
}
else if (battleMap.blockType == EMapBlockType.Retire)//如果经过滞留块
{
BattleMap.Instance().debuffBM.UnitEnterRetire(unit, battleMap);
unit.nextPos = paths[i];
MsgDispatcher.SendMsg((int)MessageType.Aftermove);
isRetire = true;
break;
}
unit.nextPos = paths[i];
MsgDispatcher.SendMsg((int)MessageType.Move);
yield return(new WaitForSeconds(0.4f));
}
if (isRetire == false)
{
MsgDispatcher.SendMsg((int)MessageType.Aftermove);
}
if (callback != null)
{
callback();
}
}
public AdapterUSB()
{
device = new GenericHIDDevice(5824, 1503);
device.Connected += OnConnected;
device.Disconnected += OnDisconnected;
frm = new MsgDispatcher(device);
frm.WindowState = FormWindowState.Minimized;
frm.Show();
frm.Hide();
}
