static extern bool ReadConsoleOutput( IntPtr hConsoleOutput, [Out] CHAR_INFO[,] lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, ref SMALL_RECT lpReadRegion );
/// <summary>Cosntructor</summary> public ConsoleProgressBar() { m_HConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE); m_barCoord = GetCursorPos(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); }
public static extern bool WriteConsoleOutput( IntPtr hConsoleOutput, /* This pointer is treated as the origin of a two-dimensional array of CHAR_INFO structures whose size is specified by the dwBufferSize parameter.*/ [MarshalAs(UnmanagedType.LPArray), In] CHAR_INFO[] lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, ref SMALL_RECT lpWriteRegion);
/// <summary>Cosntructor</summary> public ConsoleProgressBar() { // // TODO: Add constructor logic here. // mHConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE); barCoord = this.GetCursorPos(); Console.WriteLine(); Console.WriteLine(); Console.WriteLine(); }
public static bool InitConsole() { if (Application.platform != RuntimePlatform.WindowsPlayer) return false; AllocConsole(); SetConsoleCtrlHandler(null, true); StdOutHandle = GetStdHandle(unchecked((uint)STD_OUTPUT_HANDLE)); StdInHandle = GetStdHandle(unchecked((uint)STD_INPUT_HANDLE)); // 允许控制台右键菜单 uint dwConsoleMode = 0; GetConsoleMode(StdInHandle, out dwConsoleMode); SetConsoleMode(StdInHandle, ~ENABLE_MOUSE_INPUT & dwConsoleMode); // forbid close IntPtr hWnd = GetConsoleWindow(); IntPtr hMenu = GetSystemMenu(hWnd, 0); RemoveMenu(hMenu, SC_CLOSE, MF_BYCOMMAND); COORD BufferSize = new COORD() { X = 120, Y = 320, }; SMALL_RECT WinRect = new SMALL_RECT() { Left = 0, Top = 0, Right = (short)(BufferSize.X - 1), Bottom = 30, }; IntPtr pBuffer = Marshal.AllocHGlobal(Marshal.SizeOf(BufferSize)); Marshal.StructureToPtr(BufferSize, pBuffer, false); Debug.Log(SetConsoleScreenBufferSize(StdOutHandle, pBuffer)); Marshal.FreeHGlobal(pBuffer); IntPtr pWinRect = Marshal.AllocHGlobal(Marshal.SizeOf(WinRect)); Marshal.StructureToPtr(WinRect, pWinRect, false); Debug.Log(SetConsoleWindowInfo(StdOutHandle, true, pWinRect)); Marshal.FreeHGlobal(pWinRect); ConsoleAlive = true; Thread th = new Thread(new ThreadStart(WorkingThread)); th.Start(); return true; }
static private void SetPrompt(string prompt) { if (string.IsNullOrEmpty(prompt)) return; var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output); var lineCount = 1 + prompt.Count(c => c == '\n'); if (lineCount > 1) { var options = new SetPSReadlineOption {ExtraPromptLineCount = lineCount - 1}; PSConsoleReadLine.SetOptions(options); } int bufferWidth = Console.BufferWidth; var consoleBuffer = new CHAR_INFO[lineCount * bufferWidth]; int j = 0; for (int i = 0; i < prompt.Length; i++, j++) { if (prompt[i] == '\n') { for (; j % Console.BufferWidth != 0; j++) { consoleBuffer[j] = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor); } Console.CursorTop += 1; Console.CursorLeft = 0; j -= 1; // We don't actually write the newline } else { consoleBuffer[j] = new CHAR_INFO(prompt[i], Console.ForegroundColor, Console.BackgroundColor); Console.CursorLeft += 1; } } var bufferSize = new COORD { X = (short) bufferWidth, Y = (short) lineCount }; var bufferCoord = new COORD {X = 0, Y = 0}; var writeRegion = new SMALL_RECT { Top = 0, Left = 0, Bottom = (short) (lineCount - 1), Right = (short) bufferWidth }; NativeMethods.WriteConsoleOutput(handle, consoleBuffer, bufferSize, bufferCoord, ref writeRegion); }
//static ConsoleBuffer buffer; /// <summary> /// Maximizuje okno, hiduje kurzor, a nastavi kodovu stranku na 866, kde su nejake graficke znaky. googluj codepage 866 /// </summary> public static void FullScreen() { IntPtr hConsole = GetStdHandle(-11); // get console handle COORD xy = new COORD(100, 100); SetConsoleDisplayMode(hConsole, 1, out xy); // set the console to fullscreen System.Console.OutputEncoding = Encoding.GetEncoding(866); System.Console.CursorVisible = false; Wait(100); System.Console.BufferHeight = System.Console.WindowHeight; System.Console.BufferWidth = System.Console.WindowWidth; Width = System.Console.WindowWidth; Height = System.Console.WindowHeight; }
//istanza Random public Maze(int dimx, int dimy, int difficultyPercentage, int randomPercentage) { dim = new COORD(dimx, dimy); this.randomPercentage = (double)randomPercentage / 100; this.difficultyPercentage = (double)difficultyPercentage / 100; maze = new int[dimy, dimx]; for (int i = 0; i < dim.y; i++) { for (int j = 0; j < dim.x; j++) { maze[i, j] = 0; } } }
private static void ScrollBuffer(int lines) { var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output); var scrollRectangle = new SMALL_RECT { Top = (short) lines, Left = 0, Bottom = (short) (lines + Console.BufferHeight - 1), Right = (short)Console.BufferWidth }; var destinationOrigin = new COORD {X = 0, Y = 0}; var fillChar = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor); NativeMethods.ScrollConsoleScreenBuffer(handle, ref scrollRectangle, IntPtr.Zero, destinationOrigin, ref fillChar); }
public static IEnumerable <string> ReadFromBuffer(short x, short y, short width, short height) { IntPtr buffer = Marshal.AllocHGlobal(width * height * Marshal.SizeOf(typeof(CHAR_INFO))); if (buffer == null) { throw new OutOfMemoryException(); } try { COORD coord = new COORD(); SMALL_RECT rc = new SMALL_RECT(); rc.Left = x; rc.Top = y; rc.Right = (short)(x + width - 1); rc.Bottom = (short)(y + height - 1); COORD size = new COORD(); size.X = width; size.Y = height; const int STD_OUTPUT_HANDLE = -11; if (!ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE), buffer, size, coord, ref rc)) { // 'Not enough storage is available to process this command' may be raised for buffer size > 64K (see ReadConsoleOutput doc.) throw new Win32Exception(Marshal.GetLastWin32Error()); } IntPtr ptr = buffer; for (int h = 0; h < height; h++) { StringBuilder sb = new StringBuilder(); for (int w = 0; w < width; w++) { CHAR_INFO ci = (CHAR_INFO)Marshal.PtrToStructure(ptr, typeof(CHAR_INFO)); char[] chars = Console.OutputEncoding.GetChars(ci.charData); sb.Append(chars[0]); ptr += Marshal.SizeOf(typeof(CHAR_INFO)); } yield return(sb.ToString()); } } finally { Marshal.FreeHGlobal(buffer); } }
public static void CenterConsoleWindow(int Width, int Height) { Screen scr = Screen.PrimaryScreen; COORD FontSize = GetConsoleFontSize(); if (FontSize.X > 0 && FontSize.Y > 0) { int X = (scr.Bounds.Width - (Width * FontSize.X)) / 2; int Y = (scr.Bounds.Height - (Height * FontSize.Y)) / 2; IntPtr hWnd = GetConsoleWindow(); if (hWnd != IntPtr.Zero) { MoveWindow(hWnd, X, Y, Width * FontSize.X, Height * FontSize.Y, true); } } }
private List <COORD> CalcTargetTileCenter() { List <COORD> coords = null; int index = _path.nodes.Count - 1; while (index > 0) { MapAStar.NODE n = _path.nodes [index]; Vector2 nc = MapGrid.GetTileCenter(n.x, n.z); coords = CollectTilesInLine( _unit.transform.position.x, _unit.transform.position.z, nc.x, nc.y); bool blocked = false; for (int i = 1; i < coords.Count; ++i) { COORD coord = coords[i]; if (_mapGrid.IsBlock(coord.x, coord.z)) { blocked = true; break; } } if (!blocked) { // SetPathLineTiles(coords); break; } --index; } if (index == 0) { coords = new List <COORD>(); coords.Add(new COORD(_path.nodes [index].x, _path.nodes [index].z)); // SetPathLineTiles(coords); } MapAStar.NODE nodeShortPath = _path.nodes [index]; Vector2 centerShortPath = MapGrid.GetTileCenter(nodeShortPath.x, nodeShortPath.z); _targetTileCenter = new Vector3(centerShortPath.x, 0, centerShortPath.y); return(coords); }
private void StartCore() { if (!_attr.Sys.UseTty) { throw new Exception("Only a new process with controlled tty supported"); } _inputPipe = new Win32Pipe(); _outputPipe = new Win32Pipe(); var size = new COORD { X = DEFAULT_WIDTH, Y = DEFAULT_HEIGHT, }; var result = Kernel32.CreatePseudoConsole( size: size, hInput: _inputPipe.Read, hOutput: _outputPipe.Write, dwFlags: 0, phPC: out _ptyHandle ); if (result != 0) { throw new Win32Exception(result, "Could not create pseudo console."); } startupInfo = ConfigureProcessThread(_ptyHandle, (IntPtr)Kernel32.PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE); processInfo = RunProcess(ref startupInfo, _fileName); if (_attr.RedirectStdin) { var inStream = new FileStream(_inputPipe.Write, FileAccess.Write); Stdin = new StreamWriter(inStream); } if (_attr.RedirectStdout) { var outStream = new FileStream(_outputPipe.Read, FileAccess.Read); Stdout = new StreamReader(outStream); } Pid = processInfo.dwProcessId; IsRunning = true; }
public static char GetCharacterAtPosition(EngineFunctions.COORD pos) { IntPtr handler = GetStdHandle(STD_OUTPUT_HANDLE); uint width = 1; StringBuilder sb = new StringBuilder((int)width); COORD readCoord = new COORD(pos.X, pos.Y); uint numCharsRead = 0; if (!ReadConsoleOutputCharacter(handler, sb, width, readCoord, out numCharsRead)) { return((char)0); } else { return(sb.ToString()[0]); } }
public static CharInfo GetCharInfo(int x, int y) { COORD size = new COORD(1, 1); SMALL_RECT rect = new SMALL_RECT(new COORD((short)x, (short)y), size); CharInfo[,] chars = new CharInfo[1, 1]; WinApi.ReadConsoleOutput( bufferHandle, chars, size, new COORD(0, 0), ref rect ); CharInfo info = chars[0, 0]; return(info); }
public static IEnumerable<string> ReadFromBuffer(short x, short y, short width, short height) { IntPtr buffer = Marshal.AllocHGlobal(width * height * Marshal.SizeOf(typeof(CHAR_INFO))); if (buffer == null) throw new OutOfMemoryException(); try { COORD coord = new COORD(); SMALL_RECT rc = new SMALL_RECT(); rc.Left = x; rc.Top = y; rc.Right = (short)(x + width - 1); rc.Bottom = (short)(y + height - 1); COORD size = new COORD(); size.X = width; size.Y = height; const int STD_OUTPUT_HANDLE = -11; if (!ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE), buffer, size, coord, ref rc)) { // 'Not enough storage is available to process this command' may be raised for buffer size > 64K (see ReadConsoleOutput doc.) throw new Win32Exception(Marshal.GetLastWin32Error()); } IntPtr ptr = buffer; for (int h = 0; h < height; h++) { StringBuilder sb = new StringBuilder(); for (int w = 0; w < width; w++) { CHAR_INFO ci = (CHAR_INFO)Marshal.PtrToStructure(ptr, typeof(CHAR_INFO)); char[] chars = Console.OutputEncoding.GetChars(ci.charData); sb.Append(chars[0]); ptr += Marshal.SizeOf(typeof(CHAR_INFO)); } yield return sb.ToString(); } } finally { Marshal.FreeHGlobal(buffer); } }
/// <summary> /// Retrieve character from console window /// </summary> /// <param name="coordinate"></param> /// <param name="ptr"></param> /// <returns>One character</returns> public static char GetChar(COORD coordinate, IntPtr ptr) { // Convert the coordinates to a uint containing both uint coord = (uint)coordinate.X; coord |= (uint)coordinate.Y << 16; if (!ReadConsoleOutputCharacterW( ptr, out char chUnicode, // result: single Unicode char 1, // # of chars to read coord, // (X,Y) screen location to read (see above) out _)) // result: actual # of chars (unwanted) { throw new Win32Exception(); } return(chUnicode); }
public static void SetSize(int width, int height, int bufferHeight = -1) { if (width > 0 && width <= MaximumWidth && height > 0 && height <= MaximumHeight) { COORD bufferSize = GetConsoleBufferSize(); if (bufferSize.X > width || bufferSize.Y > height) { SetWindowSize( Math.Min(width, bufferSize.X) - 1, Math.Min(height, bufferSize.Y) - 1 ); } SetBufferSize(width, bufferHeight > 0 ? bufferHeight : height); SetWindowSize(width - 1, height - 1); } }
public static void CLS() { IntPtr hConsole = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi = new CONSOLE_SCREEN_BUFFER_INFO(); if (!GetConsoleScreenBufferInfo(hConsole, ref csbi)) { throw new ApplicationException("CLS não pode executado"); } long dwConSize = csbi.dwSize.X * csbi.dwSize.Y; COORD coordScreen = new COORD(); coordScreen.Y = coordScreen.X = 0; long cCharsWritten = 0; if (FillConsoleOutputCharacter(hConsole, ' ', dwConSize, coordScreen, ref cCharsWritten)) { throw new ApplicationException("CLS não pode executado"); } if (!GetConsoleScreenBufferInfo(hConsole, ref csbi)) { throw new ApplicationException("Problema no reposicionamento1"); } if (FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, ref cCharsWritten)) { throw new ApplicationException("Problema no reposicionamento2"); } if (!SetConsoleCursorPosition(hConsole, coordScreen)) { throw new ApplicationException("Problema no reposicionamento3"); } if (!CloseHandle(hConsole)) { throw new ApplicationException("Handle não liberado"); } }
private ConsoleEvent GetConsoleEvent() { // CONSIDER: Any reason to buffer more than one record in our Win32Console class? var records = new INPUT_RECORD[1]; uint count; if (!ReadConsoleInput(_handleIn, records, (uint)records.Length, out count)) { throw new Exception("ReadConsoleInput failed"); } var record = records[0]; switch (record.EventType) { case EventType.KEY_EVENT: { var keyEvent = record.KeyEvent; return(new KeyEvent(keyEvent.bKeyDown, keyEvent.UnicodeChar, keyEvent.wRepeatCount, keyEvent.wVirtualKeyCode, keyEvent.dwControlKeyState)); } case EventType.MOUSE_EVENT: { var mouseEvent = record.MouseEvent; return(new MouseEvent(mouseEvent.dwMousePosition.x, mouseEvent.dwMousePosition.y, mouseEvent.dwButtonState, mouseEvent.dwControlKeyState, mouseEvent.dwEventFlags)); } case EventType.WINDOW_BUFFER_SIZE_EVENT: { COORD size = record.WindowBufferSizeEvent.dwSize; return(new BufferSizeEvent(size.x, size.y)); } case EventType.FOCUS_EVENT: case EventType.MENU_EVENT: { // Ignore. return(null); } default: throw new Exception("Invalid EventType enum value"); } }
public static void DrawRectangle(int left, int top, int right, int bottom) { if (!AreScreenBufferArraysEqual(left, top, right, bottom)) { int rows = bottom - top + 1; int cols = right - left + 1; CHAR_INFO[] rectBuf = new CHAR_INFO[rows * cols]; int i = 0; for (int row = top; row <= bottom; row++) { for (int col = left; col <= right; col++) { rectBuf[i++] = ScreenBuffer.screenBuf[(row * ScreenBuffer.cols) + col]; } } COORD rectBufSize = new COORD() { X = (short)cols, Y = (short)rows }; COORD rectBufCoord = new COORD() { X = 0, Y = 0 }; SMALL_RECT rectangle = new SMALL_RECT() { Left = (short)left, Top = (short)top, Right = (short)right, Bottom = (short)bottom }; // note that the screen is NOT cleared at any point as this will simply // overwrite the existing values on screen. Clearing will cause flickering again. bool b = WriteConsoleOutput( ScreenBuffer.handle, rectBuf, rectBufSize, rectBufCoord, ref rectangle); Array.Copy(ScreenBuffer.screenBuf, ScreenBuffer.screenBufCopy, ScreenBuffer.screenBuf.Length); } }
public static GameObject[] CreateBattleTeam(InstanceTeam team, DataConfig.TEAM teamSide, COORD location, COORD playerLocation, float rotationDegree) { int n = team.units.Length; GameObject[] objects = new GameObject[n]; for (int i = 0; i < n; ++i) { InstanceUnit unit = team.units[i]; if (unit != null) { GameObject obj = CreateBattleUnit(unit, i, teamSide, location, playerLocation, rotationDegree); objects[i] = obj; } } return(objects); }
public void AddSelfToGrid() { COORD c = MapGrid.GetTileCoord(_unit.transform.position.x, _unit.transform.position.z); if (_mapGrid.IsInsideMap(c.x, c.z)) { _tiles.Add(c); _mapGrid.Add(c.x, c.z); } if (USER_SQUARE) { float r = _unit.unit.dataUnit.GetCollisionRadius(); COORD c1 = MapGrid.GetTileCoord(_unit.transform.position.x - r, _unit.transform.position.z); if (_mapGrid.IsInsideMap(c1.x, c1.z)) { _tiles.Add(c1); _mapGrid.Add(c1.x, c1.z); } COORD c2 = MapGrid.GetTileCoord(_unit.transform.position.x + r, _unit.transform.position.z); if (_mapGrid.IsInsideMap(c2.x, c2.z)) { _tiles.Add(c2); _mapGrid.Add(c2.x, c2.z); } COORD c3 = MapGrid.GetTileCoord(_unit.transform.position.x, _unit.transform.position.z - r); if (_mapGrid.IsInsideMap(c3.x, c3.z)) { _tiles.Add(c3); _mapGrid.Add(c3.x, c3.z); } COORD c4 = MapGrid.GetTileCoord(_unit.transform.position.x, _unit.transform.position.z + r); if (_mapGrid.IsInsideMap(c4.x, c4.z)) { _tiles.Add(c4); _mapGrid.Add(c4.x, c4.z); } } }
private static CHAR_INFO[] ReadBufferLines(int top, int count) { var result = new CHAR_INFO[Console.BufferWidth * count]; var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output); var readBufferSize = new COORD { X = (short)Console.BufferWidth, Y = (short)count}; var readBufferCoord = new COORD {X = 0, Y = 0}; var readRegion = new SMALL_RECT { Top = (short)top, Left = 0, Bottom = (short)(top + count), Right = (short)(Console.BufferWidth - 1) }; NativeMethods.ReadConsoleOutput(handle, result, readBufferSize, readBufferCoord, ref readRegion); return result; }
public static void Draw(CHAR_INFO[] buffer, int width, int height, int x = 0, int y = 0) { COORD bufferSize = new COORD(); bufferSize.x = (short)width; bufferSize.y = (short)height; COORD bufferCoord = new COORD(); bufferCoord.x = 0; bufferCoord.y = 0; SMALL_RECT lpWriteRegion = new SMALL_RECT(); lpWriteRegion.Left = (short)x; lpWriteRegion.Top = (short)y; lpWriteRegion.Bottom = (short)(y + height); lpWriteRegion.Right = (short)(x + width); WriteConsoleOutputW(handle, buffer, bufferSize, bufferCoord, ref lpWriteRegion); }
public static void Draw() { COORD bufferSize = new COORD(); bufferSize.x = (short)Width; bufferSize.y = (short)Height; COORD bufferCoord = new COORD(); bufferCoord.x = 0; bufferCoord.y = 0; SMALL_RECT lpWriteRegion = new SMALL_RECT(); lpWriteRegion.Left = 0; lpWriteRegion.Top = 0; lpWriteRegion.Bottom = (short)(Height); lpWriteRegion.Right = (short)(Width); WriteConsoleOutputW(handle, screen_buffer, bufferSize, bufferCoord, ref lpWriteRegion); }
public void Blit(Rectangle rect) { COORD sz = new COORD(); sz.X = (short)consize.Width; sz.Y = (short)consize.Height; COORD pos = new COORD(); pos.X = (short)rect.X; pos.Y = (short)rect.Y; SMALL_RECT rgn = new SMALL_RECT(); rgn.Left = (short)rect.X; rgn.Top = (short)rect.Y; rgn.Right = (short)(rect.X + rect.Width - 1); rgn.Bottom = (short)(rect.Y + rect.Height - 1); bool success = WriteConsoleOutput(output, buf, sz, pos, ref rgn); }
static ConsoleEx() { // Grab input and output buffer handles hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE); hConsoleInput = GetStdHandle(STD_INPUT_HANDLE); if (hConsoleOutput == INVALID_HANDLE_VALUE || hConsoleInput == INVALID_HANDLE_VALUE) { throw new ApplicationException("Unable to obtain buffer handle during initialization."); } // Get information about the console window characteristics. ConsoleInfo = new CONSOLE_SCREEN_BUFFER_INFO(); ConsoleOutputLocation = new COORD(); GetConsoleScreenBufferInfo(hConsoleOutput, ref ConsoleInfo); OriginalConsolePen = ConsoleInfo.wAttributes; // Disable wrapping at the end of a line (ENABLE_WRAP_AT_EOL_INPUT); this enables rectangles // to be drawn that fill the screen without the window scrolling. SetConsoleMode(hConsoleOutput, (int)OutputModeFlags.ENABLE_PROCESSED_OUTPUT); }
private bool IsDestinationBlocked(Vector3 destination) { //should already remove self grid block, so don't need to check whether grid is change //that means if unit alread inside a grid is blocked, then it is blocked by other unit // COORD c1 = MapGrid.GetTileCoord (_owner.transform.position.x, _owner.transform.position.z); COORD c2 = MapGrid.GetTileCoord(destination.x, destination.z); // if(c1.IsEqual(c2)) // { // return false; // } if (_game.mapGrid.IsBlock(c2.x, c2.z)) { return(true); } else { return(false); } }
private void ValidatePositions() { COORD[] positions = new COORD[5]; positions [0] = startPosition; positions [1] = extraPositionA; positions [2] = extraPositionB; positions [3] = extraPositionC; positions [4] = extraPositionD; for (int i = 0; i < positions.Length; ++i) { for (int j = i + 1; j < positions.Length; ++j) { if (positions[i] != null && positions[j] != null) { int dx = positions[i].x - positions[j].x; int dz = positions[i].z - positions[j].z; Assert.assert(Mathf.Abs(dx) >= 3 || Mathf.Abs(dz) >= 3); } } } }
/// <summary> /// Copies a given character to a rectangular region of the screen /// buffer. /// </summary> /// <param name="rectangle">A Rectangle structure that defines the area to be filled.</param> /// <param name="fill">A BufferCell structure that defines the fill character.</param> public override void SetBufferContents(Rectangle rectangle, BufferCell fill) { var stdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = new COORD() { X = (short)rectangle.Top, Y = (short)rectangle.Left }; var rows = rectangle.Top - rectangle.Bottom; var cols = rectangle.Right - rectangle.Left; uint length = (uint)(rows * cols); if (length == 0) { length = (uint)(Console.BufferWidth * Console.BufferHeight); coord = new COORD() { X = 0, Y = 0 }; } uint written; int res = FillConsoleOutputCharacter(stdOut, fill.Character, length, coord, out written); }
// Update is called once per frame public void Update() { if (_hasPath) { COORD currentCoord = MapGrid.GetTileCoord(_unit.transform.position.x, _unit.transform.position.z); COORD targetCoord = MapGrid.GetTileCoord(_targetTileCenter.x, _targetTileCenter.z); if (currentCoord.IsEqual(targetCoord)) { _hasPath = false; } /* * foreach(MapAStar.NODE node in _path.nodes) * { * if(tileCoord.x == node.x && tileCoord.z == node.z) * { * _hasPath = false; * break; * } * } */ } }
public void InitShowTile() { GameObject root = new GameObject(); root.name = "HEXAGON_ROOT"; _tileObjects = new GameObject[MAP_GRID_COUNT_X * MAP_GRID_COUNT_Z]; string asset = AppConfig.FOLDER_PROFAB + "tile/hexagon"; Object profab = Resources.Load(asset); for (int x = 0; x < MAP_GRID_COUNT_X; ++x) { for (int z = 0; z < MAP_GRID_COUNT_Z; ++z) { GameObject tile = GameObject.Instantiate(profab) as GameObject; tile.transform.parent = root.transform; tile.transform.localScale = new Vector3(1.732f * HEXAGON_L, 0.1f, 1.732f * HEXAGON_L); Vector2 tileCenter = GetTileCenter(x, z); if (AppConfig.DEBUGGING) { //validate tile coord <-> pos algorithm COORD tileCoord = GetTileCoord(tileCenter.x, tileCenter.y); if (tileCoord.x != x || tileCoord.z != z) { Assert.assert(false); } } tile.transform.position = new Vector3(tileCenter.x, 0, tileCenter.y); _tileObjects[GetGridIndex(x, z)] = tile; } } }
public void InitShowTile() { GameObject root = new GameObject(); root.name = "HEXAGON_ROOT"; _tileObjects = new GameObject[mapGridWidth * mapGridHeight]; string asset = AppConfig.FOLDER_PROFAB + "tile/square"; Object profab = Resources.Load(asset); for (int x = 0; x < mapGridWidth; ++x) { for (int z = 0; z < mapGridHeight; ++z) { GameObject tile = GameObject.Instantiate(profab) as GameObject; tile.transform.parent = root.transform; tile.transform.localScale = new Vector3(GRID_SIZE - 0.5f, 0.1f, GRID_SIZE - 0.5f); Vector2 tileCenter = GetTileCenter(x, z); if (AppConfig.DEBUGGING) { //validate tile coord <-> pos algorithm COORD tileCoord = GetTileCoord(tileCenter.x, tileCenter.y); if (tileCoord.x != x || tileCoord.z != z) { Assert.assert(false); } } tile.transform.position = new Vector3(tileCenter.x, 0, tileCenter.y); _tileObjects[GetGridIndex(x, z)] = tile; } } }
private void processInputEvent(INPUT_RECORD inputRecord) { if (inputRecord.EventType == EventType.WINDOW_BUFFER_SIZE_EVENT) { if (usingLinux) { // Reinitializing ncurses to deal with new dimensions // http://stackoverflow.com/questions/13707137/ncurses-resizing-glitch NCurses.endwin(); // Needs to be called after an endwin() so ncurses will initialize // itself with the new terminal dimensions. NCurses.refresh(); NCurses.clear(); } COORD dwSize = inputRecord.WindowBufferSizeEvent.dwSize; // Invoke default handler if no custom handlers attached and // userCanvasSize and userRootElementRect are not defined if (TerminalSizeChanged == null && userCanvasSize.IsEmpty && userRootElementRect.IsEmpty) { OnTerminalSizeChangedDefault(this, new TerminalSizeChangedEventArgs(dwSize.X, dwSize.Y)); } else if (TerminalSizeChanged != null) { TerminalSizeChanged.Invoke(this, new TerminalSizeChangedEventArgs(dwSize.X, dwSize.Y)); } // Refresh whole display renderer.FinallyApplyChangesToCanvas(true); return; } eventManager.ParseInputEvent(inputRecord, mainControl); }
public static GameObject[][] CreateBattleUnits(InstanceBattle battle, DataMap dataMap) { int totalGroup = 1 + battle.extraTeamCount; GameObject[][] objects = new GameObject[totalGroup][]; GameObject[] myObjects = CreateBattleTeam(battle.myTeam, DataConfig.TEAM.MY, dataMap.startPosition, dataMap.startPosition, battle.mission.playerRotation); objects [0] = myObjects; for (int i = 1; i < totalGroup; ++i) { int teamIndex = i - 1; COORD location = dataMap.GetExtraPosition(teamIndex); InstanceTeam enemyTeam = battle.enemyTeams[teamIndex]; InstanceTeam friendTeam = battle.friendTeams[teamIndex]; Assert.assert(enemyTeam == null || friendTeam == null); float teamRotation = battle.mission.teamsRotation[teamIndex]; GameObject[] members = null; if (enemyTeam != null) { Assert.assert(location != null); members = CreateBattleTeam(enemyTeam, DataConfig.TEAM.ENEMY, location, dataMap.startPosition, teamRotation); } if (friendTeam != null) { Assert.assert(location != null); members = CreateBattleTeam(friendTeam, DataConfig.TEAM.FRIEND, location, dataMap.startPosition, teamRotation); } objects [i] = members; } return(objects); }
public static extern bool SetConsoleDisplayMode( IntPtr ConsoleOutput, uint Flags, out COORD NewScreenBufferDimensions );
public string readvalue(ref System.IntPtr ptr, short a) { SMALL_RECT srctReadRect = new SMALL_RECT { Top = 0, Left = 0, Bottom = 1, Right = 80 }; CHAR_INFO[,] chiBuffer = new CHAR_INFO[2, 80]; // [2][80];10 lines, with 50 characters COORD coordBufSize = new COORD { X = 80, Y = 2 }; COORD coordBufCoord = new COORD { X = 0, Y = 0 }; bool fSuccess; int i = 0; int j = 0; string chartostring = "start"; string previousstring = ""; short g = a; short h = (short)(g + 1); srctReadRect.Top = g; srctReadRect.Bottom = h; int count = 0; //System.Console.WriteLine(g + "." + h); while (count < 1)//Hunting:if it find 1 empty rows with text then it will stop reading { previousstring = chartostring; srctReadRect.Top = g; srctReadRect.Bottom = h; fSuccess = ReadConsoleOutput(ptr, chiBuffer, coordBufSize, coordBufCoord, ref srctReadRect); i = 0; j = 0; chartostring = ""; while (j < coordBufSize.Y) { while (i < coordBufSize.X) { if (chiBuffer[j, i].UnicodeChar != 0 && chiBuffer[j, i].UnicodeChar != 32) chartostring += chiBuffer[j, i].UnicodeChar; i++; } i = 0; j++; } if (chartostring.Length == 0)//The character length is zero, reverse the top of the source rect { count++; } else { count = 0; } g += 1; h += 1; } return previousstring; }
internal static extern bool SetConsoleCursorPosition(IntPtr hConsoleOutput, COORD cursorPosition);
internal static unsafe extern bool WriteConsoleOutput(IntPtr hConsoleOutput, CHAR_INFO* buffer, COORD bufferSize, COORD bufferCoord, ref SMALL_RECT writeRegion);
public static extern bool WriteConsoleOutputCharacter( IntPtr hConsoleOutput, string lpCharacter, uint nLength, COORD dwWriteCoord, out uint lpNumberOfCharsWritten );
public static extern bool WriteConsoleOutputAttribute( IntPtr hConsoleOutput, ushort[] lpAttribute, uint nLength, COORD dwWriteCoord, out uint lpNumberOfAttrsWritten );
public static extern bool WriteConsoleOutput( IntPtr hConsoleOutput, CHAR_INFO[] lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, ref SMALL_RECT lpWriteRegion );
public static extern bool SetConsoleScreenBufferSize( IntPtr hConsoleOutput, COORD dwSize );
private static extern int FillConsoleOutputCharacter(int hConsoleOutput, byte cCharacter, int nLength, COORD dwWriteCoord, ref int lpNumberOfCharsWritten);
private int ConvertLineAndColumnToOffset(COORD coord) { int offset; int x = _initialX; int y = _initialY + Options.ExtraPromptLineCount; int bufferWidth = _console.BufferWidth; var continuationPromptLength = Options.ContinuationPrompt.Length; for (offset = 0; offset < _buffer.Length; offset++) { // If we are on the correct line, return when we find // the correct column if (coord.Y == y && coord.X <= x) { return offset; } char c = _buffer[offset]; if (c == '\n') { // If we are about to move off of the correct line, // the line was shorter than the column we wanted so return. if (coord.Y == y) { return offset; } y += 1; x = continuationPromptLength; } else { int size = LengthInBufferCells(c); x += size; // Wrap? No prompt when wrapping if (x >= bufferWidth) { int offsize = x - bufferWidth; if (offsize % size == 0) { x -= bufferWidth; } else { x = size; } y += 1; } } } // Return -1 if y is out of range, otherwise the last line was shorter // than we wanted, but still in range so just return the last offset. return (coord.Y == y) ? offset : -1; }
internal static extern bool FillConsoleOutputCharacter(IntPtr hConsoleOutput, char character, int nLength, COORD dwWriteCoord, out int pNumCharsWritten);
static extern bool ReadConsoleOutputCharacter(IntPtr hConsoleOutput, [Out] StringBuilder lpCharacter, uint nLength, COORD dwReadCoord, out uint lpNumberOfCharsRead);
public static extern bool WriteConsoleOutputCharacter( IntPtr hConsoleOutput, // handle to screen buffer string lpCharacter, // characters uint nLength, // number of characters to write COORD dwWriteCoord, // first cell coordinates ref uint lpNumberOfCharsWritten // number of cells written );
internal static extern bool SetConsoleScreenBufferSize(IntPtr hConsoleOutput, COORD size);
public static extern bool ScrollConsoleScreenBuffer( IntPtr hConsoleOutput, [In] ref SMALL_RECT lpScrollRectangle, IntPtr lpClipRectangle, COORD dwDestinationOrigin, [In] ref CHAR_INFO lpFill );
internal static extern bool FillConsoleOutputAttribute(IntPtr hConsoleOutput, short wColorAttribute, int numCells, COORD startCoord, out int pNumBytesWritten);
public static extern bool FillConsoleOutputAttribute(IntPtr Handle, short att, int Len, COORD start, ref int writted);
internal static unsafe extern bool ReadConsoleOutput(IntPtr hConsoleOutput, CHAR_INFO* pBuffer, COORD bufferSize, COORD bufferCoord, ref SMALL_RECT readRegion);
public static extern int FillConsoleOutputCharacter(IntPtr Handle, char uChar, int Len, COORD start, ref int written);
private static extern int SetConsoleCursorPosition(int hConsoleOutput, COORD dwCursorPosition);
public static extern bool ReadConsoleOutputAttribute( IntPtr hConsoleOutput, [Out] ushort[] lpAttribute, uint nLength, COORD dwReadCoord, out uint lpNumberOfAttrsRead );
internal static extern bool FillConsoleOutputAttribute(IntPtr hConsole, ushort wAttributes, int nLength, COORD dwWriteCoord, out uint written);
public static extern bool SetConsoleCursorPosition( IntPtr hConsoleOutput, COORD dwCursorPosition );
// Constructor. public ColorConsole() { ConsoleInfo = new CONSOLE_SCREEN_BUFFER_INFO(); ConsoleOutputLocation = new COORD(); hConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE); GetConsoleScreenBufferInfo(hConsoleHandle, ref ConsoleInfo); OriginalColors = ConsoleInfo.wAttributes; }