public void GenerateStatisticsBackground(GameplayGameState Self)
{
Bitmap buildbg = new Bitmap(1120, 2576);
Size BlockSize = new Size(128, 128);
int ColumnCount = (buildbg.Width / BlockSize.Width) + 1;
int RowCount = (buildbg.Height / BlockSize.Height) + 1;
using (Graphics g = Graphics.FromImage(buildbg))
{
g.Clear(Color.Black);
for (int col = 0; col < ColumnCount; col++)
{
for (int row = 0; row < RowCount; row++)
{
int DrawBlockX = col * BlockSize.Width;
int DrawBlockY = row * BlockSize.Height;
StandardColouredBlock GenerateColorBlock = new StandardColouredBlock();
Nomino ArbitraryGroup = new Nomino();
ArbitraryGroup.AddBlock(new Point[] { Point.Empty }, GenerateColorBlock);
Self.PlayField.Theme.ApplyRandom(ArbitraryGroup, Self.GameHandler, Self.PlayField);
//this.PlayField.Theme.ApplyTheme(ArbitraryGroup, this.PlayField);
TetrisBlockDrawGDIPlusParameters tbd = new TetrisBlockDrawGDIPlusParameters(g, new RectangleF(DrawBlockX, DrawBlockY, BlockSize.Width, BlockSize.Height), null, new SettingsManager());
RenderingProvider.Static.DrawElement(null, tbd.g, GenerateColorBlock, tbd);
}
}
}
StatisticsBackground = buildbg;
GeneratedImageTheme = Self.PlayField.Theme;
}
public Image GetImage(SizeF BlockSize)
{
RecalcExtents();
Size BitmapSize = new Size((int)BlockSize.Width * (_GroupExtents.Width + 1), (int)BlockSize.Height * (_GroupExtents.Height + 1));
//generate a new image.
Bitmap BuiltRepresentation = new Bitmap(BitmapSize.Width, BitmapSize.Height, PixelFormat.Format32bppPArgb);
using (Graphics DrawRep = Graphics.FromImage(BuiltRepresentation))
{
DrawRep.CompositingQuality = CompositingQuality.HighSpeed;
DrawRep.InterpolationMode = InterpolationMode.NearestNeighbor;
DrawRep.SmoothingMode = SmoothingMode.HighSpeed;
foreach (NominoElement bge in this)
{
RectangleF DrawPos = new RectangleF(BlockSize.Width * (bge.X - _GroupExtents.X), BlockSize.Height * (bge.Y - _GroupExtents.Y), BlockSize.Width, BlockSize.Height);
TetrisBlockDrawGDIPlusParameters tbd = new TetrisBlockDrawGDIPlusParameters(DrawRep, DrawPos, this, new SettingsManager());
RenderingProvider.Static.DrawElement(null, tbd.g, bge.Block, tbd);
//bge.Block.DrawBlock(tbd);
}
}
return(BuiltRepresentation);
}
public void DrawProc(GameplayGameState pState, IStateOwner pOwner, Graphics g, RectangleF Bounds)
{
if (useBackground == null || !StoredBackground.Equals(Bounds) || pState.DoRefreshBackground)
{
RefreshBackground(pState, Bounds);
}
g.DrawImage(useBackground, Bounds);
var PlayField = pState.PlayField;
if (PlayField != null)
{
PlayField.Draw(pOwner, g, Bounds);
}
foreach (var activeblock in PlayField.BlockGroups)
{
int dl = 0;
var GrabGhost = pState.GetGhostDrop(pOwner, activeblock, out dl, 3);
if (GrabGhost != null)
{
var BlockWidth = PlayField.GetBlockWidth(Bounds);
var BlockHeight = PlayField.GetBlockHeight(Bounds);
foreach (var iterateblock in activeblock)
{
RectangleF BlockBounds = new RectangleF(BlockWidth * (GrabGhost.X + iterateblock.X), BlockHeight * (GrabGhost.Y + iterateblock.Y - 2), PlayField.GetBlockWidth(Bounds), PlayField.GetBlockHeight(Bounds));
TetrisBlockDrawGDIPlusParameters tbd = new TetrisBlockDrawGDIPlusParameters(g, BlockBounds, GrabGhost, pOwner.Settings);
ImageAttributes Shade = new ImageAttributes();
Shade.SetColorMatrix(ColorMatrices.GetFader(0.5f));
tbd.ApplyAttributes = Shade;
//tbd.OverrideBrush = GhostBrush;
var GetHandler = RenderingProvider.Static.GetHandler(typeof(Graphics), iterateblock.Block.GetType(), typeof(TetrisBlockDrawGDIPlusParameters));
GetHandler.Render(pOwner, tbd.g, iterateblock.Block, tbd);
//iterateblock.Block.DrawBlock(tbd);
}
}
}
}
public void Draw(IStateOwner pState, Graphics g, RectangleF Bounds)
{
//first how big is each block?
float BlockWidth = Bounds.Width / ColCount;
float BlockHeight = Bounds.Height / (VisibleRows); //remember, we don't draw the top two rows- we start the drawing at row index 2, skipping 0 and 1 when drawing.
lock (this)
{
if (FieldBitmap == null || !LastFieldSave.Equals(Bounds) || HasChanged)
{
Bitmap BuildField = new Bitmap((int)Bounds.Width, (int)Bounds.Height, PixelFormat.Format32bppPArgb);
using (Graphics gfield = Graphics.FromImage(BuildField))
{
gfield.CompositingQuality = CompositingQuality.HighSpeed;
gfield.SmoothingMode = SmoothingMode.HighSpeed;
gfield.InterpolationMode = InterpolationMode.NearestNeighbor;
gfield.Clear(Color.Transparent);
DrawFieldContents(pState, gfield, Bounds);
if (FieldBitmap != null)
{
FieldBitmap.Dispose();
}
FieldBitmap = BuildField;
}
HasChanged = false;
}
}
g.DrawImageUnscaled(FieldBitmap, 0, 0);
lock (ActiveBlockGroups)
{
foreach (Nomino bg in ActiveBlockGroups)
{
int BaseXPos = bg.X;
int BaseYPos = bg.Y;
const float RotationTime = 100;
double useAngle = 0;
TimeSpan tsRotate = DateTime.Now - bg.GetLastRotation();
if (tsRotate.TotalMilliseconds > 0 && tsRotate.TotalMilliseconds < RotationTime)
{
if (!bg.LastRotateCCW)
{
useAngle = -90 + ((tsRotate.TotalMilliseconds / RotationTime) * 90);
}
else
{
useAngle = 90 - ((tsRotate.TotalMilliseconds / RotationTime) * 90);
}
}
var translation = bg.GetHeightTranslation(pState, BlockHeight);
float BlockPercent = translation / BlockHeight;
float CalcValue = BlockPercent + (float)bg.Y;
if (CalcValue > bg.HighestHeightValue)
{
bg.HighestHeightValue = CalcValue;
}
else
{
translation = (bg.HighestHeightValue - (float)bg.Y) * BlockHeight;
}
PointF doTranslate = new PointF(0, translation);
if (!pState.Settings.std.SmoothFall)
{
doTranslate = new PointF(0, 0);
}
//if (Settings.SmoothFall) g.TranslateTransform(doTranslate.X, -BlockHeight + doTranslate.Y);
if (pState.Settings.std.SmoothFall)
{
g.TranslateTransform(doTranslate.X, -BlockHeight + doTranslate.Y);
}
if (useAngle != 0 && pState.Settings.std.SmoothRotate)
{
int MaxXBlock = (from p in bg select p.X).Max();
int MaxYBlock = (from p in bg select p.Y).Max();
int MinXBlock = (from p in bg select p.X).Min();
int MinYBlock = (from p in bg select p.Y).Min();
int BlocksWidth = MaxXBlock - MinXBlock + 1;
int BlocksHeight = MaxYBlock - MinYBlock + 1;
PointF UsePosition = new PointF((bg.X + MinXBlock) * BlockWidth, (bg.Y - HIDDENROWS + MinYBlock) * BlockHeight);
SizeF tetronimosize = new Size((int)BlockWidth * (BlocksWidth), (int)BlockHeight * (BlocksHeight));
PointF useCenter = new PointF(UsePosition.X + tetronimosize.Width / 2, UsePosition.Y + tetronimosize.Height / 2);
g.TranslateTransform(useCenter.X, useCenter.Y);
g.RotateTransform((float)useAngle);
g.TranslateTransform(-useCenter.X, -useCenter.Y);
}
foreach (NominoElement bge in bg)
{
int DrawX = BaseXPos + bge.X;
int DrawY = BaseYPos + bge.Y - HIDDENROWS;
if (DrawX >= 0 && DrawY >= 0 && DrawX < ColCount && DrawY < RowCount)
{
float DrawXPx = DrawX * BlockWidth;
float DrawYPx = DrawY * BlockHeight;
RectangleF BlockBounds = new RectangleF(DrawXPx, DrawYPx, BlockWidth, BlockHeight);
TetrisBlockDrawParameters tbd = new TetrisBlockDrawGDIPlusParameters(g, BlockBounds, bg, pState.Settings);
RenderingProvider.Static.DrawElement(pState, g, bge.Block, tbd);
}
}
g.ResetTransform();
}
}
}
public void DrawFieldContents(IStateOwner pState, Graphics g, RectangleF Bounds)
{
float BlockWidth = Bounds.Width / ColCount;
float BlockHeight = Bounds.Height / (VisibleRows); //remember, we don't draw the top two rows- we start the drawing at row index 2, skipping 0 and 1 when drawing.
#if false
for (int drawCol = 0; drawCol < COLCOUNT; drawCol++)
{
float XPos = drawCol * BlockWidth;
g.DrawLine(LinePen, XPos, 0, XPos, Bounds.Height);
}
for (int drawRow = HIDDENROWS; drawRow < ROWCOUNT; drawRow++)
{
float YPos = (drawRow - HIDDENROWS) * BlockHeight;
g.DrawLine(LinePen, 0, YPos, Bounds.Width, YPos);
}
#endif
for (int drawRow = HIDDENROWS; drawRow < RowCount; drawRow++)
{
float YPos = (drawRow - HIDDENROWS) * BlockHeight;
var currRow = FieldContents[drawRow];
//also, is there a hotline here?
if (Flags.HasFlag(TetrisField.GameFlags.Flags_Hotline) && HotLines.ContainsKey(drawRow))
{
RectangleF RowBounds = new RectangleF(0, YPos, BlockWidth * ColCount, BlockHeight);
Brush useFillBrush = null;
var HotLine = HotLines[drawRow];
if (HotLine.LineBrush != null)
{
useFillBrush = HotLine.LineBrush;
}
else
{
useFillBrush = GetHotLineTexture((int)RowBounds.Height + 1, HotLines[drawRow].Color);
}
if (useFillBrush is TextureBrush tb1)
{
tb1.TranslateTransform(0, YPos);
}
g.FillRectangle(useFillBrush, RowBounds);
if (useFillBrush is TextureBrush tb2)
{
tb2.ResetTransform();
}
}
//for each Tetris Row...
for (int drawCol = 0; drawCol < ColCount; drawCol++)
{
float XPos = drawCol * BlockWidth;
var TetBlock = currRow[drawCol];
if (TetBlock != null)
{
RectangleF BlockBounds = new RectangleF(XPos, YPos, BlockWidth, BlockHeight);
TetrisBlockDrawGDIPlusParameters tbd = new TetrisBlockDrawGDIPlusParameters(g, BlockBounds, null, pState.Settings);
RenderingProvider.Static.DrawElement(pState, tbd.g, TetBlock, tbd);
}
}
}
}
