Expert Review 09-03-2024¶

Inhoud¶

K1¶

Je hebt object georiënteerde software gemaakt die samenwerkt met een database.¶

Object Oriented Programming(OOP)¶

Tijdens het coderen van ons Match 3 spel hebben wij gebruik gemaakt van Object Oriented Programming(OOP). Hieronder hebben wij een paar voorbeelden gegeven.

Wat is Object Oriented Programming(OOP)¶

OOP bestaat uit Encapsulation, Abstraction, Inheritance en Polymorphism. Het is een manier van coderen die gebruik maakt van Objecten en Classes. Op die manier is een code minder complex en herbruikbaar.(OOP Denken), (OOP Uitleg), (OOP Wikipedia)

Encapsulation¶

Wat is Encapsulation¶

Encapsulation is een van de 4 basis principe’s van OOP. Encapsulation betekent het bundelen van gegevens aan de Class. Daarmee kan het object veranderd worden zonder dat het gevolgen heeft op de code. Daardoor wordt alleen de nodige code laten zien en de rest verborgen.(Encapsulation)

Gebruik van Encapsulation¶

Chessboard Method in Gamestate.cs¶

Waarom deze manier?

Encapsulation gaat over het bundelen van gegevens aan een Class, daarmee word alleen de nodige code gelezen en vrij gegeven en de rest verborgen. Deze Private Method over het Laden en Tekenen van het Chessboard is alleen nodig in de Gamestate.cs, dus is de Method Private en dus alleen accessable in Gamestate.cs.

Wat doet de code

Deze Code Laad de Sprite Chessboard, zet de Locatie, Grootte en tekent hem op het scherm. Daarbuiten maakt hij ook Floats van de Randen en de Border van de Chessboard.

Bronnen

Encapsulation

Code

Gamestate.csEncapsulation

    private void Chessboard()
    {
        ChessBackground = new SpriteGameObject("Images/UI/Chess", 0, "Chess");
        ChessBackground.Position = new Vector2((GameEnvironment.Screen.X - ChessBackground.Width) / 2, (GameEnvironment.Screen.Y - ChessBackground.Height) / 2 - 25);
        ChessBackground.Scale = 0.9f;
        Add(ChessBackground);
        float leftEdge = ChessBackground.Position.X - 72.5f;
        float topEdge = ChessBackground.Position.Y - 72.5f;
        float rightEdge = leftEdge + 72.5f + (ChessBackground.Width * ChessBackground.Scale);
        float bottomEdge = topEdge + 217.5f + (ChessBackground.Height * ChessBackground.Scale);
        ChessboardBounds = new Rectangle((int)leftEdge, (int)topEdge, (int)rightEdge, (int)bottomEdge);

    }

private void Chessboard()

Abstraction¶

Wat is Abstraction¶

Abstraction is een van de 4 basis principe’s van OOP. Abstraction gaat om het makkelijker maken van de code door minder belangrijke details weg te laten, hierdoor kan je focusen op de belangrijke dingen en wordt de code makkelijker leesbaar.(Abstraction)

Gebruik van Abstraction¶

Piece.cs - Gamestate.cs¶

Waarom deze manier?

Abstraction gaat over het hergebruiken van code om de code te optimaliseren en makkelijker leesbaar te maken. Met deze code wil ik aantonen dat ik alle Sprites van de Images Draw in 1 line en alle pawns teken in een loop. Daarmee is de code makkelijk leesbaar en kleiner dan als ik alles handmatig had gedaan.

Wat doet de code

Piece.cs Laad de Piece Sprites en scaled ze correct.
Het fragment van Gamestate is een For Loop die alle Pawns op de correcte locatie tekent

Bronnen

Abstraction

Code

