DEV Community: Krirk Srithaweewath

I create a Wordle clone using C#

Krirk Srithaweewath — Sat, 19 Nov 2022 19:02:47 +0000

You can look at it here.
https://github.com/KDevZilla/Sharpword

MineSweeper C#

Krirk Srithaweewath — Sun, 13 Nov 2022 15:14:46 +0000

Introduction

I will show you how to develop a MineSweeper game using C#.
The goal of this project is to create a MineSweeper as close to the original using C# WindowsForm.

Rule of MineSweeper.

Click a cell to open it.
If the cell is a mine cell the game is over.
The first cell you click is guaranteed that it will not be a mine cell.
You are given the information from the open cell, the number you see is the number of mine cells around the open cell. To win the game, you need to open all the cells that are not mine cells.

The structure of the program

UI
I use a panel called pnlGame to handle most of the UI in this game.
It contains labels to display cell types.

Board class
int[,] Matrix keeps the cell information.
Boolean[,] IsOpenCell to keep the open/closed state of the cell

ConstCell
Cell has 3 values, Bomb, Blank, HasValue

Game class
Contains the Board object and the status of the game.

The logic behind the game class when the game is created is

Initial Board.
Generate mines on the board randomly.
Loop through all of the board.
if the cell is mine, list all of the neighbor cells (8 adjacent cells next to mine cell)
Loop through all the neighbor cell
if (the neighbor is not mine and does not have the value yet and Random value > 3) set neighbor to be HasValue cell
Loop through all of the cells in the board
if the cell has HasValue type, count the number of mine around the cell (8 adjacent cells next co HasValue cell)

These are the codes.

private void SetBomb(Board pBoard, int NumberofBomb, Position positionDoesnotAllow) {
  int i;
  int j;

  List <Position> listPositionBomb = GetUniqueRandomPosition(pBoard.NoofRow, pBoard.NoofCol, NumberofBomb, positionDoesnotAllow);
  int CellValue = 0;
  for (i = 0; i < NumberofBomb; i++) {
    pBoard.Matrix[listPositionBomb[i].Row, listPositionBomb[i].Col] = ConstCell.Bomb;
  }
}
private void SetHasValueCell(Board pBoard) {
  int i;
  int j;

  for (i = 0; i < pBoard.NoofRow; i++) {
    for (j = 0; j < pBoard.NoofCol; j++) {
      if (pBoard.Matrix[i, j] != ConstCell.Bomb) {
        continue;
      }
      List <Position> listPositionhasValue = GetNeighbourCell(i, j, pBoard.NoofRow, pBoard.NoofCol);
      foreach(Position posi in listPositionhasValue) {
        int NieghbourCellValue = pBoard.Matrix[posi.Row, posi.Col];
        if (NieghbourCellValue.In(ConstCell.Bomb, ConstCell.HasValue)) {
          continue;
        }
        int RandomValue = Random(1, 9);
        if (RandomValue > 3) {
          pBoard.Matrix[posi.Row, posi.Col] = ConstCell.HasValue;
        }
      }

    }
  }
}
public void GenerateMine(Board pBoard) {
  int i;

  int j;

  InitialBoard(pBoard);

  SetBomb(pBoard, this.NumberofMines, this.PostionThatMineMustNotExist);
  if (PostionThatMineMustNotExist.Row == -1) {
    this.board.Matrix[0, 0] = ConstCell.Bomb;
  }

  SetHasValueCell(pBoard);
  for (i = 0; i < pBoard.NoofRow; i++) {
    for (j = 0; j < pBoard.NoofCol; j++) {
      if (pBoard.Matrix[i, j].In(ConstCell.Bomb, ConstCell.Blank)) {
        continue;
      }

      List <Position> listNeighbour = GetNeighbourCell(i, j, pBoard.NoofRow, pBoard.NoofCol);
      int NumberBomb = 0;
      foreach(Position p in listNeighbour) {
        if (pBoard.Matrix[p.Row, p.Col] == ConstCell.Blank) {
          continue;
        }

        if (pBoard.Matrix[p.Row, p.Col] == ConstCell.Bomb) {
          NumberBomb++;
        }
      }
      pBoard.Matrix[i, j] = NumberBomb;
    }
  }

}

