public GameOverStatistics GetGameOverStatistics(GameplayGameState state, IStateOwner pOwner)
{
Type[] TetTypes = new Type[] { typeof(Tetrominoes.Tetromino_I),
typeof(Tetrominoes.Tetromino_I),
typeof(Tetrominoes.Tetromino_O),
typeof(Tetrominoes.Tetromino_T),
typeof(Tetrominoes.Tetromino_J),
typeof(Tetrominoes.Tetromino_L),
typeof(Tetrominoes.Tetromino_S),
typeof(Tetrominoes.Tetromino_Z) };
GameOverStatistic I_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_I));
GameOverStatistic O_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_O));
GameOverStatistic T_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_T));
GameOverStatistic J_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_J));
GameOverStatistic L_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_L));
GameOverStatistic S_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_S));
GameOverStatistic Z_Stat = GetTetrominoStatistic(state, typeof(Tetrominoes.Tetromino_Z));
GameOverStatistics StatResult = new GameOverStatistics(
new GameOverStatistic(new GameOverStatisticColumnData("---Line Clears---", Color.White, Color.Black, GameOverStatisticColumnData.HorizontalAlignment.Middle)),
I_Stat,
O_Stat,
T_Stat,
J_Stat,
L_Stat,
S_Stat,
Z_Stat);
return(StatResult);
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, NominoBlock Source, TetrisBlockDrawParameters Element)
{
if (Source is ImageBlock)
{
this.Render(pOwner, pRenderTarget, (ImageBlock)Source, Element);
}
}
public override void Render(IStateOwner pOwner, Graphics pRenderTarget, UnpauseDelayGameState Source, BaseDrawParameters Element)
{
Graphics g = pRenderTarget;
var Bounds = Element.Bounds;
RenderingProvider.Static.DrawElement(pOwner, pRenderTarget, Source._ReturnState, Element);
//Draw Faded out overlay to darken things up.
DrawFadeOverlay(g, Bounds);
//draw a centered Countdown
if (Source.LastSecond != Source.timeremaining.Seconds)
{
//emit a sound.
TetrisGame.Soundman.PlaySound(pOwner.AudioThemeMan.GameOverShade.Key, pOwner.Settings.std.EffectVolume);
Source.LastSecond = Source.timeremaining.Seconds;
Source.lastMillis = 1000;
}
double SecondsLeft = Math.Round(Source.timeremaining.TotalSeconds, 1);
String sSecondsLeft = Source.timeremaining.ToString("%s");
double Millis = (double)Source.timeremaining.Milliseconds / 1000d; //millis in percent. We will use this to animate the unpause time left.
Millis = Math.Min(Millis, Source.lastMillis);
float useSize = (float)(64f * (1 - (Millis)));
var SecondsFont = TetrisGame.GetRetroFont(useSize, pOwner.ScaleFactor);
var MeasureText = g.MeasureString(sSecondsLeft, SecondsFont);
PointF DrawPosition = new PointF(Bounds.Width / 2 - MeasureText.Width / 2, Bounds.Height / 2 - MeasureText.Height / 2);
g.DrawString(sSecondsLeft, SecondsFont, Brushes.White, DrawPosition);
Source.lastMillis = Millis;
}
public override void FrameProc(IStateOwner pOwner)
{
StandardImageBackgroundDrawSkiaCapsule dd = Data;
if (dd == null)
{
return;
}
if (dd.BackgroundBrush == null)
{
dd.ResetState(new SKRect(0, 0, pOwner.GameArea.Width, pOwner.GameArea.Height));
}
if (dd.BackgroundBrush == null)
{
return;
}
if (!dd.Movement.IsEmpty)
{
dd.CurrOrigin = new SKPoint((dd.CurrOrigin.X + dd.Movement.X) % dd._BackgroundImage.Width, (dd.CurrOrigin.Y + dd.Movement.Y) % dd._BackgroundImage.Height);
}
if (dd.AngleSpeed > 0)
{
dd.CurrAngle += dd.AngleSpeed;
}
dd.BackgroundBrush.ImageFilter = SKImageFilter.CreateOffset(dd.CurrOrigin.X, dd.CurrOrigin.Y, dd.PrimaryFilter);
//might need to do something weird for tiling.
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, List <BaseParticle> Source, GameStateSkiaDrawParameters Element)
{
if (Source.Count > 0)
{
Debug.Print("Rendering Particle Set of " + Source.Count.ToString());
Debug.Print("Trace:" + new StackTrace().ToString());
}
foreach (var iterate in Source)
{
//retrieve rendering handler.
var Grabrenderer = GetProvider(iterate.GetType());
Grabrenderer.Render(pOwner, pRenderTarget, iterate, Element);
}
if (Source.Count > 0)
{
;
}
if (pOwner.CurrentState.GameProcSuspended)
{
;
}
UpdateParticles(pOwner, Source);
}
public override void FrameProc(IStateOwner pOwner)
{
StandardImageBackgroundDrawGDICapsule dd = Data;
if (dd == null)
{
return;
}
if (dd.BackgroundBrush == null)
{
dd.ResetState();
}
if (dd.BackgroundBrush == null)
{
return;
}
if (!dd.Movement.IsEmpty)
{
dd.CurrOrigin = new PointF((dd.CurrOrigin.X + dd.Movement.X) % dd._BackgroundImage.Width, (dd.CurrOrigin.Y + dd.Movement.Y) % dd._BackgroundImage.Height);
}
if (dd.AngleSpeed > 0)
{
dd.CurrAngle += dd.AngleSpeed;
}
dd.BackgroundBrush.ResetTransform();
dd.BackgroundBrush.TranslateTransform(dd.CurrOrigin.X, dd.CurrOrigin.Y);
dd.BackgroundBrush.RotateTransform(dd.CurrAngle);
}
public Nomino GetGhostDrop(IStateOwner pOwner, Nomino Source, out int dropLength, int CancelProximity = 3)
{
//routine returns the Ghost Drop representor of this Nomino.
//this function will also return null if the dropped block is CancelProximity or closer to the place it would be dropped.
Nomino Duplicator = new Nomino(Source);
dropLength = 0;
while (true)
{
var fitresult = CanFit(Duplicator, Duplicator.X, Duplicator.Y + 1, true, new Nomino[] { Source });
//ghost drops will show up "through" any active blocks, since active blocks don't actual set blocks..
if (new CanFitResultConstants[] { CanFitResultConstants.CanFit, CanFitResultConstants.CantFit_Active }.Contains(fitresult))
{
dropLength++;
Duplicator.SetY(pOwner, Duplicator.Y + 1);
}
else
{
break;
}
}
if (dropLength < CancelProximity)
{
return(null);
}
foreach (var iterate in Duplicator)
{
iterate.Block.Owner = Source;
}
return(Duplicator);
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, BaseParticle Source, GameStateSkiaDrawParameters Element)
{
if (Source.Color.R == 255 && Source.Color.B == 0 && Source.Color.G == 0)
{
;
}
BCPoint usePosition = new BCPoint(Source.Position.X, Source.Position.Y);
//have to try to get the standardRenderingProvider. If we can then we will use the coordinates as if they are a block position- otherwise, we use the coordinates directly.
usePosition = TranslatePosition(pOwner, pRenderTarget, Source.Position, Element);
BCPoint PrevPosition = TranslatePosition(pOwner, pRenderTarget, Source.Position - Source.Velocity, Element);
byte useAlpha = TranslateAlpha(Source);
if (SharePaint == null)
{
SharePaint = new SKPaint()
{
Color = new SKColor(Source.Color.R, Source.Color.G, Source.Color.B, useAlpha), StrokeWidth = 1.2f
}
}
;
else
{
SharePaint.Color = new SKColor(Source.Color.R, Source.Color.G, Source.Color.B, useAlpha);
}
pRenderTarget.DrawLine(PrevPosition, usePosition, SharePaint);
//pRenderTarget.DrawRect(new SKRect(usePosition.X, usePosition.Y, usePosition.X + 2, usePosition.Y + 2), skp);
}
public override void Render(IStateOwner pOwner, Graphics pRenderTarget, TemporaryInputPauseGameState Source, BaseDrawParameters Element)
{
Graphics g = pRenderTarget;
var Bounds = Element.Bounds;
RenderingProvider.Static.DrawElement(pOwner, pRenderTarget, Source.GetComposite(), Element);
}
public void Render(IStateOwner pOwner, Graphics pRenderTarget, PauseGameState Source, BaseDrawParameters Element)
{
if (!Source.DrawDataInitialized)
{
InitDrawData(pOwner, Source, Element);
Source.DrawDataInitialized = true;
}
Graphics g = pRenderTarget;
var Bounds = Element.Bounds;
var FallImages = Source.FallImages;
//Render the paused state.
Font usePauseFont = TetrisGame.GetRetroFont(24, pOwner.ScaleFactor);
String sPauseText = "Pause";
SizeF Measured = g.MeasureString(sPauseText, usePauseFont);
g.FillRectangle(Brushes.Gray, Bounds);
foreach (var iterate in FallImages)
{
iterate.Draw(g);
}
g.ResetTransform();
PointF DrawPos = new PointF(Bounds.Width / 2 - Measured.Width / 2, Bounds.Height / 2 - Measured.Height / 2);
TetrisGame.DrawText(g, usePauseFont, sPauseText, Brushes.White, Brushes.Black, DrawPos.X, DrawPos.Y);
//retrieve the renderer for the MenuState object.
base.Render(pOwner, pRenderTarget, Source, Element);
}
public OptionsMenuState(IBackground background, IStateOwner pOwner, GameState OriginalState, String pSettingsTitle, StandardSettings AlterSettingsSet) : base(background)
{
_OriginalState = OriginalState;
_AlterSet = AlterSettingsSet;
_SettingsTitle = pSettingsTitle;
PopulateOptions(pOwner);
}
public MenuStateNewGameMenuItem(IStateOwner pOwner) : base(null)
{
_Owner = pOwner;
var HandlerOptions = Program.GetGameHandlers();
List <MenuItemNewGameSelection> Options = new List <MenuItemNewGameSelection>();
var Default = new MenuItemNewGameSelection(null);
DefaultOption = Default;
//Options.Add(Default);
foreach (var iterate in HandlerOptions)
{
var findconstruct = iterate.GetConstructor(new Type[] { });
if (findconstruct != null)
{
IGameCustomizationHandler newhandler = (IGameCustomizationHandler)findconstruct.Invoke(new object[] { });
MenuItemNewGameSelection newoption = new MenuItemNewGameSelection(newhandler);
Options.Add(newoption);
}
}
base.OptionManager = new MultiOptionManagerList <MenuItemNewGameSelection>(Options.ToArray(), 1);
this.Text = "New Game";
this.CurrentOption = Default;
//OnActivateOption += ScaleActivate;
}
public override void GameProc(IStateOwner pOwner)
{
base.GameProc(pOwner);
if (pOwner.CurrentState is GameplayGameState stgs1)
{
//pOwner.EnqueueAction(() => { stgs1.PlayField.HasChanged = true; });
}
if (StartOperation == DateTime.MaxValue)
{
StartOperation = LastOperation = DateTime.Now;
}
if (ClearActivities.Count > 0)
{
DateTime useNowTime = DateTime.Now;
foreach (var ClearActivity in ClearActivities)
{
var elapsed = useNowTime - ClearActivity.StartClearTime;
foreach (var block in ClearActivity.Blocks)
{
ClearActivity.ClearAction.ProcessBlock(pOwner, new BlockClearData(block, new BCPoint()
{
}), elapsed);
}
}
}
//for now we clear horizontally across...
if ((DateTime.Now - LastOperation).TotalMilliseconds > MSBlockClearTime)
{
//clear another block on each row.
var ClearResult = ClearFrame(pOwner);
if (ClearRowInfo.Keys.Count >= 4)
{
FlashState = !FlashState;
}
if (ClearActivities.Count > 0)
{
DateTime NowTime = DateTime.Now;
//if there are entries in ClearActivities, we want to make sure those are cleared as well. This is the case if the cleartime has elapsed for each.
ClearResult |= ClearActivities.All((kvp) => { return(NowTime - kvp.StartClearTime > kvp.ClearAction.ClearTime); });
}
LastOperation = DateTime.Now;
if (ClearResult)
{
//reset the original State.
pOwner.CurrentState = _BaseState;
foreach (var iterate in AfterClear)
{
pOwner.EnqueueAction(iterate);
}
if (pOwner.CurrentState is GameplayGameState stgs2)
{
// pOwner.EnqueueAction(() => { stgs2.PlayField.HasChanged = true; });
}
}
}
}
public SettingsManager(String pSourceFile, IStateOwner pOwner)
{
_Owner = pOwner;
pLoadedFile = pSourceFile;
if (File.Exists(pSourceFile))
{
XDocument xdoc = XDocument.Load(pSourceFile);
var RootNode = xdoc.Root;
if (RootNode.Name == "Settings")
{
//old settings, add those as the default.
StandardSettings DefaultSettings = new StandardSettings(RootNode);
DefaultSettings.SetOwner(this);
AllSettings.Add("Default", DefaultSettings);
}
else if (RootNode.Name == "SettingsGroups")
{
foreach (var groupnode in RootNode.Elements("SettingsGroup"))
{
String sGroupName = groupnode.Attribute("Name").Value;
XElement DataNode = groupnode.Element("Data");
StandardSettings SettingsData = new StandardSettings(DataNode);
SettingsData.SetOwner(this);
AllSettings.Add(sGroupName, SettingsData);
}
}
}
}
public MenuStateDisplayThemeMenuItem(IStateOwner pOwner, IGameCustomizationHandler handler) : base(null)
{
_Owner = pOwner;
Type currentthemetype = null;
if (_Owner.CurrentState is GameplayGameState gs)
{
currentthemetype = gs.PlayField.Theme.GetType();
}
else if (_Owner.CurrentState is ICompositeState <GameplayGameState> comp)
{
currentthemetype = comp.GetComposite().PlayField.Theme.GetType();
}
ThemeOptions = GetThemeSelectionsForHandler(handler).ToArray();
int currentIndex = 0;
for (int i = 0; i < ThemeOptions.Length; i++)
{
if (ThemeOptions[i].ThemeType == currentthemetype)
{
currentIndex = i;
break;
}
}
base.OptionManager = new MultiOptionManagerList <MenuStateThemeSelection>(ThemeOptions, currentIndex);
var closest = ThemeOptions[currentIndex];
this.Text = closest.Description;
OnChangeOption += ThemeActivate;
}
public override void Render(IStateOwner pOwner, Graphics pRenderTarget, ImageBlock Source, TetrisBlockDrawParameters Element)
{
if (Source is StandardColouredBlock)
{
this.Render(pOwner, pRenderTarget, (StandardColouredBlock)Source, Element);
}
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, FieldActionGameState Source, GameStateSkiaDrawParameters Element)
{
if (Source is FieldLineActionGameState state)
{
this.Render(pOwner, pRenderTarget, state, Element);
}
}
public override void RenderStats(IStateOwner pOwner, object pRenderTarget, object Element, object ElementData)
{
if (Element is FieldLineActionGameState state)
{
this.RenderStats((IStateOwner)pOwner, (SKCanvas)pRenderTarget, state, (GameStateSkiaDrawParameters)ElementData);
}
}
public override void Render(IStateOwner pOwner, SKCanvas pRenderTarget, PrimaryBlockAppearanceState Source, GameStateSkiaDrawParameters Element)
{
SKCanvas g = pRenderTarget;
var Bounds = Element.Bounds;
RenderingProvider.Static.DrawElement(pOwner, pRenderTarget, Source.GetComposite(), Element);
}
public override void RenderStats(IStateOwner pOwner, SKCanvas pRenderTarget, FieldActionGameState Source, GameStateSkiaDrawParameters Element)
{
if (Source._BaseState != null)
{
RenderingProvider.Static.DrawStateStats(pOwner, pRenderTarget, Source._BaseState, Element);
}
}
protected BaseAI(IStateOwner pOwner)
{
_Owner = pOwner;
//spin up an AI thread
AIThread = new Thread(AIActionThread);
AIThread.Start();
}
public void RedrawStatusbarTetrominoBitmaps(IStateOwner Owner, GameplayGameState State, RectangleF Bounds)
{
lock (LockTetImageRedraw)
{
State.SetTetrominoImages(TetrisGame.GetTetrominoBitmaps(Bounds, State.PlayField.Theme, State.GameHandler, State.PlayField, (float)Owner.ScaleFactor));
}
}
public virtual SizeF GetSize(IStateOwner pOwner, MenuStateTextMenuItem Source)
{
var testfont = GetScaledFont(pOwner, Source.FontFace, Source.FontSize);
var MeasureText = Temp.MeasureString(Source.Text, testfont);
return(MeasureText.ToSize());
}
public void Render(IStateOwner pOwner, Graphics pRenderTarget, MenuStateMultiOption Source, MenuStateMenuItemGDIPlusDrawData Element)
{
Font useFont = MenuStateTextMenuItemGDIRenderer.GetScaledFont(pOwner, Source.FontFace, Source.FontSize);
var OptionManager = Source.OptionManagerBase;
var Bounds = Element.Bounds;
String sLeftCover = "< ";
String sRightCover = ">";
var PrevItem = OptionManager.GetTextBase(OptionManager.PeekPreviousBase());
var NextItem = OptionManager.GetTextBase(OptionManager.PeekNextBase());
sLeftCover = PrevItem + sLeftCover;
sRightCover = sRightCover + NextItem;
var MeasureLeft = pRenderTarget.MeasureString(sLeftCover, useFont);
var MeasureRight = pRenderTarget.MeasureString(sRightCover, useFont);
PointF LeftPos = new PointF(Bounds.Left - MeasureLeft.Width, Bounds.Top + (Bounds.Height / 2) - MeasureLeft.Height / 2);
PointF RightPos = new PointF(Bounds.Right, Bounds.Top + (Bounds.Height / 2) - MeasureRight.Height / 2);
if (Source.Activated)
{
TetrisGame.DrawText(pRenderTarget, useFont, sLeftCover, new SolidBrush(Source.ForeColor), new SolidBrush(Source.ShadowColor), LeftPos.X, LeftPos.Y);
TetrisGame.DrawText(pRenderTarget, useFont, sRightCover, new SolidBrush(Source.ForeColor), new SolidBrush(Source.ShadowColor), RightPos.X, RightPos.Y);
}
base.Render(pOwner, pRenderTarget, Source, Element);
}
public virtual bool Proc(IStateOwner pOwner, TimeSpan Elapsed)
{
foreach (var iterate in BlocksEffect)
{
ProcessBlock(pOwner, iterate, Elapsed);
}
return(Elapsed > ClearTime);
}
public override Dictionary <string, string> GetDisplayStatistics(IStateOwner pOwner, GameplayGameState Source)
{
var result = base.GetDisplayStatistics(pOwner, Source);
int LineCount = Source.GameStats is TetrisStatistics ? (Source.GameStats as TetrisStatistics).LineCount : 0;
result.Add("Lines", LineCount.ToString());
return(result);
}
public void HandleGameKey(IStateOwner pOwner, GameState.GameKeys g, KeyInputSource pSource)
{
if (pSource == KeyInputSource.Input_Keyboard && CurrentGameState is IDirectKeyboardInputState)
{
return; //do nothing if it supports that interface.
}
CurrentGameState.HandleGameKey(pOwner, g);
}
/// <summary>
/// mutates the given GameplayGameState to prepare it for a new level, and returns it to the caller.
/// </summary>
/// <param name="mutate"></param>
/// <returns></returns>
public GameState SetupNextLevel(GameplayGameState mutate, IStateOwner pOwner)
{
Level++;
PrepareField(mutate, pOwner);
PrimaryBlockAppearanceState levelstarter = new PrimaryBlockAppearanceState(mutate);
return(levelstarter);
}
public override void GameProc(IStateOwner pOwner)
{
if (CompletionMusic == null)
{
//start the victory music... or whatever music we are told to I suppose.
CompletionMusic = TetrisGame.Soundman.PlayMusic(LevelCompleteMusic, 3.0f, false);
}
}
public void SetY(IStateOwner pOwner, int Value)
{
if (pOwner != null)
{
LastFall = pOwner.GetElapsedTime();
}
Y = Value;
}
