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; }