The logic behind the cell click event is

If the Cell is not opened yet, just open it.
If it is a blank cell, open the neighbor blank cell.
after the cell is opened the game object will calculate the result if the game state is finished if the first click got a mine cell (first-time bad luck) just restart the game without losing. (Our game tries to prevent a first-time bad luck). else show the result

    private void UserClick(Game pGame, int Row, int Column) {
      if (MineSweep.GameState == GameStateEnum.End) {
        return;
      }

      bool IsThisCellAlreayOpen = pGame.board.IsOpenCell[Row, Column];
      if (IsThisCellAlreayOpen) {
        return;
      }

      pGame.OpenCell(Row, Column);
      if (this.timer1.Enabled == false) {
        StartTimer();
      }
      int CellValue = pGame.board.Matrix[Row, Column];
      if (pGame.board.Matrix[Row, Column] == ConstCell.Blank) {
        pGame.OpenNeighborBlankCell(Row, Column);
      }

      if (pGame.GameState == GameStateEnum.Running) {
        ShowFaceWonder();
        return;
      }

      if (pGame.GameState == GameStateEnum.End) {
        if (!pGame.HasSuccessfulClickthefirstCellWithoutDie) {
          Position ByPassPositionFortheNewGame = new Position(Row, Column);
          NewGame(ByPassPositionFortheNewGame);
          UserClick(MineSweep, Row, Column);
          return;
        }

        StopTimer();
        if (pGame.GameResult == GameResultEnum.Lost) {
          ShowFaceLost();
        } else {
          ShowFaceWon();
          if (MineSweep.GameDifficultLevel == 4) {
            return;
          }

          String message = @ "You broke a record for " + arrDifficultLevel[MineSweep.GameDifficultLevel];
          if (MineSweep.Seconds < score.GetSecond(MineSweep.GameDifficultLevel)) {
            FormEnterNewTimeRecord f = new FormEnterNewTimeRecord();
            f.Message = message;
            f.PreviousRecordName = score.GetName(MineSweep.GameDifficultLevel);
            f.ShowDialog();
            if (f.DialogResult != DialogResult.OK) {
              return;
            }
            score.SetSecond(MineSweep.GameDifficultLevel, MineSweep.Seconds);
            score.SetName(MineSweep.GameDifficultLevel, f.NewName);
            SaveScore();
          }
        }
      }

    }

    public void OpenNeighborBlankCell(int Row, int Column) {
      List < Position > listNeighborRecursive = new List < Position > ();
      HashSet < int > hshNeighborRecursive = new HashSet < int > ();
      GetNeighbourCellRecursive(listNeighborRecursive,
        hshNeighborRecursive,
        Row,
        Column,
        board.NoofRow,
        board.NoofCol,
        ConstCell.Blank);

      listNeighborRecursive.ForEach(x => OpenCell(x.Row, x.Col));
      int i;
      foreach(Position po in listNeighborRecursive) {
        List < Position > listNeighbourNotBlank = GetNeighbourCell(po.Row, po.Col, board.NoofRow, board.NoofCol);
        foreach(Position poNotBlank in listNeighbourNotBlank) {
          if (!board.Matrix[poNotBlank.Row, poNotBlank.Col].IsBetween(1, 8)) {
            continue;
          }
          OpenCell(poNotBlank);
        }
      }
    }

    private List < Position > GetNeighbourCellRecursive(List < Position > lisNeighborAll, HashSet < int > HshNeighborAll, int Row, int Column, int NoofRow, int NoofCol, int CellValueCriteria) {
        List < Position > listNeighbor = GetNeighbourCell(Row, Column, board.NoofRow, board.NoofCol);
        foreach(Position pos in listNeighbor) {

          if (board.Matrix[pos.Row, pos.Col] != CellValueCriteria) {
            continue;
          }
          int HashValue = pos.Row * NoofRow + pos.Col;
          if (HshNeighborAll.Contains(HashValue)) {
            continue;
          }
          HshNeighborAll.Add(HashValue);
          lisNeighborAll.Add(pos.Clone());
          List < Position > listNeighborChild = GetNeighbourCellRecursive(lisNeighborAll,

          }
          return listNeighbor;

        }

PuppyBox

Krirk Srithaweewath — Sun, 13 Nov 2022 15:14:09 +0000

Introduction

Github repo
Download Exe

This is a clone go Gecko Shuffle game.

Rule of this game

There are 3 boxes, 2 of which are blank boxes, and one of which features a picture of a puppy.
Three of them will move at random.
You choose the one you believe it is a puppy box.
After you have choosen the box, program will reveal which box is a puppy.
The more choices you guess correctly, the more points you receive.

The Code
This game is so small. So almost all of the logics are in the same place as UI.

The UI
Form1 contains the logic to shuffle and move the boxes,
the control we use for rendering the boxes is picturebox.

The Game
Game class keeps the score, box moving speed, current level, game state information.

Box class
This class reponsible for drawing itself.
There are 5 states of the box.

Drawing animation
The logic behind drawing an animation is in Form1.OpenBox() method.
Program will loop though all of the BoxStateEnum
then set a boxstate to a specific box object then call RefreshUI() method.

private void OpenBox(int BoxIndex) {
  var values = Enum.GetValues(typeof (Box.BoxStateEnum));
  foreach(Box.BoxStateEnum state in values) {
    boxs[BoxIndex].BoxState = state;
    RefreshUI();
    Wait(MiliSecondAnimationWaitEachFrame);

  }

}

public enum BoxStateEnum {
  Close,
  BegintoOpen1,
  BegintoOpen2,
  BegintoOpen3,
  Open
}

The logic behind drawing method is using Graphics.FillPolygon() method.
We have DrawClose(),
DrawBeginToOpen1(),
DrawBeginToOpen2(),
DrawBeginToOpen3(),
DrawOpen()

These method follow the same logic

Create a list of Point
using FillPolyGon method to draw each part of the picture. For DrawClose() and DrowOpen, it is quite simple but for DrawBegingToOpen1(), DrawBegingToOpen2(), DrawBegingToOpen3() They are quite complicated.

    private void DrawClose(Graphics g) {
      Rectangle FillArea = new Rectangle(new Point(Left, Top), new Size(Width - 2, Height - 2));
      g.FillRectangle(BackBrush, FillArea);
      List < Point > listPoint = new List < Point > ();

      Point LeftSideTopLeft = new Point(TopLeftPoint.X - this.BoxLength, TopLeftPoint.Y + this.BoxLength);
      Point LeftSideBottomLeft = new Point(LeftSideTopLeft.X, LeftSideTopLeft.Y + this.Height);

      listPoint.Add(TopLeftPoint);
      listPoint.Add(LeftSideTopLeft);
      listPoint.Add(LeftSideBottomLeft);
      listPoint.Add(BottomLeftPoint);

      g.FillPolygon(BackBrush, listPoint.ToArray());
      listPoint.Clear();
      Point DownSideBottomLeft = LeftSideBottomLeft;
      Point DownSideBottomRight = new Point(LeftSideBottomLeft.X + this.Width, DownSideBottomLeft.Y);
      Point DownSideTopRight = BottomRightPoint;

      listPoint.Add(BottomLeftPoint);
      listPoint.Add(DownSideBottomLeft);
      listPoint.Add(DownSideBottomRight);
      listPoint.Add(DownSideTopRight);

      g.FillPolygon(BackBrush, listPoint.ToArray());
    }
    int BoxLength = 10;

    private void DrawBeginToOpen1(Graphics g) {
      Point TopLeftCustom = new Point(TopLeftPoint.X - 10, TopLeftPoint.Y + 10);
      Point BottomLeftCustom = new Point(TopLeftCustom.X, TopLeftCustom.Y + this.Height);
      Point TopRightCustom = new Point(TopLeftPoint.X + this.Width - 10, TopLeftCustom.Y - 30);
      Point BottomRightCustom = new Point(TopLeftPoint.X + this.Width - 10, TopRightCustom.Y + this.Height);
      List < Point > listPoint = new List < Point > ();

      listPoint.Add(TopLeftCustom);
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(BottomRightCustom);
      listPoint.Add(TopRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

      Point DownSideBottomLeft = new Point(BottomLeftCustom.X + 10, BottomLeftCustom.Y + 10);
      Point DownSideBottomRight = new Point(BottomRightCustom.X + 10, BottomRightCustom.Y + 10);
      listPoint = new List < Point > ();
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(DownSideBottomLeft);
      listPoint.Add(DownSideBottomRight);
      listPoint.Add(BottomRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

      Point RightSideTopRight = new Point(TopRightCustom.X + 10, TopRightCustom.Y + 10);
      Point RightSideBottomRight = new Point(BottomRightCustom.X + 10, BottomRightCustom.Y + 10);
      listPoint = new List < Point > ();
      listPoint.Add(TopRightCustom);
      listPoint.Add(RightSideTopRight);
      listPoint.Add(RightSideBottomRight);
      listPoint.Add(BottomRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

    }

    private void DrawBeginToOpen2(Graphics g) {

      Point TopLeftCustom = new Point(TopLeftPoint.X + BoxLength, TopLeftPoint.Y + BoxLength);
      Point BottomLeftCustom = new Point(TopLeftCustom.X, TopLeftCustom.Y + this.Height);
      Point TopRightCustom = new Point(TopLeftPoint.X + (this.Width / 2) - 10, TopLeftCustom.Y - (this.Height / 2));
      Point BottomRightCustom = new Point(TopLeftPoint.X + (this.Width / 2) - 10, TopRightCustom.Y + this.Height);
      List < Point > listPoint = new List < Point > ();

      listPoint.Add(TopLeftCustom);
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(BottomRightCustom);
      listPoint.Add(TopRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

      Point DownSideBottomLeft = new Point(BottomLeftCustom.X + BoxLength, BottomLeftCustom.Y);
      Point DownSideBottomRight = new Point(BottomRightCustom.X + BoxLength, BottomRightCustom.Y);
      listPoint = new List < Point > ();
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(DownSideBottomLeft);
      listPoint.Add(DownSideBottomRight);
      listPoint.Add(BottomRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

      Point RightSideTopRight = new Point(TopRightCustom.X + BoxLength, TopRightCustom.Y);
      Point RightSideBottomRight = new Point(BottomRightCustom.X + BoxLength, BottomRightCustom.Y);
      listPoint = new List < Point > ();
      listPoint.Add(TopRightCustom);
      listPoint.Add(RightSideTopRight);
      listPoint.Add(RightSideBottomRight);
      listPoint.Add(BottomRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());
    }
    private void DrawBeginToOpen3(Graphics g) {
      Point TopLeftCustom = new Point(TopLeftPoint.X + 20, TopLeftPoint.Y - 20);
      Point BottomLeftCustom = new Point(TopLeftCustom.X, TopLeftCustom.Y + this.Height);
      Point TopRightCustom = new Point(TopLeftPoint.X + this.Width - 20, TopLeftCustom.Y + this.BoxLength);
      Point BottomRightCustom = new Point(TopRightCustom.X, TopRightCustom.Y + this.Height);
      List < Point > listPoint = new List < Point > ();

      listPoint.Add(TopLeftCustom);
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(BottomRightCustom);
      listPoint.Add(TopRightCustom);
      g.FillPolygon(FaceBrushEmpty, listPoint.ToArray());

      Point LeftSideTopLeft = new Point(TopLeftCustom.X - BoxLength, TopLeftCustom.Y + this.BoxLength);
      Point LeftSideBottomLeft = new Point(LeftSideTopLeft.X, LeftSideTopLeft.Y + this.Height);
      listPoint = new List < Point > ();
      listPoint.Add(TopLeftCustom);
      listPoint.Add(LeftSideTopLeft);
      listPoint.Add(LeftSideBottomLeft);
      listPoint.Add(BottomLeftCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

      Point DownSideBottomRight = new Point(BottomRightCustom.X - BoxLength, BottomRightCustom.Y + BoxLength);
      listPoint = new List < Point > ();
      listPoint.Add(BottomLeftCustom);
      listPoint.Add(LeftSideBottomLeft);
      listPoint.Add(DownSideBottomRight);
      listPoint.Add(BottomRightCustom);
      g.FillPolygon(BackBrush, listPoint.ToArray());

    }
    private void DrawOpen(Graphics g) {
      DrawClose(g);
      Rectangle FillArea = new Rectangle(new Point(Left + 1, Top + 1), new Size(Width - 2, Height - 2));

      g.FillRectangle(BackBrush, FillArea);
      if (IsDog) {
        g.DrawImage(DogImage, FillArea);
      } else {
        g.FillRectangle(FaceBrushEmpty, FillArea);
      }

    }

For the ShuffleBox,
the first parameter is Direction, there are 2 directions ClockWise, AntiClockWise,
the second is From
the third is to

We have DictionaryPositionToBoxIndex to keep the indexposition
and boxs to keep the list of the box object.
The reason we need DictionaryPositionToBoxIndex is
Supposing at the initial state we have boxes in this order.
box1, box2, box3

Then we shuffle between the first box and the second box, here is the result.
box3, box2, box1

If we would like to shuffle between the first box and the second box
we need to shuffle between box3 and box2
DictionaryPositionToBoxIndex can tell us
the firstbox is box3 not box1 anymore.

    private void DoShuffleBox(DirectionEnum Direction, int From, int To, int SpeedLevel) {
      Box boxFrom = null;
      Box boxTo = null;
      int IndexFrom = DictionaryPositionToBoxIndex[From];
      int IndexTo = DictionaryPositionToBoxIndex[To];

      boxFrom = boxs[IndexFrom];
      boxTo = boxs[IndexTo];

      if (Direction == DirectionEnum.ClockWise) {
        while (boxFrom.Top > TopPosition) {
          boxFrom.Top -= SpeedLevel;
          boxTo.Top += SpeedLevel;
          pictureBox1.Refresh();

        }
        while (boxFrom.Left < listPositionBox[To].X) {
          boxFrom.Left += SpeedLevel;
          boxTo.Left -= SpeedLevel;
          pictureBox1.Refresh();
        }
        while (boxFrom.Top < NormalTopPosition) {
          boxFrom.Top += SpeedLevel;
          boxTo.Top -= SpeedLevel;
          pictureBox1.Refresh();

        }
      } else {
        while (boxFrom.Top < BottopPosition) {
          boxFrom.Top += SpeedLevel;
          boxTo.Top -= SpeedLevel;
          pictureBox1.Refresh();

        }
        while (boxFrom.Left < listPositionBox[To].X) {
          boxFrom.Left += SpeedLevel;
          boxTo.Left -= SpeedLevel;
          pictureBox1.Refresh();
        }
        while (boxTo.Top < NormalTopPosition) {
          boxTo.Top += SpeedLevel;
          boxFrom.Top -= SpeedLevel;
          pictureBox1.Refresh();

        }
      }
      ShuffleBoxPosition(From, To);
    }

Reference

This is a clone of Gecko Shuffle game
You can watch the the Original Gecko Shuffle here
https://www.youtube.com/watch?v=u5SKVLbDNrE&ab_channel=258JD
https://archive.org/details/win3_gecko
https://gamesdb.launchbox-app.com/games/images/105102

puppy.png credit
https://pngtree.com/so/cute