private void FlushQueue()
{
FlushingIntervalDeadline = DateTime.Now.MillisecondsSince1970() + (long)FlushInterval.TotalMilliseconds;
if (CurrentBatch.Count == 0)
{
return;
}
List <UserEvent> toProcessBatch = null;
lock (mutex)
{
toProcessBatch = new List <UserEvent>(CurrentBatch);
CurrentBatch.Clear();
}
LogEvent logEvent = EventFactory.CreateLogEvent(toProcessBatch.ToArray(), Logger);
NotificationCenter?.SendNotifications(NotificationCenter.NotificationType.LogEvent, logEvent);
try
{
EventDispatcher?.DispatchEvent(logEvent);
}
catch (Exception e)
{
Logger.Log(LogLevel.ERROR, "Error dispatching event: " + logEvent + " " + e);
}
}
private bool onAccessibilityScaleUpdated(AccessibilityEvents.AccessibilityScaleUpdated evt)
{
eventDispatcher.DispatchEvent(new UIEvents.CanvasScalerModifierUpdated(evt.Scale));
return(false);
}
public void CloseShop()
{
EventDispatcher.DispatchEvent(Events.CLOSE_UI_PANE, null);
eventSystem.SetSelectedGameObject(lastCategorySelected);
anim.SetTrigger("CloseShop");
}
/// <summary>
///
/// </summary>
/// <param name="execution"></param>
/// <param name="deleteReason"></param>
/// <param name="deleteHistory"></param>
protected internal virtual void DeleteProcessInstanceCascade(IExecutionEntity execution, string deleteReason, bool deleteHistory)
{
// fill default reason if none provided
if (deleteReason is null)
{
deleteReason = DeleteReasonFields.PROCESS_INSTANCE_DELETED;
}
foreach (IExecutionEntity subExecutionEntity in execution.Executions)
{
if (subExecutionEntity.IsMultiInstanceRoot)
{
foreach (IExecutionEntity miExecutionEntity in subExecutionEntity.Executions)
{
if (miExecutionEntity.SubProcessInstance != null)
{
DeleteProcessInstanceCascade(miExecutionEntity.SubProcessInstance, deleteReason, deleteHistory);
}
}
}
else if (subExecutionEntity.SubProcessInstance != null)
{
DeleteProcessInstanceCascade(subExecutionEntity.SubProcessInstance, deleteReason, deleteHistory);
}
}
TaskEntityManager.DeleteTasksByProcessInstanceId(execution.Id, deleteReason, deleteHistory);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateCancelledEvent(execution.ProcessInstanceId, execution.ProcessInstanceId, null, deleteReason));
}
// delete the execution BEFORE we delete the history, otherwise we will
// produce orphan HistoricVariableInstance instances
IExecutionEntity processInstanceExecutionEntity = execution.ProcessInstance;
if (processInstanceExecutionEntity == null)
{
return;
}
IList <IExecutionEntity> childExecutions = CollectChildren(execution.ProcessInstance);
for (int i = childExecutions.Count - 1; i >= 0; i--)
{
IExecutionEntity childExecutionEntity = childExecutions[i];
DeleteExecutionAndRelatedData(childExecutionEntity, deleteReason, false);
}
DeleteExecutionAndRelatedData(execution, deleteReason, false);
if (deleteHistory)
{
HistoricProcessInstanceEntityManager.Delete(new KeyValuePair <string, object>("id", execution.Id));
}
HistoryManager.RecordProcessInstanceEnd(processInstanceExecutionEntity.Id, deleteReason, null);
processInstanceExecutionEntity.Deleted = true;
}
void OnGameOperStartSyn(GameOperStartSyn data)
{
Debug.LogFormat("===StartSyn(seq[" + data.seq + "]):" + Utils.ToStr(data));
Game.Instance.state = GameState.Playing;
Game.SoundManager.PlayRoundStartSound();
RoomMgr.gameOperStartSyn = data;
Game.MJMgr.Clear();
Game.MJMgr.CardLeft = 112;// data.cardLeft;
//Game.MJMgr.Init();
Game.Instance.Ting = false;
//Game.IsBusy = false;
//Game.MJMgr.HangUp = false;
/////////////////////////////////
Game.MJMgr.bStart = true;
/////////////////////////////////
for (int i = 0; i < Game.MJMgr.MjData.Length; i++)
{
if (null != Game.MJMgr.MjData[i])
{
Player player = Game.MJMgr.MjData[i].player;
if (null != player)
{
player.ting = false;
}
}
}
Game.MJMgr.MakersPosition = data.bankerPos; // 庄家位置
MJPlayer banker = Game.MJMgr.GetPlayerByPosition(data.bankerPos);
Game.MJMgr.Shuffle();
if (data.reconnect)
{
Game.MJTable.Dice(data.dice1, data.dice2);
LicensingOnReconnect(data.playerHandCards);
}
else
{
banker.MJHand.PlayDize(data.dice1, data.dice2);
LicensingOnStart(data.playerHandCards);
Game.MJTable.PlayShuffle();
Game.Delay(1, () =>
{
Game.MJMgr.Licensing(data.playerHandCards);
});
}
if (Game.UIMgr.IsSceneActive(UIPage.PlayPage))
{
EventDispatcher.DispatchEvent(MessageCommand.MJ_UpdatePlayPage);
}
else
{
Game.UIMgr.PushScene(UIPage.PlayPage);
}
}
//接收服务端消息
void OnGameOperPlayerActionSyn(GameOperPlayerActionSyn data)
{
Debug.LogFormat("===<color=green>同步</color>[seq({0})]:{1} <color=yellow>{2}</color> 牌:[{3}]", data.seq, strs[data.position], ActionStr(data.action), ToStr(data.cardValue));
int position = data.position;
MJPlayer player = Game.MJMgr.GetPlayerByPosition(data.position);
bool isMy = player.index == 0;
if (MJUtils.DragCard(data.action))
{
int card = data.cardValue[0];
player.DragCard(card, isMy);
}
else if (MJUtils.DropCard(data.action))
{
HandAnima.IsBusy = true;
int card = data.cardValue[0];
//Game.MJMgr.LastDropCardPlayer = player;
player.MJHand.PlayDropCard(card, isMy);
}
else if (MJUtils.MinGang(data.action))
{
player.MJHand.PlayMingGang(data.cardValue[0], isMy);
}
else if (MJUtils.BuGang(data.action))
{
player.MJHand.PlayBuGang(data.cardValue[0], isMy);
}
else if (MJUtils.AnGang(data.action))
{
player.MJHand.PlayAngGang(data.cardValue[0], isMy);
}
else if (MJUtils.Peng(data.action))
{
player.MJHand.PlayPeng(data.cardValue[0], isMy);
}
else if (MJUtils.Chi(data.action))
{
player.MJHand.PlayChi(data.cardValue[0], data.cardValue[1], isMy);
}
else if (MJUtils.Ting(data.action))
{
player.MJHand.PlayTing(isMy);
}
else if (MJUtils.TingPeng(data.action))
{
player.MJHand.PlayPeng(data.cardValue[0], isMy);
Game.Delay(0.5f, () =>
{
player.MJHand.PlayTing(isMy);
});
}
else if (MJUtils.TingChi(data.action))
{
player.MJHand.PlayChi(data.cardValue[0], data.cardValue[1], isMy);
Game.Delay(0.5f, () =>
{
player.MJHand.PlayTing(isMy);
});
}
else if (MJUtils.TingZhidui(data.action))
{
Game.SoundManager.PlayZhidui(position);
int card = data.cardValue[0];
Game.MJMgr.MjData[position].player.ting = true;
EventDispatcher.DispatchEvent(MessageCommand.MJ_UpdatePlayPage);
player.handCardLayout.PlayZhidui(card, isMy);
}
}
private void onViewBusy(AvatarBaseAsync obj)
{
eventDispatcher.DispatchEvent(default(InventoryUIEvents.StartedLoadingEquipment));
}
//int[] wins = new int[] {
// MJUtils.HU_BaoZhongBao,
// MJUtils.HU_DaiLou,
// MJUtils.HU_GuaDaFeng,
// MJUtils.HU_HongZhong,
// MJUtils.HU_Hu,
// MJUtils.HU_KaiPaiZha,
// MJUtils.HU_MoBao
//};
//void _OnGameOperPlayerHuSyn(GameOperPlayerHuSyn data)
//{
// string huInfo = GetHuStr(data.resultType);
// string winInfo = GetHuStr(data.winType);
// Debug.LogFormat("===HuSyn:{0}[炮：{1}] card:{2} bao:[{3}] Hu:{4}/Win:{5}", (data.position < 0) ? "流局" : strs[data.position], (data.paoPosition < 0) ? "无" : strs[data.paoPosition], GetCardStr(data.card), GetCardStr(data.bao), huInfo, winInfo);
// RoomMgr.huSyn = data;
// if (RoomMgr.huSyn.resultType != MJUtils.HU_LiuJu)
// {
// MJPlayer player = Game.MJMgr.GetPlayerByPosition(data.position);
// MjData pData = Game.MJMgr.MjData[data.position];
// bool zimo = (data.paoPosition == -1 || data.paoPosition == data.position);
// List<GameOperPlayerSettle> list = data.detail;
// foreach (GameOperPlayerSettle s in list)
// {
// Debug.LogFormat("===OnGameOperPlayerHuSyn:{0} fanNum:{1} handcard:[{2}]", strs[s.position], s.fanNum, ToStr(s.handcard));
// if (s.position == data.position)
// {
// player.handCardLayout.Refresh(s.handcard);
// }
// }
// if (zimo)
// {
// Game.SoundManager.PlayEffect(27);
// Game.SoundManager.PlayZimo(data.position);
// player.DragCard(data.card, true);
// }
// else
// {
// if (-1 != data.paoPosition)
// {
// Game.SoundManager.PlayEffect(28);
// MJPlayer paoPlayer = Game.MJMgr.GetPlayerByPosition(data.paoPosition);
// GameObject eff = Game.PoolManager.EffectPool.Spawn("shandian_EF");
// eff.transform.position = Game.MJMgr.LastDropCard.transform.position;
// Game.PoolManager.EffectPool.Despawn(eff, 2);
// }
// Game.SoundManager.PlayHu(data.position);
// player.handCardLayout.DragCard(data.card, Game.MJMgr.LastDropCard.gameObject);
// }
// Game.MaterialManager.TurnOnHandCard();
// player.handCardLayout.PlayHu();
// PlayHuEffect(data.position);
// bool isMy = player.index == 0;
// if (isMy)
// {
// Game.SoundManager.PlayWin();
// }
// else
// {
// if (data.paoPosition != -1)
// {
// MJPlayer paoPplayer = Game.MJMgr.GetPlayerByPosition(data.paoPosition);
// isMy = paoPplayer.index == 0;
// if (isMy)
// {
// Game.SoundManager.PlayLose();
// }
// }
// }
// }
// else
// {
// Game.SoundManager.PlayFall();
// }
// if (!data.skipHuSettle)
// {
// Game.Delay(3, () =>
// {
// Game.SoundManager.PlaySettleSound();
// Game.DialogMgr.PushDialog(UIDialog.SettleRoundDialog);
// IsBusy = false;
// });
// }
//}
void OnGameOperPlayerHuSyn(GameOperPlayerHuSyn data)
{
string huInfo = GetHuStr(data.resultType);
string winInfo = GetHuStr(data.winType);
Debug.LogFormat("===HuSyn:{0}[炮：{1}] card:{2} bao:[{3}] Hu:{4}/Win:{5}", (data.position < 0) ? "流局" : strs[data.position], (data.paoPosition < 0) ? "无" : strs[data.paoPosition], GetCardStr(data.card), GetCardStr(data.bao), huInfo, winInfo);
RoomMgr.huSyn = data;
if (RoomMgr.huSyn.resultType == MJUtils.HU_LiuJu)
{
Game.SoundManager.PlayFall();
if (!data.skipHuSettle)
{
Game.Delay(3, () =>
{
Game.SoundManager.PlaySettleSound();
Game.DialogMgr.PushDialog(UIDialog.SettleRoundDialog);
});
}
return;
}
MJPlayer player = Game.MJMgr.GetPlayerByPosition(data.position);
MjData pData = Game.MJMgr.MjData[data.position];
List <GameOperPlayerSettle> list = data.detail;
foreach (GameOperPlayerSettle s in list)
{
Debug.LogFormat("===OnGameOperPlayerHuSyn:{0} fanNum:{1} handcard:[{2}]", strs[s.position], s.fanNum, ToStr(s.handcard));
if (s.position == data.position)
{
player.handCardLayout.Refresh(s.handcard);
}
////////////////////////
if (!RoomMgr.IsSingeRoom())
{
if (!RoomMgr.IsVipRoom())
{
if (Game.MJMgr.MjData[s.position].player.coin + s.fanNum * Game.Instance.baseScore < 0)
{
Game.MJMgr.MjData[s.position].player.coin = 0;
}
else
{
Game.MJMgr.MjData[s.position].player.coin += s.fanNum * Game.Instance.baseScore;
}
}
else
{
Game.MJMgr.MjData[s.position].player.score += s.fanNum;
}
EventDispatcher.DispatchEvent(MessageCommand.MJ_UpdatePlayPage);
}
////////////////////////
}
bool zimo = (data.paoPosition == -1 || data.paoPosition == data.position);
if (zimo)
{
PlayZimoHu(player, data);
}
else
{
bool isPao = false;
if (-1 != data.paoPosition)
{
Game.SoundManager.PlayEffect(28);
MJPlayer paoPlayer = Game.MJMgr.GetPlayerByPosition(data.paoPosition);
GameObject eff = Game.PoolManager.EffectPool.Spawn("shandian_EF");
eff.transform.position = Game.MJMgr.LastDropCard.transform.position;
Game.PoolManager.EffectPool.Despawn(eff, 5);
isPao = paoPlayer.index == 0;
}
Game.Delay(1, () =>
{
bool isWin = player.index == 0;
if (isWin)
{
Game.SoundManager.PlayWin();
}
else if (isPao)
{
Game.SoundManager.PlayLose();
}
PlayHu(player, data);
});
}
}
private void DispatchEvent(BitSwarmEvent evt)
{
dispatcher.DispatchEvent(evt);
}
public void Bomb(Dictionary <int, bool> attackedMask = null)
{
// SounderManager.Get().PlaySound(1, "boom1");
bool flag = true;
if (GameGOW.Get().MapMgr.IsOutMap(this.Position))
{
flag = false;
}
if (flag)
{
SounderManager.Get().PlaySound(1, "sound/yinxiao/pet_boom_" + (int)SkillManager.CurrentSkillId);
}
if (SkillManager.DO_bomb_Action == true && flag)
{
DigMap();
}
Vector2 boom_pos = new Vector2();
if (Network.gamemode == BattleType.AI_1v1)
{
boom_pos = this.Position;
}
else if (Network.NetworkMode == true)
{
boom_pos = Boom_pos;
}
else
{
boom_pos = this.Position;
}
for (int i = -1; i <= 1; i++)
{
if (GameGOW.Get().MapMgr.IsEmpty((int)(boom_pos.x + i), (int)(boom_pos.y + 5)))
{
boom_pos.x = (int)(boom_pos.x + i);
boom_pos.y = (int)((int)(boom_pos.y + 5));
break;
}
}
if (SkillManager.CurrentSkillId == 7)
{
/*
* 能飞自杀
* if(flag && boom_pos.y==0)
* {
*
*
* }
* else
* {
* if (flag)
* SelfCharacterWalkAction.Set_m_pCharacter(boom_pos);
* else
* {
* Debug.Log("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWW");
* this.Stop();
* }
* }
*/
if (flag)
{
SelfCharacterWalkAction.Set_m_pCharacter(boom_pos);
}
else
{
this.Stop();
}
}
List <TKPhysicalObj> bombList = GameGOW.Get().MapMgr.GetObjectsInMap(boom_pos, m_pConfig.m_fBombRange, null);
int rr = 0;
for (int i = 0; i < bombList.Count; ++i)
{
CharacterLogic pCharacter = bombList[i] as CharacterLogic;
if (pCharacter != null)
{
pCharacter.Falling(); //attackmask
m_pAttackInfo.m_Position = boom_pos;
m_pAttackInfo.m_bIsCenterDamage = (attackedMask != null && attackedMask.ContainsKey(pCharacter.ID));
if (SkillManager.DO_bomb_Action == true || SkillManager.CurrentSkillId == 6)
{
BattleUtils.TriggerAttack(m_pAttackInfo, pCharacter, Boom_Skill);
}
}
if ((SkillManager.DO_bomb_Action == false && SkillManager.CurrentSkillId == 7) && flag)
{
rr++;
if (rr < 2)
{
this.Stop();
}
}
}
//xue move from BombView.cs
BombStatus++;
SkillManager.bomb_num--;
if (Network.gamemode == BattleType.AI_1v1 && SkillManager.bomb_num <= 0)
{
if (GameGOW.Get().BattleMgr.m_bIsInBattle == true)
{
if (GameGOW.Get().BattleMgr.m_pCurrentPlayer.ID == Network.playerid)
{
EventDispatcher.DispatchEvent("EventHideBattleJoyStickUI", null, null);
}
else
{
EventDispatcher.DispatchEvent("EventShowBattleJoyStickUI", null, null);
}
GameGOW.Get().BattleMgr.ChangeController_Quick();
if (GameGOW.Get().BattleMgr.Get_InBattle() == true && GameGOW.Get().BattleMgr.m_iCurrentRoundPlayerIndex % 2 == 1)
{
GameGOW.Get().AIMgr.Act_AI_1v1();
}
}
}
else if (Network.NetworkMode == true)
{
}
else
{
if (SkillManager.bomb_num <= 0)
{
GameGOW.Get().BattleMgr.ChangeController();
}
}
}
public void Quit()
{
Time.timeScale = 1;
EventDispatcher.DispatchEvent(Events.SCENE_CHANGED, 0);
SceneManager.LoadScene(0);
}
public static void DispatchGlobalEvent(this object aObject, string aEvent, object[] aParams)
{
EventDispatcher.DispatchEvent(aEvent, GlobalDispatcher.Instance, aParams);
}
public static void DispatchEvent(this object aObject, string aEvent, object[] aParams)
{
EventDispatcher.DispatchEvent(aEvent, aObject, aParams);
}
public static void DispatchEvent(this object aObject, string aEvent)
{
EventDispatcher.DispatchEvent(aEvent, aObject);
}
private void sendTurnOutput(int action)
{
if (currentTurnInput.Count < currentTurnData.Moves.Count)
{
dispatcher.DispatchEvent(new DanceBattleEvents.TurnInputSent(action, currentTurnInput.Count, localPlayerSessionId));
sendSessionMessage(PartyGameSessionMessageTypes.ShowTurnOutput, new PartyGameSessionMessages.ShowTurnOutput(localPlayerSessionId, action));
currentTurnInput.Add(action);
if (currentTurnInput.Count >= currentTurnData.Moves.Count)
{
changeControlState(ControlsState.Disabled);
EventManager.Instance.PostEvent("SFX/UI/DanceGame/Note2", EventAction.PlaySound, null, null);
}
else
{
EventManager.Instance.PostEvent("SFX/UI/DanceGame/Note1", EventAction.PlaySound, null, null);
}
}
}
public bool PuzzleInit()
{
dispatcher.DispatchEvent(new UIDisablerEvents.DisableUIElement("Joystick"));
rectTransform = GetComponent <RectTransform>();
rectTransform.localPosition = new Vector3(0f, 0f, -100f);
swipeThreshold = Screen.dpi * 0.4f;
if (swipeThreshold <= 0f)
{
swipeThreshold = 50f;
}
focusObj = null;
oldFocus = null;
hasInitalizedPuzzle = false;
isSolved = false;
pieceCount = 0;
solveCount = 0;
hasMadeMove = false;
isTap = false;
solveObjects.Clear();
moveableObjects.Clear();
settings = base.gameObject.GetComponentInParent <BlockAndLockSettings>();
if (settings == null)
{
throw new MissingComponentException("Could not find BlockAndLockSettings component");
}
UnityEngine.Object.Instantiate(settings.AudioPrefab, base.transform);
settings.MarkerTopLeft.SetActive(value: false);
settings.MarkerBottomRight.SetActive(value: false);
gameBoard = new BlockAndLockBoardData[settings.GridWidth, settings.GridHeight];
for (int i = 0; i < settings.GridHeight; i++)
{
for (int j = 0; j < settings.GridWidth; j++)
{
gameBoard[j, i] = new BlockAndLockBoardData(PieceCategory.Empty, 0);
}
}
for (int k = 0; k < maxPieces; k++)
{
prevBoardData[k] = new BlockAndLockBoardData(PieceCategory.Empty, 0);
}
bkgArtworkObj = base.gameObject.transform.Find("Common/Bkg common").gameObject;
if (checkWasFound(bkgArtworkObj, "common background artwork"))
{
bkgArtworkColl = bkgArtworkObj.GetComponent <Collider>();
if (bkgArtworkColl == null)
{
Log.LogError(this, $"BlockAndLock - could not find collider on background artwork");
return(false);
}
bkgArtworkObj.layer = LayerMask.NameToLayer("UI");
}
beginArtworkObj = base.gameObject.transform.Find("Begin/Begin artwork").gameObject;
if (checkWasFound(beginArtworkObj, "beginning artwork"))
{
beginArtworkObj.layer = LayerMask.NameToLayer("UI");
}
completedArtworkObj = base.gameObject.transform.Find("Completed/Completed Artwork").gameObject;
if (checkWasFound(completedArtworkObj, "completed artwork"))
{
completedArtworkObj.layer = LayerMask.NameToLayer("UI");
completedArtworkObj.SetActive(value: false);
}
completedAnchorObj = base.gameObject.transform.Find("Completed/Completed particles anchor").gameObject;
if (checkWasFound(completedAnchorObj, "Completed particles anchor"))
{
completedAnchorObj.layer = LayerMask.NameToLayer("UI");
}
restartButton = base.gameObject.transform.Find("RestartBtn").gameObject;
if (checkWasFound(restartButton, "restart button"))
{
restartButton.layer = LayerMask.NameToLayer("UI");
restartButton.SetActive(value: false);
fieldRestart = restartButton.GetComponentInChildren <Text>();
if (checkWasFound(fieldRestart, "text field on the restart button"))
{
if (string.IsNullOrEmpty(settings.RestartToken))
{
throw new Exception("BlockAndLock - token for Restart text must be set");
}
fieldRestart.text = Service.Get <Localizer>().GetTokenTranslation(settings.RestartToken).ToUpper();
}
}
arrowContainer = base.gameObject.transform.Find("Arrows");
if (checkWasFound(arrowContainer, "arrow container"))
{
foreach (Transform item in arrowContainer)
{
GameObject gameObject = item.transform.gameObject;
if (uniqueNames.Contains(gameObject.name))
{
Log.LogError(this, $"Found duplicate arrow piece '{gameObject.name}'. Please make them unique");
return(false);
}
if (gameObject.name == "ArrowLeft")
{
arrowLeft = gameObject;
}
else if (gameObject.name == "ArrowRight")
{
arrowRight = gameObject;
}
else if (gameObject.name == "ArrowUp")
{
arrowUp = gameObject;
}
else
{
if (!(gameObject.name == "ArrowDown"))
{
Log.LogError(this, $"Piece '{gameObject.name}' is not an expected name. Please rename or delete it");
return(false);
}
arrowDown = gameObject;
}
uniqueNames.Add(gameObject.name);
if (gameObject.GetComponent <Collider>() == null)
{
gameObject.AddComponent <BoxCollider>();
}
BlockAndLockPiece blockAndLockPiece = gameObject.GetComponent <BlockAndLockPiece>();
gameObject.layer = LayerMask.NameToLayer("UI");
if (blockAndLockPiece == null)
{
blockAndLockPiece = gameObject.AddComponent <BlockAndLockPiece>();
}
blockAndLockPiece.Init(PieceCategory.Arrow);
}
}
solveContainer = base.gameObject.transform.Find("Solve Positions");
int result;
if (checkWasFound(solveContainer, "solve container"))
{
foreach (Transform item2 in solveContainer)
{
GameObject gameObject = item2.transform.gameObject;
if (uniqueNames.Contains(gameObject.name))
{
Log.LogError(this, $"'{gameObject.name}'. Please make them unique");
return(false);
}
Grid2 grid = PositionToGrid(gameObject.transform.localPosition.x, gameObject.transform.localPosition.y);
if (gameBoard[grid.x, grid.y].Category != 0)
{
Log.LogError(this, $"'{gameObject.name}' can't go into grid position ({grid.x}, {grid.y}), it's not empty.");
return(false);
}
uniqueNames.Add(gameObject.name);
Match match = Regex.Match(gameObject.name, "\\(([0-9]+)\\)", RegexOptions.None);
if (match.Success)
{
if (!int.TryParse(match.Groups[1].Value, out result))
{
Log.LogError(this, string.Format("'{0}' cannot parse matched value of (1)'.", gameObject.name, match.Groups[1].Value));
return(false);
}
gameBoard[grid.x, grid.y] = new BlockAndLockBoardData(PieceCategory.SolvePosition, result);
if (gameObject.GetComponent <Collider>() == null)
{
gameObject.AddComponent <BoxCollider>();
}
gameObject.layer = LayerMask.NameToLayer("UI");
solveObjects.Add(result, gameObject);
BlockAndLockPiece blockAndLockPiece = gameObject.GetComponent <BlockAndLockPiece>();
if (blockAndLockPiece == null)
{
blockAndLockPiece = gameObject.AddComponent <BlockAndLockPiece>();
}
blockAndLockPiece.Init(PieceCategory.SolvePosition);
continue;
}
Log.LogError(this, string.Format("'{0}' doesn't have an id, should be named like 'SolvedPostion (1)'.", gameObject.name, grid.x, grid.y));
return(false);
}
}
moveableContainer = base.gameObject.transform.Find("Moveable Positions");
if (moveableContainer == null)
{
Log.LogError(this, $"could not find moveable container object");
return(false);
}
foreach (Transform item3 in moveableContainer)
{
GameObject gameObject = item3.transform.gameObject;
if (uniqueNames.Contains(gameObject.name))
{
Log.LogError(this, $"Found duplicate start piece '{gameObject.name}'. Please make them unique");
return(false);
}
Grid2 grid = PositionToGrid(gameObject.transform.localPosition.x, gameObject.transform.localPosition.y);
if (gameBoard[grid.x, grid.y].Category != 0)
{
Log.LogError(this, $"'{gameObject.name}' can't go into grid position ({grid.x}, {grid.y}), it's not empty.");
return(false);
}
uniqueNames.Add(gameObject.name);
Match match = Regex.Match(gameObject.name, "\\(([0-9]+)\\)", RegexOptions.None);
if (match.Success)
{
if (!int.TryParse(match.Groups[1].Value, out result))
{
Log.LogError(this, string.Format("'{0}' cannot parse matched value of (1)'.", gameObject.name, match.Groups[1].Value));
return(false);
}
gameBoard[grid.x, grid.y] = new BlockAndLockBoardData(PieceCategory.MoveableObject, result);
if (gameObject.GetComponent <Collider>() == null)
{
gameObject.AddComponent <BoxCollider>();
}
gameObject.layer = LayerMask.NameToLayer("UI");
moveableObjects.Add(result, gameObject);
BlockAndLockPiece blockAndLockPiece = gameObject.GetComponent <BlockAndLockPiece>();
if (blockAndLockPiece == null)
{
blockAndLockPiece = gameObject.AddComponent <BlockAndLockPiece>();
}
blockAndLockPiece.Init(PieceCategory.MoveableObject);
continue;
}
Log.LogError(this, string.Format("'{0}' doesn't have an id, should be named like 'StartPostion (1)'.", gameObject.name, grid.x, grid.y));
return(false);
}
obstacleContainer = base.gameObject.transform.Find("Obstacle Positions");
if (obstacleContainer == null)
{
Log.LogError(this, $"could not find obstacle container");
return(false);
}
foreach (Transform item4 in obstacleContainer)
{
GameObject gameObject = item4.transform.gameObject;
if (uniqueNames.Contains(gameObject.name))
{
Log.LogError(this, $"Found duplicate obstacle piece '{gameObject.name}'. Please make them unique");
return(false);
}
Grid2 grid = PositionToGrid(gameObject.transform.localPosition.x, gameObject.transform.localPosition.y);
if (gameBoard[grid.x, grid.y].Category != 0)
{
Log.LogError(this, $"'{gameObject.name}' can't go into grid position ({grid.x}, {grid.y}), it's not empty.");
return(false);
}
uniqueNames.Add(gameObject.name);
Match match = Regex.Match(gameObject.name, "\\(([0-9]+)\\)", RegexOptions.None);
if (match.Success)
{
if (!int.TryParse(match.Groups[1].Value, out result))
{
Log.LogError(this, string.Format("'{0}' cannot parse matched value of (1)'.", gameObject.name, match.Groups[1].Value));
return(false);
}
gameBoard[grid.x, grid.y] = new BlockAndLockBoardData(PieceCategory.Obstacle, result);
if (gameObject.GetComponent <Collider>() == null)
{
gameObject.AddComponent <BoxCollider>();
}
gameObject.layer = LayerMask.NameToLayer("UI");
BlockAndLockPiece blockAndLockPiece = gameObject.GetComponent <BlockAndLockPiece>();
if (blockAndLockPiece == null)
{
blockAndLockPiece = gameObject.AddComponent <BlockAndLockPiece>();
}
blockAndLockPiece.Init(PieceCategory.Obstacle);
continue;
}
Log.LogError(this, string.Format("'O_o\t BlockAndLockController.Start: ''{0}' doesn't have an id, should be named like 'ObstaclePostion (1)'.", gameObject.name, grid.x, grid.y));
return(false);
}
if (moveableObjects.Count != solveObjects.Count)
{
Log.LogError(this, $"the number of moveable positions and solve positions must match ({moveableObjects.Count} != {solveObjects.Count})");
return(false);
}
pieceCount = solveObjects.Count;
guiCam = GameObject.Find("PopupCamera").GetComponentInChildren <Camera>();
if (guiCam == null)
{
Log.LogError(this, $"Can't find the GUI camera");
return(false);
}
CalculateScreenExtents();
gameBoardSaved = new BlockAndLockBoardData[settings.GridWidth, settings.GridHeight];
for (int i = 0; i < settings.GridHeight; i++)
{
for (int j = 0; j < settings.GridWidth; j++)
{
gameBoardSaved[j, i] = gameBoard[j, i];
}
}
touchPositionOrigin = INVALID_COORDINATE;
hasInitalizedPuzzle = true;
return(true);
}
public void OnCloseButtonPressed(ButtonClickListener.ClickType clickType)
{
dispatcher.DispatchEvent(default(CellPhoneEvents.CellPhoneClosed));
}
bool PlayHuEffect(int position)
{
string HuEffectUI = "";
string HuEffectScene = "";
switch (RoomMgr.huSyn.winType)
{
case MJUtils.HU_BaoZhongBao:
{
Game.SoundManager.PlayEffect(21);
HuEffectUI = "bzbUI_EF";
HuEffectScene = "baozhongbao_EF";
break;
}
case MJUtils.HU_DaiLou:
{
Game.SoundManager.PlayEffect(23);
HuEffectUI = "louUI_EF";
HuEffectScene = "lou_EF";
break;
}
case MJUtils.HU_GuaDaFeng:
{
Game.SoundManager.PlayEffect(29);
HuEffectUI = "ljfUI_EF";
HuEffectScene = "longjuanfeng_EF";
break;
}
case MJUtils.HU_HongZhong:
{
Game.SoundManager.PlayEffect(25);
HuEffectUI = "hzmtfUI_EF";
HuEffectScene = "hzmtf_EF";
break;
}
//case MJUtils.HU_Hu:
// {
// Game.SoundManager.PlayEffect(26);
// HuEffectUI = "huUI_EF";
// HuEffectScene = "hu_EF";
// break;
// }
case MJUtils.HU_KaiPaiZha:
{
Game.SoundManager.PlayEffect(24);
HuEffectUI = "zhaUI_EF";
HuEffectScene = "zhadang_EF";
break;
}
case MJUtils.HU_MoBao:
{
Game.SoundManager.PlayEffect(22);
HuEffectUI = "mbhUI_EF";
HuEffectScene = "mobaohu_EF";
break;
}
default:
{
return(false);
}
}
EventDispatcher.DispatchEvent(MessageCommand.PlayEffect, position, HuEffectUI);
MJPlayer player = Game.MJMgr.GetPlayerByPosition(position);
GameObject eff = Game.PoolManager.EffectPool.Spawn(HuEffectScene);
eff.transform.position = player.EffectPos.position;
Game.PoolManager.EffectPool.Despawn(eff, 5);
return(true);
}
/// <summary>
/// Call this on an event
/// </summary>
/// <param name="e"></param>
public void OnEvent(IEvent e)
{
EventDispatcher.DispatchEvent <MouseScrollEvent>(e, OnMouseScrolled);
EventDispatcher.DispatchEvent <WindowResizedEvent>(e, OnWindowResized);
}
void OnGameOperPlayerActionNotify(GameOperPlayerActionNotify data)
{
RoomMgr.actionNotify = data;
int position = data.position;
int actions = data.actions;
int lastActionPosition = data.lastActionPosition;
int lastActionCard = data.lastActionCard;
string pengArg = "";
if (MJUtils.Peng())
{
pengArg = GetCardStr(data.pengArg);
}
string gangArg = string.Empty;
if (MJUtils.MinGang() || MJUtils.AnGang())
{
gangArg = GetCardStr(data.gangArg);
Debug.Log("data.gangArg:" + data.gangArg);
}
string chi = "";
if (MJUtils.Chi())
{
int count = data.chiArg.Count;
for (int i = 0; i < count; i++)
{
GameOperChiArg arg = data.chiArg[i];
chi += "[" + GetCardStr(arg.myCard1) + "," + GetCardStr(arg.myCard2) + "]-" + GetCardStr(arg.targetCard) + " ";
}
}
Debug.LogFormat("===<color=blue>提示</color>,最后操作[{0}]; 牌[{1}]", strs[lastActionPosition], GetCardStr(lastActionCard));
Debug.LogFormat("===<color=blue>提示</color>,{0} <color=yellow>{1}</color>,[{2}] 支对:[{3}],听列表:[{4}]", strs[data.position], ActionStr(data.actions), pengArg + chi + gangArg, ToStr(data.tingDzs), ToStr(data.tingList));
if (lastActionPosition >= 0 && lastActionCard > 0)
{
MJPlayer p = Game.MJMgr.GetPlayerByPosition(lastActionPosition);
GameObject go = p.dropCardLayout.last;
if (null != go)
{
MJEntity et = go.GetComponent <MJEntity>();
if (null != et)
{
Game.MJMgr.LastDropCard = et;
Game.MJMgr.targetFlag.gameObject.SetActive(true);
Game.MJMgr.targetFlag.position = go.transform.position;
}
}
}
else
{
Game.MJMgr.targetFlag.gameObject.SetActive(false);
}
EventDispatcher.DispatchEvent(MessageCommand.MJ_UpdatePlayPage);
}
protected virtual void RevertChangesIntern(IRevertChangesSavepoint savepoint, IList <Object> objectsToRevert, bool globally,
RevertChangesFinishedCallback revertChangesFinishedCallback)
{
// Store the RevertChangesFinishedCallback from this thread on the stack and set the property null (for following calls):
if (objectsToRevert == null || objectsToRevert.Count == 0)
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(true);
}
return;
}
if (globally)
{
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success = false;
try
{
DataChangeEvent dataChange = new DataChangeEvent();
dataChange.IsLocalSource = true;
dataChange.Inserts = new List <IDataChangeEntry>(0);
dataChange.Updates = new List <IDataChangeEntry>();
dataChange.Deletes = new List <IDataChangeEntry>();
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
dataChange.Deletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
dataChange.Updates.Add(new DataChangeEntry(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success);
}
}
});
}
else
{
// Commented the following part from Ambeth 0.130 and use the part from Ambeth 0.129 due to a deadlock in the merge process:
//GuiThreadHelper.InvokeOutOfGui(delegate()
//{
// bool success1 = false;
// try
// {
// IList<IDataChangeEntry> directObjectDeletes = new List<IDataChangeEntry>();
// IList<Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null);
// IList<IObjRef> orisToRevert = new List<IObjRef>();
// ISet<Object> persistedObjectsToRevert = new IdentityHashSet<Object>();
// for (int a = initializedObjects.Count; a-- > 0; )
// {
// Object objectToRevert = initializedObjects[a];
// IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(objectToRevert.GetType());
// Object id = metaData.IdMember.GetValue(objectToRevert, false);
// if (id == null)
// {
// directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
// continue;
// }
// persistedObjectsToRevert.Add(objectToRevert);
// orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
// }
// IList<Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
// for (int a = orisToRevert.Count; a-- > 0; )
// {
// if (hardRefsToRootCacheValues[a] == null)
// {
// // Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// // We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// // be tried to persist in a merge process any time in the future
// orisToRevert.RemoveAt(a);
// }
// }
// // We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// // To prohibit GC any potential WeakReferences in the meantime....
// GuiThreadHelper.InvokeInGuiAndWait(delegate()
// {
// IProcessResumeItem processResumeItem = WaitEventToResume();
// try
// {
// bool oldCacheModificationValue = CacheModification.IsActive;
// CacheModification.IsActive = true;
// bool oldFailEarlyModeActive = AbstractCache<Object>.FailEarlyModeActive;
// AbstractCache<Object>.FailEarlyModeActive = true;
// try
// {
// IList<IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
// IList<Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
// foreach (IWritableCache firstLevelCache in firstLevelCaches)
// {
// IList<Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
// for (int a = persistedObjectsInThisCache.Count; a-- > 0; )
// {
// Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
// if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
// {
// continue;
// }
// RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache);
// }
// }
// for (int a = objectsToRevert.Count; a-- > 0; )
// {
// Object objectToRevert = objectsToRevert[a];
// if (objectToRevert is IDataObject)
// {
// // Objects which are specified to be reverted loose their delete flag
// ((IDataObject)objectToRevert).ToBeDeleted = false;
// }
// }
// }
// finally
// {
// AbstractCache<Object>.FailEarlyModeActive = oldFailEarlyModeActive;
// CacheModification.IsActive = oldCacheModificationValue;
// }
// }
// finally
// {
// if (processResumeItem != null)
// {
// processResumeItem.ResumeProcessingFinished();
// processResumeItem = null;
// }
// }
// });
// if (directObjectDeletes.Count > 0)
// {
// DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
// dataChange.Deletes = directObjectDeletes;
// EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
// }
// success1 = true;
// }
// finally
// {
// if (revertChangesFinishedCallback != null)
// {
// revertChangesFinishedCallback.Invoke(success1);
// }
// }
//});
// Here comes the part from Ambeth 0.129:
GuiThreadHelper.InvokeOutOfGui(delegate()
{
bool success1 = false;
bool?success2 = null;
bool?success3 = null;
try
{
IList <IDataChangeEntry> directObjectDeletes = new List <IDataChangeEntry>();
List <IObjRef> objRefs = new List <IObjRef>();
List <ValueHolderRef> valueHolderKeys = new List <ValueHolderRef>();
IList <Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null, objRefs, valueHolderKeys);
IList <IObjRef> orisToRevert = new List <IObjRef>();
ISet <Object> persistedObjectsToRevert = new IdentityHashSet <Object>();
for (int a = initializedObjects.Count; a-- > 0;)
{
Object objectToRevert = initializedObjects[a];
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData();
Object id = metaData.IdMember.GetValue(objectToRevert, false);
if (id == null)
{
directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert));
continue;
}
persistedObjectsToRevert.Add(objectToRevert);
orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null));
}
IList <Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses);
for (int a = orisToRevert.Count; a-- > 0;)
{
if (hardRefsToRootCacheValues[a] == null)
{
// Object could not be loaded/retrieved any more. So the ori refers to an invalid object
// We can not revert invalid objects and currently ignore them. They will raise exceptions if they will
// be tried to persist in a merge process any time in the future
orisToRevert.RemoveAt(a);
}
}
// We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack
// To prohibit GC any potential WeakReferences in the meantime....
success2 = false;
GuiThreadHelper.InvokeInGui(delegate(Object state)
{
WaitEventToResume(delegate(IProcessResumeItem processResumeItem)
{
try
{
bool oldCacheModificationValue = CacheModification.Active;
CacheModification.Active = true;
bool oldFailEarlyModeActive = AbstractCache.FailInCacheHierarchyModeActive;
AbstractCache.FailInCacheHierarchyModeActive = true;
try
{
IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches();
IList <Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues;
foreach (IWritableCache firstLevelCache in firstLevelCaches)
{
IList <Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly);
for (int a = persistedObjectsInThisCache.Count; a-- > 0;)
{
Object persistedObjectInThisCache = persistedObjectsInThisCache[a];
if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache))
{
continue;
}
RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache, null);
}
}
for (int a = objectsToRevert.Count; a-- > 0;)
{
Object objectToRevert = objectsToRevert[a];
if (objectToRevert is IDataObject)
{
// Objects which are specified to be reverted loose their flags
((IDataObject)objectToRevert).ToBeDeleted = false;
}
}
if (directObjectDeletes.Count == 0)
{
success2 = true;
return;
}
}
finally
{
AbstractCache.FailInCacheHierarchyModeActive = oldFailEarlyModeActive;
CacheModification.Active = oldCacheModificationValue;
}
}
finally
{
if (processResumeItem != null)
{
processResumeItem.ResumeProcessingFinished();
}
}
success3 = false;
GuiThreadHelper.InvokeOutOfGui(delegate()
{
try
{
DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0);
dataChange.Deletes = directObjectDeletes;
EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1);
success3 = true;
}
finally
{
if (revertChangesFinishedCallback != null)
{
revertChangesFinishedCallback.Invoke(success3.Value);
}
}
});
success2 = true;
}, delegate(Exception e)
{
if (revertChangesFinishedCallback != null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success2.Value);
}
});
}, null);
success1 = true;
}
finally
{
if (revertChangesFinishedCallback != null && success2 == null && success3 == null)
{
revertChangesFinishedCallback.Invoke(success1);
}
}
});
}
}
private void onButton()
{
dispatcher.DispatchEvent(default(JigsawEvents.CloseButton));
}
public void CheckLoading()
{
Network.GameLoading_Cnt = 1000;
if (Network.GameLoading == 0)
{
return;
}
if (Network.GameLoading >= 1)
{
Network.GameLoading_Cnt++;
}
if (Network.GameLoading == 1 && Network.GameLoading_Cnt > 120)
{
Network.GameLoading_Cnt = 120;
m_pTickerMgr.Clear();
m_pMapMgr.Clear();
m_pCharacterMgr.Clear();
m_pBattleMgr.Clear();
EventDispatcher.DispatchEvent("EventBeforeSwitchMap", null, null);
m_pCurrentMapData = m_pDataMgr.GetMapDataByID(battleinfo.m_iMapIndex); //读取配置文件
if (Network.gamemode == BattleType.AI_1v1)
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 3;
}
else if (Network.NetworkMode == true)
{
Network.Send_GameLoading(UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10));
Network.GameLoading++;
}
else
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 3;
}
}
else if (Network.GameLoading == 3 && Network.GameLoading_Cnt > 160)
{
Network.GameLoading_Cnt = 160;
m_pMapMgr.SetData(m_pCurrentMapData); //加载地图资源
if (Network.gamemode == BattleType.AI_1v1)
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 5;
}
else if (Network.NetworkMode == true)
{
Network.Send_GameLoading(UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10));
Network.GameLoading++;
}
else
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 5;
}
}
else if (Network.GameLoading == 5 && Network.GameLoading_Cnt > 190)
{
Network.GameLoading_Cnt = 190;
m_pCharacterMgr.SetData(m_pCurrentMapData); //加载坦克资源
if (Network.gamemode == BattleType.AI_1v1)
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 7;
}
else if (Network.NetworkMode == true)
{
Network.Send_GameLoading(UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10));
Network.GameLoading++;
}
else
{
Network.GameLoading_num[1] = UnityEngine.Random.Range((Network.GameLoading + 1) * 10, (Network.GameLoading + 3) * 10);
Network.GameLoading = 7;
}
}
else if (Network.GameLoading == 7 && Network.GameLoading_Cnt > 260)
{
Network.GameLoading_Cnt = 260;
EventDispatcher.DispatchEvent("EventAfterSwitchMap", null, null); //加载背景
if (Network.gamemode == BattleType.AI_1v1)
{
Network.GameLoading_num[1] = 100;
Network.GameLoading = 9;
}
else if (Network.NetworkMode == true)
{
Network.Send_GameLoading(100);
Network.GameLoading++;
}
else
{
Network.GameLoading_num[1] = 100;
Network.GameLoading = 9;
}
}
else if (Network.GameLoading == 9 && Network.GameLoading_Cnt > 340)
{
Network.GameLoading_Cnt = 340;
//m_pBattleMgr.StartBattle(battleinfo, m_pCurrentMapData);
//m_pMyPlayer = m_pBattleMgr.m_pCurrentPlayer;
if (Network.gamemode == BattleType.AI_1v1)
{
Network.GameLoading = 10;
}
else if (Network.NetworkMode == true)
{
}
else
{
Network.GameLoading = 10;
}
}
}
// CREATE METHODS
/// <summary>
///
/// </summary>
/// <param name="processDefinition"></param>
/// <param name="businessKey"></param>
/// <param name="tenantId"></param>
/// <param name="initiatorVariableName"></param>
/// <returns></returns>
public virtual IExecutionEntity CreateProcessInstanceExecution(IProcessDefinition processDefinition, string businessKey, string tenantId, string initiatorVariableName)
{
IExecutionEntity processInstanceExecution = executionDataManager.Create();
if (ExecutionRelatedEntityCountEnabledGlobally)
{
((ICountingExecutionEntity)processInstanceExecution).IsCountEnabled = true;
}
processInstanceExecution.ProcessDefinitionId = processDefinition.Id;
processInstanceExecution.ProcessDefinitionKey = processDefinition.Key;
processInstanceExecution.ProcessDefinitionName = processDefinition.Name;
processInstanceExecution.ProcessDefinitionVersion = processDefinition.Version;
processInstanceExecution.BusinessKey = businessKey;
processInstanceExecution.IsScope = true; // process instance is always a scope for all child executions
// Inherit tenant id (if any)
if (tenantId is object)
{
processInstanceExecution.TenantId = tenantId;
}
string authenticatedUserId = Authentication.AuthenticatedUser.Id;
processInstanceExecution.StartTime = Context.ProcessEngineConfiguration.Clock.CurrentTime;
processInstanceExecution.StartUserId = authenticatedUserId;
// Store in database
Insert(processInstanceExecution, false);
IUserInfo starter = null;
if (string.IsNullOrWhiteSpace(authenticatedUserId) == false)
{
starter = GetUser(processInstanceExecution, authenticatedUserId);
//保存调用用户变量
processInstanceExecution.SetVariable(processInstanceExecution.StartUserId, starter);
}
processInstanceExecution.StartUser = starter.FullName;
if (initiatorVariableName is object)
{
processInstanceExecution.SetVariable(initiatorVariableName, authenticatedUserId);
}
// Need to be after insert, cause we need the id
processInstanceExecution.ProcessInstanceId = processInstanceExecution.Id;
processInstanceExecution.RootProcessInstanceId = processInstanceExecution.Id;
//TODO: 当没有用户任务的时候，添加identity会报错
if (authenticatedUserId is object)
{
IdentityLinkEntityManager.AddIdentityLink(processInstanceExecution, authenticatedUserId, null, IdentityLinkType.STARTER);
}
// Fire events
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, processInstanceExecution));
}
return(processInstanceExecution);
}
public void Start()
{
ResetCamera();
dispatcher.DispatchEvent(default(CinematographyEvents.DirectorStartComplete));
IsStartUpComplete = true;
}
/// <summary>
///
/// </summary>
/// <param name="executionEntity"></param>
/// <param name="deleteReason"></param>
/// <param name="cancel"></param>
public virtual void DeleteDataForExecution(IExecutionEntity executionEntity, string deleteReason, bool cancel)
{
// To start, deactivate the current incoming execution
executionEntity.Ended = true;
executionEntity.IsActive = false;
bool enableExecutionRelationshipCounts = IsExecutionRelatedEntityCountEnabled(executionEntity);
if (executionEntity.Id.Equals(executionEntity.ProcessInstanceId) && (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).IdentityLinkCount > 0)))
{
IIdentityLinkEntityManager identityLinkEntityManager = IdentityLinkEntityManager;
ICollection <IIdentityLinkEntity> identityLinks = identityLinkEntityManager.FindIdentityLinksByProcessInstanceId(executionEntity.ProcessInstanceId);
foreach (IIdentityLinkEntity identityLink in identityLinks)
{
identityLinkEntityManager.Delete(identityLink);
}
}
// Get variables related to execution and delete them
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).VariableCount > 0))
{
ICollection <IVariableInstance> executionVariables = executionEntity.VariableInstancesLocal.Values;
foreach (IVariableInstance variableInstance in executionVariables)
{
if (variableInstance is IVariableInstanceEntity variableInstanceEntity)
{
IVariableInstanceEntityManager variableInstanceEntityManager = VariableInstanceEntityManager;
variableInstanceEntityManager.Delete(variableInstanceEntity);
if (variableInstanceEntity.ByteArrayRef != null && variableInstanceEntity.ByteArrayRef.Id is object)
{
ByteArrayEntityManager.DeleteByteArrayById(variableInstanceEntity.ByteArrayRef.Id);
}
}
}
}
// Delete current user tasks
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).TaskCount > 0))
{
ITaskEntityManager taskEntityManager = TaskEntityManager;
ICollection <ITaskEntity> tasksForExecution = taskEntityManager.FindTasksByExecutionId(executionEntity.Id);
foreach (ITaskEntity taskEntity in tasksForExecution)
{
taskEntityManager.DeleteTask(taskEntity, deleteReason, false, cancel);
}
}
// Delete jobs
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).TimerJobCount > 0))
{
ITimerJobEntityManager timerJobEntityManager = TimerJobEntityManager;
ICollection <ITimerJobEntity> timerJobsForExecution = timerJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (ITimerJobEntity job in timerJobsForExecution)
{
timerJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).JobCount > 0))
{
IJobEntityManager jobEntityManager = JobEntityManager;
ICollection <IJobEntity> jobsForExecution = jobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (IJobEntity job in jobsForExecution)
{
JobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).SuspendedJobCount > 0))
{
ISuspendedJobEntityManager suspendedJobEntityManager = SuspendedJobEntityManager;
ICollection <ISuspendedJobEntity> suspendedJobsForExecution = suspendedJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (ISuspendedJobEntity job in suspendedJobsForExecution)
{
suspendedJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).DeadLetterJobCount > 0))
{
IDeadLetterJobEntityManager deadLetterJobEntityManager = DeadLetterJobEntityManager;
ICollection <IDeadLetterJobEntity> deadLetterJobsForExecution = deadLetterJobEntityManager.FindJobsByExecutionId(executionEntity.Id);
foreach (IDeadLetterJobEntity job in deadLetterJobsForExecution)
{
deadLetterJobEntityManager.Delete(job);
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
// Delete event subscriptions
if (!enableExecutionRelationshipCounts || (enableExecutionRelationshipCounts && ((ICountingExecutionEntity)executionEntity).EventSubscriptionCount > 0))
{
IEventSubscriptionEntityManager eventSubscriptionEntityManager = EventSubscriptionEntityManager;
IList <IEventSubscriptionEntity> eventSubscriptions = eventSubscriptionEntityManager.FindEventSubscriptionsByExecution(executionEntity.Id);
foreach (IEventSubscriptionEntity eventSubscription in eventSubscriptions)
{
eventSubscriptionEntityManager.Delete(eventSubscription);
}
}
}
public void Activate()
{
isActive = true;
EventDispatcher.DispatchEvent(Events.WEAPON_READY, this);
}
public override void OnEnter()
{
dispatcher = Service.Get <EventDispatcher>();
DCinematicSpeech dCinematicSpeech = new DCinematicSpeech();
DialogList.Entry entry = default(DialogList.Entry);
if (!UseDialogList)
{
dCinematicSpeech.Text = Service.Get <Localizer>().GetTokenTranslation(i18nContents);
}
else if (DialogList != null)
{
entry = ((!RandomDialog) ? DialogList.Entries[DialogListItemIndex] : DialogList.Entries[Random.Range(0, DialogList.Entries.Length)]);
dCinematicSpeech.Text = Service.Get <Localizer>().GetTokenTranslation(entry.ContentToken);
}
dCinematicSpeech.BubbleContentKey = DialogPrefabKey;
dCinematicSpeech.Buttons = null;
dCinematicSpeech.BackgroundImageKey = BackgroundImageKey;
dCinematicSpeech.ContentImageKey = ContentImageKey;
dCinematicSpeech.TextStyle = TextStyle;
dCinematicSpeech.RichText = RichText;
dCinematicSpeech.MascotName = (string.IsNullOrEmpty(CustomName) ? MascotName : CustomName);
dCinematicSpeech.DismissTime = ((AutoCloseTime > 0f) ? AutoCloseTime : ((float)DismissTime));
dCinematicSpeech.CenterX = CenterX;
dCinematicSpeech.CenterY = CenterY;
dCinematicSpeech.OffsetY = OffsetY;
dCinematicSpeech.OffsetYPercent = OffsetYPercent;
dCinematicSpeech.HideTail = HideTail;
dCinematicSpeech.ClickToClose = ClickToClose;
dispatcher.DispatchEvent(new CinematicSpeechEvents.ShowSpeechEvent(dCinematicSpeech, HideQuestHud));
dispatcher.AddListener <CinematicSpeechEvents.SpeechCompleteEvent>(OnSpeechComplete);
string text = "";
string overrideAnimationName = "";
string overrideStopAnimationName = "";
bool flag = false;
if (UseDialogList && DialogList != null)
{
text = entry.AudioEventName;
overrideAnimationName = entry.DialogAnimationTrigger;
overrideStopAnimationName = entry.DialogAnimationEndTrigger;
flag = entry.AdvanceSequence;
}
else if (!AudioEventName.IsNone)
{
text = AudioEventName.Value;
overrideAnimationName = DialogAnimationOverride.Value;
overrideStopAnimationName = EndDialogAnimationOverride.Value;
flag = AdvanceSequence;
}
if (!string.IsNullOrEmpty(text))
{
EventAction eventAction = EventAction.PlaySound;
if (flag)
{
eventAction = EventAction.AdvanceSequence;
}
GameObject mascotObject = Service.Get <MascotService>().GetMascotObject(MascotName);
if (mascotObject != null && PlayDialogAnimation)
{
MascotController component = mascotObject.GetComponent <MascotController>();
EventManager.Instance.PostEventNotify(text, eventAction, base.Owner, component.dialogAudioCallback);
component.StartDialogAnimation(text, overrideAnimationName, AutoStopDialogAnimation, overrideStopAnimationName);
}
else
{
EventManager.Instance.PostEventNotify(text, eventAction, base.Owner, onMascotAudioComplete);
}
}
if (!WaitForFinish)
{
Finish();
}
}
public virtual EventRet DispatchEvent(string evt, params object[] objs)
{
EventRet b = eventDispatcher.DispatchEvent(evt, objs);
return(b);
}
private void ApplyUpdatesRecursive(
ReactShadowNode cssNode,
EventDispatcher eventDispatcher)
{
if (!cssNode.HasUpdates)
{
return;
}
if (!cssNode.IsVirtualAnchor)
{
for (var i = 0; i < cssNode.ChildCount; ++i)
{
ApplyUpdatesRecursive(
cssNode.GetChildAt(i),
eventDispatcher);
}
}
var tag = cssNode.ReactTag;
if (!_shadowNodeRegistry.IsRootNode(tag))
{
cssNode.DispatchUpdates(
_operationsQueue,
_nativeViewHierarchyOptimizer);
if (cssNode.ShouldNotifyOnLayout)
{
eventDispatcher.DispatchEvent(
OnLayoutEvent.Obtain(
tag,
cssNode.LayoutX,
cssNode.LayoutY,
cssNode.LayoutWidth,
cssNode.LayoutHeight));
}
}
cssNode.MarkUpdateSeen();
}
public void OnPointerClick(PointerEventData eventData)
{
this.isOn = !this.isOn;
EventDispatcher.DispatchEvent(UIEventConst.CLICK_UGUI_JUST);
}
