public WebsocketWrapper(Logger logger, bool listeningMode, ProxySettings proxySettings, Session session, CanvasType canvas)
{
this.canvas = canvas;
if (this.listeningMode = listeningMode)
{
listeningResetEvent = new ManualResetEvent(false);
}
this.logger = logger;
webSocket = new WebSocket(UrlManager.WebSocketUrl);
webSocket.Log.Output = LogWebsocketOutput;
webSocket.Origin = UrlManager.BaseHttpAdress;
webSocket.UserAgent = HttpHeaderValues.UserAgent;
if (session != null)
{
foreach (WebsocketCookie cookie in session.Cookies.Select(ConvertCookie))
{
webSocket.SetCookie(cookie);
}
}
if (proxySettings != null)
{
webSocket.SetProxy(proxySettings.Address, proxySettings.Username, proxySettings.Password);
}
webSocket.OnOpen += WebSocket_OnOpen;
webSocket.OnMessage += WebSocket_OnMessage;
webSocket.OnClose += WebSocket_OnClose;
ConnectWebSocket();
}
public void ShowOrHideUI(CanvasType ct, string uiName, bool isShow)
{
switch (ct)
{
case CanvasType.Top:
if (canvas_Top.transform.Find(uiName))
{
canvas_Top.transform.Find(uiName).gameObject.SetActive(isShow);
}
else
{
if (isShow)
{
}
}
break;
case CanvasType.Mid:
canvas_Mid.transform.Find(uiName).gameObject.SetActive(isShow);
break;
case CanvasType.Bottom:
if (canvas_Bottom.transform.Find(uiName))
{
canvas_Bottom.transform.Find(uiName).gameObject.SetActive(isShow);
}
break;
}
}
public TicTacToePresenter(TicTacToeForm ticTacToeForm)
{
_gameCanvases = EnumUtil.GetListOfEnumElement <CanvasType>("Matrix");
_ticTacToeForm = ticTacToeForm;
_canvasContainer = new CanvasContainer();
_network = new ActivationNetwork(new SigmoidFunction(2), 100, 14, 2);
new BackPropagationLearning(_network);
_pen = new Pen(Color.Black, 5);
_crossDesignator = new CrossDesignator();
_network = (ActivationNetwork)Network.Load("Net.bin");
_gameUtil = new GameUtil();
_computerPlayer = new ComputerPlayer(_gameUtil, _gameCanvases);
_board = new GameBoard(_gameCanvases);
_game = new Game(_gameUtil, _board, _computerPlayer);
_ticTacToeForm.DrawAction += Draw;
_ticTacToeForm.LearnAction += ExecuteLearnAction;
_ticTacToeForm.CrossAction += ExecuteCrossAction;
_ticTacToeForm.CircleAction += ExecuteCircleAction;
_ticTacToeForm.ClearAction += ExecuteClearAction;
_ticTacToeForm.CopyAction += ExecuteCopyAction;
_ticTacToeForm.TestAction += ExecuteTestAction;
_ticTacToeForm.NewGameAction += ExecuteNewGameAction;
_ticTacToeForm.PlayAction += ExecutePlayAction;
_ticTacToeForm.BackAction += ExecuteBackAction;
_lastModifiedCanvas = CanvasType.Matrix11;
_paintFactory = new PaintFactory(_pen, _crossDesignator);
}
internal Canvas(DocumentFiltersBase parent, System.IO.Stream stream, CanvasType type, string options)
{
_type = type;
_options = options;
_stream = new IGRStreamBridge(stream);
_streamHandle = _stream.NewWritableStreamPtr();
}
public void UpdateCanvasView(CanvasType canvasType)
{
var canvas = _canvasContainer.GetCanvas(canvasType);
var bitmap = canvas.GetBitmap();
_ticTacToeForm.UpdatePictureBox($"pb{canvasType}", bitmap);
}
private void ExecuteCopyAction(CanvasType canvasType)
{
var currentBitmap = _canvasContainer.GetCanvas(CanvasType.Test);
_canvasContainer.UpdateCanvas(currentBitmap, canvasType);
UpdateCanvasView(canvasType);
}
private double[] PreaperNetworkInput(CanvasType canvasType)
{
var canvas = _canvasContainer.GetCanvas(canvasType);
var input = BitmapConverter.ImageToByte(canvas.GetBitmap());
return(input);
}
internal Canvas(DocumentFiltersBase parent, IGRStream stream, CanvasType type, string options)
{
_type = type;
_options = options;
_stream = stream;
_streamHandle = stream.NewWritableStreamPtr();
}
public void Set(GameObject canvas,CanvasType type)
{
this.canvas = canvas;
panel = canvas.transform.FindChild("UIPanel").gameObject;
point = panel.transform.FindChild("UIPoint").gameObject;
this.type = type;
}
private void SortByDepth(CanvasType type)
{
List <BaseView> list = new List <BaseView>(typedViewInstances.Count + namedViewInstances.Count);
list.AddRange(typedViewInstances.Values.Where(v => v.CanvasType == type).ToList());
list.AddRange(namedViewInstances.Values.Where(v => v.CanvasType == type).ToList());
Transform canvasTransform = GetCanvasTransform(type);
LegacyUIView[] legacyViews = canvasTransform.GetComponentsInChildren <LegacyUIView>();
if (legacyViews.Length > 0)
{
list.AddRange(legacyViews);
}
list.Sort((v1, v2) => {
return(v1.SortDepth.CompareTo(v2.SortDepth));
});
for (int i = 0; i < list.Count; i++)
{
if (list[i] && list[i].gameObject)
{
list[i].GetComponent <RectTransform>().SetSiblingIndex(i);
}
}
}
// 隐藏其他页面，显示指定的页面
public BasePanel PopAllAndPushPanel(UIPanelType panelType, CanvasType uiStayCanvas)
{
if (panelStack == null)//如果栈不存在，就实例化一个空栈
{
panelStack = new Stack <BasePanel>();
}
var tempPanel = UIManager.Instance.GetPanelFromCache(panelType);
if (tempPanel == null || !tempPanel.gameObject.activeSelf)
{
HideAll();
}
if (tempPanel == null)
{
tempPanel = UIManager.Instance.PushPanel(panelType, uiStayCanvas);
}
else
{
tempPanel.transform.SetAsLastSibling();
tempPanel.OnEnter();//页面进入显示，可交互
if (GetCurrentPanel() != tempPanel)
{
panelStack.Push(tempPanel);
}
DebugUI();
}
return(tempPanel);
}
private static CanvasObject CanvasObjectInit(CanvasType type, string name)
{
var canvasObject = new CanvasObject();
canvasObject.Init(type, name);
return(canvasObject);
}
public Panel(CanvasType type, PanelStatus status, GameObject obj, LuaTable table)
{
panelType = type;
panelStatus = status;
panelObject = obj;
luaTable = table;
}
private void Draw(Point point, CanvasType canvasType)
{
_lastModifiedCanvas = canvasType;
_painterCommand = new DrawPointCommand(point, _pen);
_canvasContainer.DrawOnCanvas(canvasType, _painterCommand);
UpdateCanvasView(canvasType);
}
//页面入栈，即把页面显示在界面上
public BasePanel PushPanel(UIPanelType panelType, CanvasType uiStayCanvas)
{
if (panelStack == null)//如果栈不存在，就实例化一个空栈
{
panelStack = new Stack <BasePanel>();
}
if (panelStack.Count > 0)
{
BasePanel topPanel = panelStack.Peek();//取出栈顶元素保存起来，但是不移除
if (topPanel != null)
{
topPanel.OnPause();//使该页面暂停，不可交互
}
else
{
panelStack.Pop();
}
}
BasePanel panelTemp = GetPanel(panelType, uiStayCanvas);
panelTemp.transform.SetAsLastSibling();
panelTemp.OnEnter();//页面进入显示，可交互
panelStack.Push(panelTemp);
DebugUI();
return(panelTemp);
}
public CanvasController GetControllerWithType(CanvasType type)
{
CanvasController controller;
controllersDic.TryGetValue(type, out controller);
return(controller);
}
public ColorNameResolver(CanvasType canvas)
{
switch (canvas)
{
case CanvasType.Earth:
colorEnum = typeof(EarthPixelColor);
break;
case CanvasType.Moon:
colorEnum = typeof(MoonPixelColor);
break;
case CanvasType.Voxel:
colorEnum = typeof(ThreeDimVoxelColor);
break;
case CanvasType.Covid:
colorEnum = typeof(CovidPixelColor);
break;
case CanvasType.OneBit:
colorEnum = typeof(MonochromePixelColor);
break;
case CanvasType.PixelZoneMirror:
case CanvasType.PixelCanvasMirror:
colorEnum = typeof(EmptyEnum);
break;
}
padLength = Enum.GetNames(colorEnum).Max(c => c.Length);
}
public CanvasObject AddCanvas(CanvasType type, string name)
{
var co = Creator.CreateCanvas(type, name);
_otherCanvas.Add(co);
return(co);
}
public void ToggleCanvas(CanvasType type)
{
Debug.Log("Toggle called on " + type.ToString());
CanvasController toggled = canvasControllerList.Find(canvas => canvas.canvasType == type);
if (toggled != null)
{
if (!toggled.isShown)
{
Debug.Log("Was hidden");
if (type == CanvasType.HUDCanvas)
{
Cursor.visible = false;
}
else
{
Cursor.visible = true;
}
toggled.gameObject.SetActive(true);
toggled.isShown = true;
if (type != CanvasType.HUDCanvas)
{
if (type != CanvasType.LoadingCanvas)
{
Time.timeScale = 0f;
Debug.Log("Time scale 0 and CursorConfined");
Cursor.lockState = CursorLockMode.Confined;
}
gameManager.gameIsPaused = true;
}
}
else
{
Debug.Log("Was shown");
if (type == CanvasType.HUDCanvas)
{
Cursor.visible = true;
}
else
{
Cursor.visible = false;
}
toggled.gameObject.SetActive(false);
toggled.isShown = false;
if (type != CanvasType.HUDCanvas)
{
if (type != CanvasType.LoadingCanvas)
{
Time.timeScale = 1f;
Cursor.lockState = CursorLockMode.Locked;
Debug.Log("Time scale 1 and Cursor Locked");
}
gameManager.gameIsPaused = false;
}
}
}
}
public void CloseTop(CanvasType type)
{
Stack <Panel> stack = this.GetStack(type);
Panel panel = stack.Pop();
panel.Close();
panel.UnListen();
}
public Transform GetCanvasTransform(CanvasType canvasType)
{
if (canvasType == CanvasType.UI)
{
return(UICanvasTransform);
}
return(GameCanvasTransform);
}
public void LoadCanvas(CanvasType type)
{
GameObject root_Canvas = GameObject.Find("Canvas");
GameObject canvas = Instantiate(Resources.Load <GameObject>("UI/" + type.ToString()));
canvas.transform.parent = root_Canvas.transform;
canvas.transform.localPosition = Vector3.zero;
}
/// <summary>
/// 显示页面，栈不发生变化
/// </summary>
/// <param name="panelType"></param>
/// <param name="uiStayCanvas"></param>
/// <returns></returns>
public BasePanel ShowPanel(UIPanelType panelType, CanvasType uiStayCanvas)
{
BasePanel panelTemp = GetPanel(panelType, uiStayCanvas);
panelTemp.transform.SetAsLastSibling();
panelTemp.OnEnter();//页面进入显示，可交互
DebugUI();
return(panelTemp);
}
public Transform GetCanvasTransform(CanvasType canvasType)
{
switch (canvasType)
{
case CanvasType.Window: return(WindowCanvas);
default:
throw new ArgumentOutOfRangeException(nameof(canvasType), canvasType, null);
}
}
/// <summary>
/// 將已經召喚的物件納入物件池中
/// </summary>
/// <param name="_ui"></param>
/// <returns></returns>
public bool LoginUI(MyUnityUIGroup _ui, CanvasType _type)
{
_ui.Transform.SetParent(GetCanvasByFrequence(_type).Transform);
if (uiPool.ContainsValue(_ui))
{
return(false);
}
uiPool.Add(_ui.name, _ui);
return(true);
}
private void ExecuteNewGameAction()
{
foreach (var canvasType in _gameCanvases)
{
_canvasContainer.ClearCanvas(canvasType);
UpdateCanvasView(canvasType);
}
_lastModifiedCanvas = CanvasType.Matrix11;
_game.ClearBoard();
}
public void OpenCanvasUI(CanvasType type)
{
if (canvasReference[type.CanvasTypeToIndex()] != null)
{
ActiveEventCall(); // 현재 열려있는 다른 canvas 닫기
canvasReference[type.CanvasTypeToIndex()].gameObject.SetActive(true);
_stackCanvasIndex.Push(type.CanvasTypeToIndex());
}
stackCount = _stackCanvasIndex.Count;
}
private static void LoadFile(string path)
{
using (FileStream fileStream = File.OpenRead(path))
{
byte version = 0;
using (BinaryReader reader = new BinaryReader(fileStream, Encoding.Default, true))
{
if (!options.OldRecordFile)
{
version = reader.ReadByte();
}
if (version == 1)
{
canvasType = (CanvasType)reader.ReadByte();
}
leftX = reader.ReadInt16();
topY = reader.ReadInt16();
rightX = reader.ReadInt16();
bottomY = reader.ReadInt16();
w = rightX - leftX + 1;
h = bottomY - topY + 1;
startTime = DateTime.FromBinary(reader.ReadInt64());
}
using (BinaryReader reader = new BinaryReader(fileStream))
{
long mapLength = reader.ReadInt64();
using (DeflateStream decompressingStream = new DeflateStream(fileStream, CompressionMode.Decompress, true))
{
using (BinaryReader decompressingReader = new BinaryReader(decompressingStream))
{
initialMapState = decompressingReader.ReadMap();
}
}
int metadataLength = sizeof(short) * 4 + sizeof(long) + sizeof(long); //rect boundaries, start time and map length
if (version == 1)
{
metadataLength += sizeof(byte) * 2; //version and canvas
}
fileStream.Seek(metadataLength + mapLength, SeekOrigin.Begin);
while (fileStream.Length - fileStream.Position > 1)
{
deltas.Add(reader.ReadDelta());
}
}
}
}
/// <summary>
/// 특정 Canvas를 On 할 때 호출.
/// </summary>
public void CanvasOn(CanvasType type, bool isEff = false)
{
if (isEff)
{
coroutine = CanvasOnEff(canvas[(int)type].transform);
StartCoroutine(coroutine);
}
else
{
canvas[(int)type].SetActive(true);
}
}
public void SetSoleCanvas(CanvasType c)
{
currentCanvas = c;
foreach (CanvasType ct in canvases.Keys)
{
if (ct != c)
{
canvases[ct].enabled = false;
}
}
canvases[c].enabled = true;
}
IEnumerator RoutineLoadScene(int sceneLevel, CanvasType type, BGMSoundType musicType)
{
_fadeAnim.Play(_fadeOutHash);
yield return(new WaitUntil(() => _fadeScreen.color.a == 1));
LoadSceneByIndex(sceneLevel);
CanvasManager.Instance.OpenCanvasUI(type);
_fadeAnim.Play(_fadeInHash);
AudioManager.Instance.PlayBGMSound(musicType);
yield return(new WaitUntil(() => _fadeScreen.color.a == 0));
}
public CanvasObject GetCanvas(CanvasType type)
{
if (canvas.ContainsKey(type)) return canvas[type];
return null;
}
