public void UpdateSize(Vector2 _consoleSize, int fontSize)
{
SetFontSize(fontSize);
if (_consoleSize.X <= 0 || _consoleSize.Y <= 0)
{
return;
}
if (_consoleSize.X > Console.LargestWindowWidth || _consoleSize.Y > Console.LargestWindowHeight)
{
return;
}
consoleSize = _consoleSize;
sWidth = consoleSize.X;
sHeight = consoleSize.Y;
screen = new Pixel[sWidth * sHeight];
screenSize = new ScreenSize()
{
Left = 0, Top = 0, Right = (ushort)sWidth, Bottom = (ushort)sHeight
};
handle = CreateFile("CONOUT$", 0x40000000, 2, IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero);
try
{
Console.SetWindowSize(consoleSize.X, consoleSize.Y);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
}
return;
}
public static void ChangeSize(ScreenSize size)
{
var form = Application.OpenForms[0];
var browserForm = (BrowserForm)form;
browserForm.ChangeSize(size);
}
public void Init(Vector2 _consoleSize, int fontSize)
{
SetFontSize(fontSize);
Console.OutputEncoding = System.Text.Encoding.UTF8;
//Save console settings
consoleSize = _consoleSize;
//Apply scale for init
Console.SetWindowSize(consoleSize.X, consoleSize.Y);
sWidth = consoleSize.X;
sHeight = consoleSize.Y;
objects = new List <Object>();
//Setup screen buffer
screen = new Pixel[sWidth * sHeight];
screenSize = new ScreenSize()
{
Left = 0, Top = 0, Right = (ushort)sWidth, Bottom = (ushort)sHeight
};
handle = CreateFile("CONOUT$", 0x40000000, 2, IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero);
initialized = true;
return;
}
/// <summary>
/// Draw 7-seg image
/// </summary>
/// <param name="dp"></param>
/// <param name="format"></param>
/// <remarks>
/// Format:
/// 0-9 ... draw number
/// * ... draw Dark 8
/// . ... draw Dot at last position
/// , ... draw Dot at last position (dark)
/// : ... draw colon
/// ; ... draw colon(dark)
/// ! ... draw half space
/// _ ... draw space
/// \b ... back space (1/4)
/// </remarks>
public void Draw(DrawProperty dp, string format, ScreenPos pos, ScreenY height)
{
if (LoadStatus != 1)
{
return;
}
var x = ScreenX.From(0);
var sz0 = ScreenSize.From(Bitmaps['*'].SizeInPixels.Width, Bitmaps['*'].SizeInPixels.Height);
var z = height / sz0.Height;
var sz = sz0 * z;
var sr = ScreenRect.FromLTWH(0, 0, sz.Width, sz.Height);
foreach (var c in format)
{
if (SpaceAdjust.TryGetValue(c, out var adjust))
{
x += sz.Width * adjust;
}
var bmp = Bitmaps.GetValueOrDefault(c, null);
if (bmp != null)
{
dp.Graphics.DrawImage(bmp, _(sr + pos + x));
}
x += sz.Width;
}
}
/// <summary>
/// Initialize feature
/// </summary>
public override void OnInitialInstance()
{
base.OnInitialInstance();
Pane.Target = Pane["ToolBox"];
// Tool box background
Parts.Add(Pane.Target, new PartsToolBox {
}, LAYER.ToolButtonBox);
var x = ScreenX.From(0);
var y = ScreenY.From(48);
var btnSize = ScreenSize.From(24, 24);
var marginY = ScreenY.From(8);
for (var i = 0; i < Buttons.Count; i++)
{
var btn = Buttons[i];
btn.Name = string.IsNullOrEmpty(btn.Name) ? btn.GetType().Name : btn.Name;
btn.Size = btnSize;
btn.Location = CodePos <ScreenX, ScreenY> .From(x, y);
var dmy = btn.Load(View); // dmy = thread control
Parts.Add(Pane.Target, btn, LAYER.ToolButtons);
y += btnSize.Height + marginY;
}
}
private static ScreenSize GetScreenSize()
{
if (screenSizeInitialised)
{
return(screenSize);
}
float shortSideDP = PixelToDp(GetShortSide());
ScreenSize size;
if (shortSideDP > 500)
{
size = DisplayMetricsUtil.ScreenSize.tablet;
}
else if (shortSideDP < 300)
{
size = DisplayMetricsUtil.ScreenSize.smartphoneSmall;
}
else
{
size = DisplayMetricsUtil.ScreenSize.smartphone;
}
screenSize = size;
screenSizeInitialised = true;
return(size);
}
/// <summary>
/// fetches a tilemap. this is simple; apparently only the screen size (shape) is a factor (not the tile size)
/// </summary>
public TileEntry[] FetchTilemap(int addr, ScreenSize size)
{
var blockDims = SizeInBlocksForBGSize(size);
int blocksw = blockDims.Width;
int blocksh = blockDims.Height;
int width = blockDims.Width * 32;
int height = blockDims.Height * 32;
TileEntry[] buf = new TileEntry[width * height];
for (int by = 0; by < blocksh; by++)
{
for (int bx = 0; bx < blocksw; bx++)
{
for (int y = 0; y < 32; y++)
{
for (int x = 0; x < 32; x++)
{
int idx = (by * 32 + y) * width + bx * 32 + x;
ushort entry = *(ushort *)(vram + addr);
buf[idx].tilenum = (ushort)(entry & 0x3FF);
buf[idx].palette = (byte)((entry >> 10) & 7);
buf[idx].flags = (TileEntryFlags)((entry >> 13) & 7);
buf[idx].address = addr;
addr += 2;
}
}
}
}
return(buf);
}
public void ChangeSize(ScreenSize size)
{
if (this.InvokeRequired)
{
// This is a worker thread so delegate the task.
this.Invoke(new ChangeSizeDelegate(this.ChangeSize), size);
}
else
{
// This is the UI thread so perform the task.
var height = 0;
var width = 0;
switch (size)
{
case ScreenSize.L:
height = Screen.PrimaryScreen.WorkingArea.Height;
width = Screen.PrimaryScreen.WorkingArea.Width;
break;
case ScreenSize.M:
height = Convert.ToInt32(Screen.PrimaryScreen.WorkingArea.Height * 0.75);
width = Convert.ToInt32(Screen.PrimaryScreen.WorkingArea.Width * 0.75);
break;
case ScreenSize.S:
height = Convert.ToInt32(Screen.PrimaryScreen.WorkingArea.Height * 0.5);
width = Convert.ToInt32(Screen.PrimaryScreen.WorkingArea.Width * 0.5);
break;
}
this.Height = height;
this.Width = width;
}
}
protected Utility(IntPtr hwnd, ScreenSize size)
{
this.SC2hwnd = hwnd;
this.mem = new ReadWriteMemory(this.SC2hwnd);
this.ChangeSize(size);
this.debug = /*Debugger.IsAttached*/ false;
}
public void UpdateViewerSize()
{
if (_frmFullscreenRenderer != null)
{
return;
}
if (HideMenuStrip)
{
_menu.Visible = false;
}
ScreenSize screenSize = EmuApi.GetScreenSize(false);
if (_resizeForm && _frm.WindowState != FormWindowState.Maximized)
{
_frm.Resize -= frmMain_Resize;
Size newSize = new Size(screenSize.Width, screenSize.Height);
_frm.ClientSize = new Size(newSize.Width, newSize.Height + (HideMenuStrip ? 0 : _panel.Top));
_frm.Resize += frmMain_Resize;
}
_renderer.Size = new Size(screenSize.Width, screenSize.Height);
_renderer.Top = (_panel.Height - _renderer.Height) / 2;
_renderer.Left = (_panel.Width - _renderer.Width) / 2;
}
public override void Draw(DrawProperty dp)
{
if (Seg7?.IsLoaded == false)
{
return;
}
var pos = dp.PaneRect.RB - ScreenSize.From(420, 40);
var now = Parent.Now;
Seg7.Draw(dp, "****,!**,!**_**\b;\b**\b;\b**", pos, Height);
if (now != DateTime.MinValue)
{
var timestr = $"{now.Year}.!{StrUtil.Right($"_{now.Month}", 2)}.!{StrUtil.Right($"_{now.Day}", 2)}_{StrUtil.Right($"_{now.Hour}", 2)}\b:\b{StrUtil.Right($"0{now.Minute}", 2)}\b:\b{StrUtil.Right($"0{now.Second}", 2)}";
Seg7.Draw(dp, timestr, pos, Height);
// Sim Time Caption
dp.Graphics.DrawText($"Sim time :", pos.X - ScreenX.From(8), pos.Y + ScreenY.From(20), Colors.Cyan, new CanvasTextFormat
{
FontFamily = "Tahoma",
FontSize = 11f,
FontWeight = FontWeights.Normal,
HorizontalAlignment = CanvasHorizontalAlignment.Right,
});
}
// Current Local Time
dp.Graphics.DrawText($"Actual time : {DateTime.Now.ToString(TimeUtil.FormatYMDHMS)}", dp.PaneRect.R - ScreenX.From(64), pos.Y - ScreenY.From(24), Colors.DarkGray, new CanvasTextFormat
{
FontFamily = "Tahoma",
FontSize = 11f,
FontWeight = FontWeights.Normal,
HorizontalAlignment = CanvasHorizontalAlignment.Right,
});
}
public void EngSetScreenSize(ScreenSize screenSize)
{
switch (screenSize)
{
case ScreenSize.SMALL:
Width = SCREEN_SIZE_SMALL_WIDTH;
Height = SCREEN_SIZE_SMALL_HEIGHT;
break;
case ScreenSize.MEDIUM:
Width = SCREEN_SIZE_MEDIUM_WIDTH;
Height = SCREEN_SIZE_MEDIUM_HEIGHT;
break;
case ScreenSize.LARGE:
Width = SCREEN_SIZE_LARGE_WIDTH;
Height = SCREEN_SIZE_LARGE_HEIGHT;
break;
case ScreenSize.FULLSCREEN:
this.FormBorderStyle = FormBorderStyle.None;
this.WindowState = FormWindowState.Maximized;
break;
default:
Console.WriteLine("Default case");
break;
}
CenterToScreen();
}
public void OnValueChangedScreen()
{
CurrentScreenSize = (ScreenSize)ScreenSizeSelector.GetComponent <Dropdown>().value;
// change screen size code here
switch ((int)CurrentScreenSize)
{
case 0: //1024x768
if (Screen.width != 1024 || Screen.height != 768)
{
Screen.SetResolution(1024, 768, false);
Debug.Log("setting to 1024x768");
}
break;
case 1: //1280x800
if (Screen.width != 1280 || Screen.height != 800)
{
Screen.SetResolution(1280, 800, false);
Debug.Log("setting to 1280x800");
}
break;
case 2: //1280x960
if (Screen.width != 1280 || Screen.height != 960)
{
Screen.SetResolution(1280, 960, false);
Debug.Log("setting to 1280x960");
}
break;
default:
Debug.LogWarning("why am i here?");
break;
}
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
// TODO: Add your update logic here
if (ScreenSize.Contains(player2.HitBox) && stopwatch.ElapsedMilliseconds < 1000)
{
player2.Speed = (int)ball.Speed.Y;
}
else if (stopwatch.ElapsedMilliseconds > 5000)
{
stopwatch.Reset();
}
player1.MoveUpDown(Keyboard.GetState().IsKeyDown(Keys.W), Keyboard.GetState().IsKeyDown(Keys.S),
GraphicsDevice.Viewport.Y, GraphicsDevice.Viewport.Height);
player2.AutoMoveUpDown(GraphicsDevice.Viewport.Y, GraphicsDevice.Viewport.Height);
ball.Move(ScreenSize);
BallAndPaddleReaction(ball, player1, player2);
CheckScore();
ScoreKeeper.UpdateScore(player1.Score, player2.Score);
base.Update(gameTime);
}
public static ScreenSize GetRatio()
{
float ratio = (float)Screen.width / (float)Screen.height;
ScreenSize size = ScreenSize.SIZE_5TO4;
if (Mathf.Abs(ratio - 16f / 9f) < 0.01f)
{
size = ScreenSize.SIZE_16TO9;
}
else if (Mathf.Abs(ratio - 16f / 10f) < 0.01f)
{
size = ScreenSize.SIZE_16TO10;
}
else if (Mathf.Abs(ratio - 3f / 2f) < 0.01f)
{
size = ScreenSize.SIZE_3TO2;
}
else if (Mathf.Abs(ratio - 4f / 3f) < 0.01f)
{
size = ScreenSize.SIZE_4TO3;
}
else if (Mathf.Abs(ratio - 5f / 4f) < 0.01f)
{
size = ScreenSize.SIZE_5TO4;
}
return(size);
}
/// <summary>
/// Sets the screen's size
/// </summary>
public ScreenImplementation()
{
var displayMetrics = Resources.System.DisplayMetrics;
var height = displayMetrics.HeightPixels / displayMetrics.Density;
var width = displayMetrics.WidthPixels / displayMetrics.Density;
Size = new ScreenSize(true, width, height);
}
private static AButton[] GetButtons(ContentManager content, GraphicsDeviceManager graphics)
{
return(new AButton[]
{
new ActionButton(content, 620, 320, 260, 50, new[] { VideoMenu.Fullscreen + ScreenSize.IsFullScreen() }, () =>
{
ScreenSize.ChangeSize(graphics); //TODO reload game HUD
}, default, new List <Screen> {
public void SetScale(double scale)
{
VideoConfig.VideoScale = scale;
ApplyVideoConfig();
ScreenSize size = SnesApi.GetScreenSize(false);
_renderControl.Size = new Size(size.Width, size.Height);
}
public static SmartClicker GetInstance(IntPtr hwnd, ScreenSize size)
{
if ((hwnd == IntPtr.Zero) || !Utility.supported.Contains(size))
{
return(null);
}
return(instance ?? new SmartClicker(hwnd, size));
}
public static Dimensions SizeInTilesForBGSize(ScreenSize size)
{
if (size == ScreenSize.Hacky_1x1) return new Dimensions(1, 1);
var ret = SizeInBlocksForBGSize(size);
ret.Width *= 32;
ret.Height *= 32;
return ret;
}
/// <summary>
/// title bar design
/// </summary>
/// <param name="dp"></param>
/// <param name="sr">log panel drawing area</param>
/// <returns></returns>
protected virtual ScreenY drawTitleBar(DrawProperty dp, ScreenRect sr)
{
var _bd = new CanvasSolidColorBrush(dp.Canvas, Color.FromArgb(64, 0, 0, 0));
var titleHeight = 8;
var w3 = sr.Width / 4;
var pst = new ScreenPos[] { ScreenPos.From(sr.LT.X, sr.LT.Y + titleHeight + 16), ScreenPos.From(sr.LT.X, sr.LT.Y), ScreenPos.From(sr.RB.X, sr.LT.Y), };
var psb = new ScreenPos[] { ScreenPos.From(sr.RB.X, sr.LT.Y + titleHeight), ScreenPos.From(sr.RB.X - w3, sr.LT.Y + titleHeight + 2), ScreenPos.From(sr.RB.X - w3 * 2, sr.LT.Y + titleHeight + 8), ScreenPos.From(sr.RB.X - w3 * 3, sr.LT.Y + titleHeight + 16), ScreenPos.From(sr.LT.X, sr.LT.Y + titleHeight + 16), };
var ps = pst.Union(psb).ToList();
var path = new CanvasPathBuilder(dp.Canvas);
path.BeginFigure(ps[0]);
for (var i = 1; i < ps.Count; i++)
{
path.AddLine(ps[i]);
}
path.EndFigure(CanvasFigureLoop.Closed);
var geo = CanvasGeometry.CreatePath(path);
dp.Graphics.FillGeometry(geo, _bd);
// edge highlight
for (var i = 1; i < pst.Length; i++)
{
dp.Graphics.DrawLine(pst[i - 1], pst[i], Color.FromArgb(96, 255, 255, 255));
}
// edge shadow
for (var i = 1; i < psb.Length; i++)
{
dp.Graphics.DrawLine(psb[i - 1], psb[i], Color.FromArgb(96, 0, 0, 0));
}
// title bar design
var btr = sr.Clone();
btr.RB = ScreenPos.From(btr.LT.X + ScreenX.From(24), btr.LT.Y + ScreenY.From(12));
btr = btr + ScreenPos.From(4, 4);
var imgttl = Assets.Image("LogPanelTitileDesign");
if (imgttl != null)
{
dp.Graphics.DrawImage(imgttl, btr.LT + ScreenSize.From(-3, -14));
}
btr = btr + ScreenX.From(50);
// title filter buttons
var btn1 = Assets.Image("btnLogPanel");
var btn0 = Assets.Image("btnLogPanelOff");
if (btn1 != null && btn0 != null)
{
var ctfb = new CanvasTextFormat
{
FontFamily = "Arial",
FontSize = 10.0f,
FontWeight = FontWeights.Normal,
FontStyle = FontStyle.Italic,
};
foreach ((var lv, var caption) in new (LLV, string)[] { (LLV.ERR, "e"), (LLV.WAR, "w"), (LLV.INF, "i"), (LLV.DEV, "d") })
/// <summary>
/// Use this to setup the screen, this will disable the console.
/// </summary>
/// <param name="aSize">The dezired screen resolution</param>
/// <param name="aBpp">The dezired Bytes per pixel</param>
public void SetMode(ScreenSize aSize, Bpp aBpp)
{
//Get screen size
switch (aSize)
{
case ScreenSize.Size320X200:
ScreenWidth = 320;
ScreenHeight = 200;
break;
case ScreenSize.Size640X400:
ScreenWidth = 640;
ScreenHeight = 400;
break;
case ScreenSize.Size640X480:
ScreenWidth = 640;
ScreenHeight = 480;
break;
case ScreenSize.Size800X600:
ScreenWidth = 800;
ScreenHeight = 600;
break;
case ScreenSize.Size1024X768:
ScreenWidth = 1024;
ScreenHeight = 768;
break;
case ScreenSize.Size1280X1024:
ScreenWidth = 1280;
ScreenHeight = 1024;
break;
}
//Get bpp
switch (aBpp)
{
case Bpp.Bpp15:
ScreenBpp = 15;
break;
case Bpp.Bpp16:
ScreenBpp = 16;
break;
case Bpp.Bpp24:
ScreenBpp = 24;
break;
case Bpp.Bpp32:
ScreenBpp = 32;
break;
}
//set the screen
_vbe.vbe_set((ushort)ScreenWidth, (ushort)ScreenHeight, (ushort)ScreenBpp);
}
public Form1()
{
InitializeComponent();
ScreenSizeInCanvas = ScreenSize.ApplyAspect(CanvasSize);
label2.Text = string.Format("Your screen resolution: {0}x{1}", ScreenSize.Width, ScreenSize.Height);
this.pictureBox1.MouseDown += (s, e) =>
{
isl = true;
start = e.Location;
this.pictureBox1.Cursor = Cursors.Cross;
};
this.pictureBox1.MouseMove += (s, e) =>
{
if (isl)
{
start_x += e.X - start.X;
start_y += e.Y - start.Y;
start = e.Location;
draw_result();
}
};
this.pictureBox1.MouseUp += (s, e) =>
{
isl = false;
start = e.Location;
this.pictureBox1.Cursor = Cursors.Arrow;
draw_result();
};
this.button4.MouseDown += (s, e) =>
{
m_MouseDownInEyedropper = true;
this.Cursor = m_eyeDropperCursor;
m_ScreenImage = Utility.CaptureScreen();
m_cursorLocation = Utility.GetCursorPostionOnScreen();
this.domColor.BackColor = m_ScreenImage.GetPixel(m_cursorLocation.X, m_cursorLocation.Y);
};
this.button4.MouseMove += (s, e) =>
{
if (m_MouseDownInEyedropper)
{
m_cursorLocation = Utility.GetCursorPostionOnScreen();
this.domColor.BackColor = m_ScreenImage.GetPixel(m_cursorLocation.X, m_cursorLocation.Y);
draw_result();
}
};
this.button4.MouseUp += (s, e) =>
{
m_MouseDownInEyedropper = false;
m_ScreenImage.Dispose();
this.Cursor = Cursors.Default;
draw_result();
};
}
public void Move(IDrawArea pane, ScreenSize offset)
{
var s0 = GetScreenPos(pane, PositionBackup);
var s1 = s0 + offset;
var l1 = LayoutPos.From(pane, s1);
var cl = CoderX(l1.X, l1.Y);
var ca = CoderY(l1.X, l1.Y);
Location = CodePos <Distance, Angle> .From(cl, ca);
}
public static Dimensions SizeInBlocksForBGSize(ScreenSize size)
{
return(size switch
{
ScreenSize.AAAA_32x32 => new Dimensions(1, 1),
ScreenSize.ABAB_64x32 => new Dimensions(2, 1),
ScreenSize.AABB_32x64 => new Dimensions(1, 2),
ScreenSize.ABCD_64x64 => new Dimensions(2, 2),
_ => throw new Exception()
});
public static Dimensions SizeInBlocksForBGSize(ScreenSize size)
{
switch (size)
{
case ScreenSize.AAAA_32x32: return new Dimensions(1, 1);
case ScreenSize.ABAB_64x32: return new Dimensions(2, 1);
case ScreenSize.AABB_32x64: return new Dimensions(1, 2);
case ScreenSize.ABCD_64x64: return new Dimensions(2, 2);
default: throw new Exception();
}
}
public static SmartClicker GetInstance(IntPtr hwnd)
{
WC.GetClientRect(hwnd, out ClientRect);
if (!WC.IsFullScreen(hwnd))
{
return(null);
}
ScreenSize size = (ScreenSize)Enum.Parse(typeof(ScreenSize), string.Concat(new object[] { "Size", ClientRect.Width, "x", ClientRect.Height }));
return(GetInstance(hwnd, size));
}
public override Dictionary <string, string> GetAdditionalProperties()
{
Dictionary <string, string> additionalProperties = new Dictionary <string, string>();
additionalProperties.Add("Screen size", ScreenSize.ToString());
additionalProperties.Add("Processor", Processor);
additionalProperties.Add("RAM", RAM.ToString());
additionalProperties.Add("Battery capacity", BatteryCapacity.ToString());
return(additionalProperties);
}
public async Task <IHttpActionResult> SetScreenResolution(ScreenSize screenSize)
{
if (screenSize == null)
{
return(new StatusCodeResult(HttpStatusCode.BadRequest, Request));
}
await MyConfig.SetScreenResolution(screenSize.Width, screenSize.Height);
return(Ok());
}
private void UpdateScale()
{
Size dimensions = pnlRenderer.ClientSize;
ScreenSize size = EmuApi.GetScreenSize(true, EmuApi.ConsoleId.HistoryViewer);
double verticalScale = (double)dimensions.Height / size.Height;
double horizontalScale = (double)dimensions.Width / size.Width;
double scale = Math.Min(verticalScale, horizontalScale);
EmuApi.SetVideoScale(scale, EmuApi.ConsoleId.HistoryViewer);
}
private void SetScale(int scale)
{
ScreenSize size = EmuApi.GetScreenSize(true, EmuApi.ConsoleId.HistoryViewer);
Size newSize = new Size(size.Width * scale, size.Height * scale);
if (this.WindowState != FormWindowState.Maximized)
{
Size sizeGap = newSize - ctrlRenderer.Size;
this.ClientSize += sizeGap;
}
ctrlRenderer.Size = newSize;
}
public static Dimensions SizeInTilesForBGSize(ScreenSize size)
{
if (size == ScreenSize.Hacky_1x1)
{
return(new Dimensions(1, 1));
}
var ret = SizeInBlocksForBGSize(size);
ret.Width *= 32;
ret.Height *= 32;
return(ret);
}
public void ResetGame()
{
if (board != null) {
for (int i = 0; i < rounds; ++i) {
for (int f = 0; f < 2; ++f) {
Destroy (board [i] [f].fieldAction);
Destroy (board [i] [f].fieldElement);
}
}
}
screen = new ScreenSize (interfaceScript.canvas.pixelRect);
rounds = boardSize;
round = 0;
scoreP1 = 0;
scoreP2 = 0;
interfaceScript.round.text = "1";
interfaceScript.scoreP1.text = "0";
interfaceScript.scoreP2.text = "0";
board = new List<Board[]>();
float fieldSize = screen.width / boardSize;
float fieldBorder = Mathf.Clamp(fieldSize / 10.0f, 0.0f, screen.height / 25.0f);
float fieldSizeWithoutBorder = fieldSize - fieldBorder;
float halfWidth = screen.width / 2.0f;
for (int i = 0; i < rounds; ++i) {
board.Add (new Board[2]);
for (int f = 0; f < 2; ++f) {
board [i] [f].action = 0;
board [i] [f].fieldElement = Instantiate(fieldElement) as GameObject;
board [i] [f].fieldElement.transform.SetParent(GameObject.Find ("Board").transform, false);
board [i] [f].fieldElement.name = "FieldElement_" + i + "_" + f;
}
RectTransform curBoard1 = board [i] [0].fieldElement.GetComponent<RectTransform> ();
RectTransform curBoard2 = board [i] [1].fieldElement.GetComponent<RectTransform> ();
curBoard1.sizeDelta = new Vector2 (fieldSizeWithoutBorder, Mathf.Clamp(fieldSizeWithoutBorder, 50.0f, 125.0f));
curBoard2.sizeDelta = new Vector2 (fieldSizeWithoutBorder, Mathf.Clamp(fieldSizeWithoutBorder, 50.0f, 125.0f));
curBoard1.anchoredPosition = new Vector2 (fieldSize * i - (halfWidth - fieldSize / 2.0f), curBoard1.rect.height / 2.0f + fieldBorder / 2.0f);
curBoard2.anchoredPosition = new Vector2 (fieldSize * i - (halfWidth - fieldSize / 2.0f), -(curBoard2.rect.height / 2.0f + fieldBorder / 2.0f));
}
gameRunning = true;
interfaceScript.restart.gameObject.SetActive (false);
}
/// <summary>
/// Use this to setup the screen, this will disable the console.
/// </summary>
/// <param name="aSize">The dezired screen resolution</param>
/// <param name="aBpp">The dezired Bytes per pixel</param>
public void SetMode(ScreenSize aSize, Bpp aBpp)
{
//Get screen size
switch (aSize)
{
case ScreenSize.Size320x200:
ScreenWidth = 320;
ScreenHeight = 200;
break;
case ScreenSize.Size640x400:
ScreenWidth = 640;
ScreenHeight = 400;
break;
case ScreenSize.Size640x480:
ScreenWidth = 640;
ScreenHeight = 480;
break;
case ScreenSize.Size800x600:
ScreenWidth = 800;
ScreenHeight = 600;
break;
case ScreenSize.Size1024x768:
ScreenWidth = 1024;
ScreenHeight = 768;
break;
case ScreenSize.Size1280x1024:
ScreenWidth = 1280;
ScreenHeight = 1024;
break;
}
//Get bpp
switch (aBpp)
{
case Bpp.Bpp15:
ScreenBpp = 15;
break;
case Bpp.Bpp16:
ScreenBpp = 16;
break;
case Bpp.Bpp24:
ScreenBpp = 24;
break;
case Bpp.Bpp32:
ScreenBpp = 32;
break;
}
//set the screen
_vbe.vbe_set((ushort)ScreenWidth, (ushort)ScreenHeight, (ushort)ScreenBpp);
}
public static void SetGraphicsMode(ScreenSize screenSize, ColorDepth colorDepth)
{
HALVGAScreen.ScreenSize ScrSize = HALVGAScreen.ScreenSize.Size320x200;
HALVGAScreen.ColorDepth ClrDepth = HALVGAScreen.ColorDepth.BitDepth8;
switch (screenSize)
{
case ScreenSize.Size320x200:
ScrSize = HALVGAScreen.ScreenSize.Size320x200;
break;
case ScreenSize.Size640x480:
ScrSize = HALVGAScreen.ScreenSize.Size640x480;
break;
case ScreenSize.Size720x480:
ScrSize = HALVGAScreen.ScreenSize.Size720x480;
break;
default:
throw new Exception("This situation is not implemented!");
}
switch (colorDepth)
{
case ColorDepth.BitDepth2:
ClrDepth = HALVGAScreen.ColorDepth.BitDepth2;
break;
case ColorDepth.BitDepth4:
ClrDepth = HALVGAScreen.ColorDepth.BitDepth4;
break;
case ColorDepth.BitDepth8:
ClrDepth = HALVGAScreen.ColorDepth.BitDepth8;
break;
case ColorDepth.BitDepth16:
ClrDepth = HALVGAScreen.ColorDepth.BitDepth16;
break;
default:
throw new Exception("This situation is not implemented!");
}
mScreen.SetGraphicsMode(ScrSize, ClrDepth);
}
public MFTestResults LargeBitmapTest()
{
MFTestResults result = MFTestResults.Fail;
ScreenSize[] pairs = new ScreenSize[] {
new ScreenSize( 160, 120 ), // QQVGA
new ScreenSize( 240, 160 ), // HQVGA
new ScreenSize( 320, 240 ), // QVGA
new ScreenSize( 480, 320 ), // HVGA
new ScreenSize( 640, 240 ), // HVGA
new ScreenSize( 864, 480 ), // FWVGA
new ScreenSize( 640, 480 ), // VGA
new ScreenSize( 800, 480 ), // WVGA
new ScreenSize( 848, 480 ), // WVGA
new ScreenSize( 854, 480 ), // WVGA
//new ScreenSize( 1024, 768 ), // XVGA
//new ScreenSize( 1152, 864 ), // XVGA+
//new ScreenSize( 1280, 1024 ), // SXGA
//new ScreenSize( 1400, 1050 ), // SXGA+
//new ScreenSize( 1600, 1200 ), // UXGA
};
Bitmap bmp = null;
try
{
foreach (ScreenSize p in pairs)
{
try
{
// the CLR's limit of allocation in the managed heap is sizeof(CLR_RT_HeapBlock) * (2^16) = 768432 bytes.
// To that one needs to subtract the size of an heap cluster (sizeof(CLR_RT_heapCluster)) and
// round to the number of heap blocks in the remaining amount, since the CLR allocated in heap blocks units.
// Thus some allocation (e.g. 800x600) must go in the unmanaged SimpleHeap if supported.
bmp = new Bitmap(p.width, p.height);
}
catch (OutOfMemoryException)
{
//SimpleHeap has no legitimate API to distinguish between no implementation
//or implemented but out-of-memory condition occurred. If OOM is thrown, assume
//it is because no SimpleHeap was provided.
// On the emulator though, we know it is implemented
if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3)
{
return MFTestResults.Fail;
}
}
bmp.DrawLine(Color.White, 5, 0, 0, bmp.Width, bmp.Height);
bmp.DrawEllipse(Color.White, 4, 50, 50, 40, 11, Color.White, 0, 0, Color.Black, bmp.Width, bmp.Height, 5);
window.StretchImage(0, 0, bmp, width, height, 0xFF);
window.Flush();
bmp.Dispose(); bmp = null; // this is particlarly needed for the allocation in the non-managed heap
}
result = MFTestResults.Pass;
}
finally
{
if (bmp != null)
{
bmp.Dispose();
}
Debug.GC(true);
System.Threading.Thread.Sleep(500);
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="FilmFormat"/> class.
/// </summary>
/// <param name='name'>
/// Name.
/// </param>
/// <param name='filmWidth'>
/// Film width in inches.
/// </param>
/// <param name='filmHeight'>
/// Film height in inches.
/// </param>
/// <param name='aspectRatio'>
/// Aspect ratio.
/// </param>
/// <param name='screenSizes'>
/// ScreenSizes.
/// </param>
public FilmFormat(string name, float filmWidth, float filmHeight, float aspectRatio, ScreenSize[] screenSizes)
{
this.name = name;
this.filmWidth = filmWidth;
this.filmHeight = filmHeight;
this.aspectRatio = aspectRatio;
this.screenSizes = screenSizes;
}
public static void SetScreenSize(int index)
{
currentScreenSizeMode = (ScreenSize)Enum.ToObject(typeof(ScreenSize), index);
game.setScreenSize(index);
HUD.UpdateScale();
Vignette.Load();
}
/// <summary>
/// fetches a tilemap. this is simple; apparently only the screen size (shape) is a factor (not the tile size)
/// </summary>
public TileEntry[] FetchTilemap(int addr, ScreenSize size)
{
var blockDims = SizeInBlocksForBGSize(size);
int blocksw = blockDims.Width;
int blocksh = blockDims.Height;
int width = blockDims.Width * 32;
int height = blockDims.Height * 32;
TileEntry[] buf = new TileEntry[width*height];
for (int by = 0; by < blocksh; by++)
{
for (int bx = 0; bx < blocksw; bx++)
{
for (int y = 0; y < 32; y++)
{
for (int x = 0; x < 32; x++)
{
int idx = (by * 32 + y) * width + bx * 32 + x;
ushort entry = *(ushort*)(vram + addr);
buf[idx].tilenum = (ushort)(entry & 0x3FF);
buf[idx].palette = (byte)((entry >> 10) & 7);
buf[idx].flags = (TileEntryFlags)((entry >> 13) & 7);
buf[idx].address = addr;
addr += 2;
}
}
}
}
return buf;
}
public void SetGraphicsMode(ScreenSize aSize, ColorDepth aDepth)
{
switch (aSize)
{
case ScreenSize.Size320x200:
if (aDepth == ColorDepth.BitDepth8)
{
WriteVGARegisters(g_320x200x8);
PixelWidth = 320;
PixelHeight = 200;
Colors = 256;
SetPixel = new SetPixelDelegate(SetPixel320x200x8);
GetPixel = new GetPixelDelegate(GetPixel320x200x8);
}
else if (aDepth == ColorDepth.BitDepth4)
{
WriteVGARegisters(g_320x200x4);
PixelWidth = 320;
PixelHeight = 200;
Colors = 16;
//SetPixel = new SetPixelDelegate(SetPixel320x200x4);
//GetPixel = new GetPixelDelegate(GetPixel320x200x4);
}
else throw new Exception("Unsupported color depth passed for specified screen size");
break;
case ScreenSize.Size640x480:
if (aDepth == ColorDepth.BitDepth2)
{
WriteVGARegisters(g_640x480x2);
PixelWidth = 640;
PixelHeight = 480;
Colors = 4;
//SetPixel = new SetPixelDelegate(SetPixel640x480x2);
//GetPixel = new GetPixelDelegate(GetPixel640x480x2);
}
else if (aDepth == ColorDepth.BitDepth4)
{
WriteVGARegisters(g_640x480x4);
PixelWidth = 640;
PixelHeight = 480;
Colors = 16;
SetPixel = new SetPixelDelegate(SetPixel640x480x4);
GetPixel = new GetPixelDelegate(GetPixel640x480x4);
}
else throw new Exception("Unsupported color depth passed for specified screen size");
break;
case ScreenSize.Size720x480:
if (aDepth == ColorDepth.BitDepth4)
{
WriteVGARegisters(g_720x480x4);
PixelWidth = 720;
PixelHeight = 480;
Colors = 16;
SetPixel = new SetPixelDelegate(SetPixel720x480x4);
GetPixel = new GetPixelDelegate(GetPixel720x480x4);
}
else throw new Exception("Unsupported color depth passed for specified screen size");
break;
default:
throw new Exception("Unknown screen size");
}
}
/// <summary>
/// returns a tilemap which might be resized into 8x8 physical tiles if the 16x16 logical tilesize is specified
/// </summary>
//TileEntry[] AdaptTilemap(TileEntry[] map8x8, int tilesWide, int tilesTall, int tilesize)
//{
// if (tilesize == 8) return map8x8;
// int numTiles = tilesWide * tilesTall;
// var ret = new TileEntry[numTiles * 4];
// for(int y=0;y<tilesTall;y++)
// {
// for (int x = 0; x < tilesWide; x++)
// {
// int si = tilesWide * y + x;
// int di = tilesHigh
// for (int tx = 0; tx < 2; tx++)
// {
// for (int ty = 0; ty < 2; ty++)
// {
// }
// }
// }
// }
//}
/// <summary>
/// decodes a BG. youll still need to paletteize and colorize it.
/// someone else has to take care of calculating the starting color from the mode and layer number.
/// </summary>
public void DecodeBG(int* screen, int stride, TileEntry[] map, int tiledataBaseAddr, ScreenSize size, int bpp, int tilesize, int paletteStart)
{
int ncolors = 1 << bpp;
int[] tileBuf = new int[16*16];
var dims = SizeInTilesForBGSize(size);
int count8x8 = tilesize / 8;
int tileSizeBytes = 8 * bpp;
int baseTileNum = tiledataBaseAddr / tileSizeBytes;
int[] tileCache = _tileCache[bpp];
int tileCacheMask = tileCache.Length - 1;
int screenWidth = dims.Width * count8x8 * 8;
for (int mty = 0; mty < dims.Height; mty++)
{
for (int mtx = 0; mtx < dims.Width; mtx++)
{
for (int tx = 0; tx < count8x8; tx++)
{
for (int ty = 0; ty < count8x8; ty++)
{
int mapIndex = mty * dims.Width + mtx;
var te = map[mapIndex];
int tileNum = te.tilenum + tx + ty * 16 + baseTileNum;
int srcOfs = tileNum * 64;
for (int i = 0, y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++, i++)
{
int px = x;
int py = y;
if ((te.flags & TileEntryFlags.Horz) != 0) px = 7 - x;
if ((te.flags & TileEntryFlags.Vert) != 0) py = 7 - y;
int dstX = (mtx * count8x8 + tx) * 8 + px;
int dstY = (mty * count8x8 + ty) * 8 + py;
int dstOfs = dstY * stride + dstX;
int color = tileCache[srcOfs & tileCacheMask];
srcOfs++;
if (color == 0 && usingUserBackColor)
{ }
else
{
color += te.palette * ncolors;
color += paletteStart;
}
screen[dstOfs] = color;
}
}
}
}
}
}
}
public static void SetScreenSize(ScreenSize size)
{
currentScreenSizeMode = size;
game.setScreenSize((int)size);
HUD.UpdateScale();
Vignette.Load();
}
/// <summary>
/// returns a tilemap which might be resized into 8x8 physical tiles if the 16x16 logical tilesize is specified
/// </summary>
//TileEntry[] AdaptTilemap(TileEntry[] map8x8, int tilesWide, int tilesTall, int tilesize)
//{
// if (tilesize == 8) return map8x8;
// int numTiles = tilesWide * tilesTall;
// var ret = new TileEntry[numTiles * 4];
// for(int y=0;y<tilesTall;y++)
// {
// for (int x = 0; x < tilesWide; x++)
// {
// int si = tilesWide * y + x;
// int di = tilesHigh
// for (int tx = 0; tx < 2; tx++)
// {
// for (int ty = 0; ty < 2; ty++)
// {
// }
// }
// }
// }
//}
/// <summary>
/// decodes a BG. youll still need to paletteize and colorize it.
/// someone else has to take care of calculating the starting color from the mode and layer number.
/// </summary>
public void DecodeBG(int* screen, int stride, TileEntry[] map, int tiledataBaseAddr, ScreenSize size, int bpp, int tilesize, int paletteStart)
{
//emergency backstop. this can only happen if we're displaying an unavailable BG or other similar such value
if (bpp == 0) return;
int ncolors = 1 << bpp;
int[] tileBuf = new int[16*16];
var dims = SizeInTilesForBGSize(size);
int count8x8 = tilesize / 8;
int tileSizeBytes = 8 * bpp;
int baseTileNum = tiledataBaseAddr / tileSizeBytes;
int[] tileCache = _tileCache[bpp];
int tileCacheMask = tileCache.Length - 1;
int screenWidth = dims.Width * count8x8 * 8;
for (int mty = 0; mty < dims.Height; mty++)
{
for (int mtx = 0; mtx < dims.Width; mtx++)
{
for (int tx = 0; tx < count8x8; tx++)
{
for (int ty = 0; ty < count8x8; ty++)
{
int mapIndex = mty * dims.Width + mtx;
var te = map[mapIndex];
//apply metatile flipping
int tnx = tx, tny = ty;
if (tilesize == 16)
{
if ((te.flags & TileEntryFlags.Horz) != 0) tnx = 1 - tnx;
if ((te.flags & TileEntryFlags.Vert) != 0) tny = 1 - tny;
}
int tileNum = te.tilenum + tnx + tny * 16 + baseTileNum;
int srcOfs = tileNum * 64;
for (int i = 0, y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++, i++)
{
int px = x;
int py = y;
if ((te.flags & TileEntryFlags.Horz) != 0) px = 7 - x;
if ((te.flags & TileEntryFlags.Vert) != 0) py = 7 - y;
int dstX = (mtx * count8x8 + tx) * 8 + px;
int dstY = (mty * count8x8 + ty) * 8 + py;
int dstOfs = dstY * stride + dstX;
int color = tileCache[srcOfs & tileCacheMask];
srcOfs++;
if (color == 0 && usingUserBackColor)
{ }
else
{
color += te.palette * ncolors;
color += paletteStart;
}
screen[dstOfs] = color;
}
}
}
}
}
}
}
private void UpdateScreenSize()
{
ScreenSize newScreenSize = null;
int screenSize = Mathf.Min(Screen.height, Screen.width);
foreach (ScreenSize scrn in ScreenSizes.Reverse())
{
if (screenSize >= scrn.MinimumResolution)
{
newScreenSize = scrn;
break;
}
}
if (newScreenSize != null)
{
CurrentScreenSize = newScreenSize;
}
}
public virtual void Start()
{
UpdateScreenSize();
CurrentScreenWidth = Screen.width;
if (CurrentScreenSize == null)
{
CurrentScreenSize = ScreenSizes[0];
}
}