Piece.csGamestate.csAbstraction

    public class Piece : GameObjectList
    {
        protected SpriteGameObject piece;
        public SpriteGameObject Sprite => piece;
        public float Width => this.Sprite.Width;
        public float Height => this.Sprite.Height;

        public PieceType Type { get; } 

        public Piece(PieceType type, PieceColor color) : base()
        {
            Type = type; 

            string PieceTypeName = type.ToString();
            string PieceColor = color.ToString();

            piece = new SpriteGameObject($"Images/Pieces/{PieceTypeName}{PieceColor}", 0, $"{PieceTypeName}{PieceColor}");

            piece.Scale = 0.30f;
            Add(piece);
        }
        public override Rectangle BoundingBox
        {
            get
            {
                int adjustedX = (int)Position.X + 25;
                int adjustedY = (int)Position.Y + 75;
                return new Rectangle(adjustedX, adjustedY, (int)Width, (int)Height);
            }
        }
    }

        private void DrawPieces()
    {

        for (int i = 0; i < 7; i++)
        {
            Piece pawnWhite = new Piece(PieceType.Pawn, PieceColor.White);
            pawnWhite.Position = new Vector2(358 + (i * 72.5f), 470.5f);
            Add(pawnWhite);
            whitePawns.Add(pawnWhite);
            Piece pawnBlack = new Piece(PieceType.Pawn, PieceColor.Black);
            pawnBlack.Position = new Vector2(358 + (i * 72.5f), 40);
            Add(pawnBlack);
            blackPawns.Add(pawnBlack);
        }
    }

    piece = new SpriteGameObject($"Images/Pieces/{PieceTypeName}{PieceColor}", 0, $"{PieceTypeName}{PieceColor}");

    for (int i = 0; i < 7; i++)
    {
        Piece pawnWhite = new Piece(PieceType.Pawn, PieceColor.White);
        pawnWhite.Position = new Vector2(358 + (i * 72.5f), 470.5f);
    }

Inheritance¶

Wat is Inheritance¶

Inheritance is een van de 4 basis principe’s van OOP. Inheritance gaat om het herbruiken van code door een nieuwe class te maken die alle waardes van de andere class krijgt. daardoor hoeven die waardes niet opnieuw aangegeven worden en word er dus heel veel onnodige code verwijderd. Vaak worden die nieuwe classes sub-classes genoemt.(Inheritance)

Gebruik van Inheritance¶

Piece.cs - GameObjectList.cs¶

Waarom deze manier?

Inheritance betekent dat een Mechanisme of Class is gebouwt op/vanaf een andere Class. Met deze code wil ik dus aantonen dat onze Piece.cs class geinherit is vanaf GameObjectList.cs

Wat doet de code

Deze Code laad de Spriteobject van alle pieces en scaled ze naar de juiste grootte voor de game.

Bronnen

Inheritance

Code

Piece.csInheritance

    public class Piece : GameObjectList
    {
        protected SpriteGameObject piece;
        public SpriteGameObject Sprite => piece;
        public float Width => this.Sprite.Width;
        public float Height => this.Sprite.Height;

        public PieceType Type { get; } 

        public Piece(PieceType type, PieceColor color) : base()
        {
            Type = type; 

            string PieceTypeName = type.ToString();
            string PieceColor = color.ToString();

            piece = new SpriteGameObject($"Images/Pieces/{PieceTypeName}{PieceColor}", 0, $"{PieceTypeName}{PieceColor}");

            piece.Scale = 0.30f;
            Add(piece);
        }
        public override Rectangle BoundingBox
        {
            get
            {
                int adjustedX = (int)Position.X + 25;
                int adjustedY = (int)Position.Y + 75;
                return new Rectangle(adjustedX, adjustedY, (int)Width, (int)Height);
            }
        }
    }

public class Piece : GameObjectList

Polymorphism¶

Wat is Polymorphism¶

Polymorphism is een van de 4 basis principe’s van OOP. Polymorphism gaat om het herbruiken van functions door de Sub class de Main class te laten override. Hierdoor hoef je geen onnodige Functions te schrijven en is het makkelijk om nieuwe Objects of code toe te voegen, De code is hierdoor overzichtelijker en Makkelijker te lezen en aan te passen.Polymorphism

Gebruik van Polymorphism¶

Piece.cs - Pawn.cs¶

Waarom deze manier?

Polymorphism betekent dat een Geinherited Class de Main Class override zodat 1 functie meerdere uitkomsten kan hebben. Ik heb Polymorphism toe gevoegd in mijn Pieces zodat ik 1 algemene Movement Method heb die de Pieces dan kunnen override. Hierdoor is mijn code klein en duidelijk en als ik ooit een nieuwe piece wil aanmaken is dat gemakkelijk te doen zonder allemaal files aan te hoeven passen.

Wat doet de code

Deze Code override de algemene GetPossibleMoves waardoor Polymorphism wordt toegevoegd om de Code leesbaar en overzichtelijk te maken.

Bronnen

Polymorphism

Code

Piece.cs - GetPossibleMovesPawn.cs - Polymorphism

    public virtual bool GetPossibleMoves()
    {
        return false;
    }

public override bool GetPossibleMoves()
{
    Console.WriteLine("Pawn Movement");
    bool hasPossibleMoves = true;

    return hasPossibleMoves;
}

EER¶

EER

Class Diagram¶

Class Diagram

K3¶

Je hebt een infrastructuur ontworpen en gebouwd volgens de gegeven specificaties.¶

JSONGamestate.cs Variable CreationGamestate.cs - GetTeamId FunctionGamestate.cs - Check Team to PieceColorLobbyJoinGamestate.cs - OnEnterRoomData

namespace Blok3Game.Engine.JSON
{
    public class Team : DataPacket
    {
        public string SessionId { get; set; }

        public string UserId { get; set; }

        public string RoomId { get; set; }
        public string TeamId { get; set; }

        public Team() : base()
        {
            EventName = "Team Selected";
        }
    }
}

public static Team CurrentTeam { get; private set; } = new Team();

public static void GetTeamId(string teamId)
{
    CurrentTeam.TeamId = teamId;
    Console.WriteLine("TeamId: " + CurrentTeam.TeamId);
}

    if (CurrentTeam.TeamId == SelectedPiece.Color)
    {
            previousTile = FindTileById(SelectedPiece.TileID);

            if (previousTile != null)
            {
                previousTile.OccupyingPiece = null;
            }

            Console.WriteLine($"Moving Piece: {SelectedPiece}, to {clickedTile.ID}");
            SelectedPiece.Position = clickedTile.CenterPosition;
            SelectedPiece.TileID = clickedTile.ID;
            clickedTile.OccupyingPiece = SelectedPiece;

            SelectedPiece = null;
            previousTile.OccupyingPiece = null;
    }

    private void OnEnterRoomData(EnterRoomData data)
    {
        if (data.Player.UserId == SocketClient.Instance.UserId)
        {
            nextScreenName = GameStateManager.LOBBY_WAIT_FOR_PLAYERS_STATE;
            Animate(AnimationState.MovingOffscreenInactive);
        }
        Team team = new();
        players = LobbyWaitForPlayersState.PlayersCount;
        team.TeamId = players == 1 ? "White" : "Black";
        SocketClient.Instance.SendDataPacket(team);
        GameState.GetTeamId(team.TeamId);

    }

Netwerk Diagram¶

Network Diagram

Sequence Diagram¶

Sequence Diagram

G1¶

Je ontwikkelt je op persoonlijk vlak en blijft leren.¶

Aan het begin van Blok 3 had ik nog nooit C# aan geraakt. Tijdens de Voorjaars vakantie heb ik me dus vooral gefocust op het leren van C# en Monogame en het resultaat is het huidige product van het spel. Ik heb Tijdens Sprint 1 en 2 de Grid en Pieces getekent en de Logica van de Pawn en Toren gemaakt! in Sprint 3 ben ik verbeterd door Polymorphism aan de Movement toe te voegen EN de Teams te syncen met de Server waardoor team zwart geen witten pieces kan bewegen en vice versa.

Bronnen

Algemene Bronnen¶

Last update: March 28, 2024