Design Connect Four – انجمن DEV

Summarize this content to 400 words in Persian Lang
سناریوهای طراحی بازی در مصاحبه های OOAD یک ارزیابی کامل از مهارت های برنامه نویسی شی گرا، توانایی های حل مسئله و تفکر طراحی یک نامزد ارائه می دهد. آن‌ها به شرکت‌ها اجازه می‌دهند مهندسان نرم‌افزاری را که می‌توانند به طور مؤثر ایده‌های مفهومی را به سیستم‌های کارآمد تبدیل کنند، شناسایی کنند.**

ارزیابی اصول OO:

کلاس ها و اشیاء: بازی ها به طور طبیعی خود را به بازنمایی شی گرا می دهند. داوطلبان باید کلاس هایی مانند Player، Card، GameBoardو غیره، درک خود را از ایجاد شی و تعامل نشان می دهد.

وراثت: بازی ها اغلب دارای اشیایی با ویژگی ها و رفتارهای مشابه هستند. وراثت امکان استفاده مجدد از کد را با ایجاد کلاس های پایه مانند GamePiece و زیر کلاس هایی مانند ChessPiece یا PuzzlePiece. مصاحبه کننده می تواند توانایی شما در شناسایی سلسله مراتب وراثت مناسب را ارزیابی کند.

پلی مورفیسم: بازی ها ممکن است اشیایی داشته باشند که به یک عمل مشابه واکنش متفاوتی نشان دهند. به عنوان مثال، مهره های مختلف شطرنج به طور متفاوتی حرکت می کنند. مصاحبه می تواند درک شما از چندشکلی را از طریق روش هایی مانند move() که بر اساس زیر کلاس رفتار متفاوتی دارند.

کپسوله سازی: بازی ها باید داده ها و منطق را در داخل اشیاء محصور کنند. مصاحبه‌گر می‌تواند ببیند آیا کلاس‌هایی طراحی می‌کنید که جزئیات پیاده‌سازی داخلی را پنهان می‌کنند و روش‌های دسترسی مناسب را ارائه می‌دهند.

مهارت های حل مسئله و طراحی:

پیچیدگی شکست: بازی ها قوانین و مکانیزم هایی دارند. این مصاحبه توانایی شما را در تجزیه و تحلیل مشکل، شناسایی اجزای اصلی و طراحی سیستمی که الزامات بازی را برآورده می کند، ارزیابی می کند.

تفکر الگوریتمی: بازی ها اغلب شامل محاسبات، تصمیم گیری و مدیریت وضعیت بازی هستند. در مصاحبه می توانید ببینید که آیا می توانید منطق اصلی بازی را با استفاده از الگوریتم ها و ساختارهای داده مناسب پیاده سازی کنید.

زمینهConnect Four یک بازی محبوب است که بر روی یک شبکه 7×6 بازی می شود. دو بازیکن به نوبت دیسک های رنگی را داخل شبکه می اندازند. اولین بازیکنی که چهار دیسک پشت سر هم (عمودی، افقی یا مورب) دریافت کند برنده است.

الزاماتچند سوال احتمالی برای پرسیدن:

قوانین بازی چیست؟اندازه شبکه چقدر است؟چند بازیکن وجود دارد؟ بازیکن در مقابل کامپیوتر؟ بازیکن در مقابل بازیکن؟آیا ما امتیاز را دنبال می کنیم؟مبانیبازی فقط توسط دو بازیکن انجام خواهد شد، بازیکن در مقابل بازیکنصفحه بازی باید دارای ابعاد متغیر باشدهدف اتصال N دیسک در یک ردیف (عمودی، افقی یا مورب) است.N یک متغیر است (به عنوان مثال اتصال 4، 5، 6، و غیره)باید یک سیستم ردیابی امتیاز وجود داشته باشدپس از اینکه یک بازیکن به امتیاز مورد نظر رسید، برنده است

طرحسطح بالاما به یک کلاس Grid برای حفظ وضعیت برد 2 بعدی نیاز داریمسلول تخته می تواند خالی، زرد (اشغال شده توسط بازیکن 1) یا قرمز ( اشغال شده توسط بازیکن 2) باشد.شبکه همچنین مسئول بررسی شرایط برد خواهد بودما می توانیم یک کلاس Player برای نمایش رنگ قطعه بازیکن داشته باشیماین خیلی مهم نیست، اما کپسوله کردن اطلاعات به طور کلی روش خوبی استکلاس Game از Grid و Players تشکیل خواهد شدکلاس Game مسئول حلقه بازی و پیگیری امتیاز خواهد بودکد

import java.util.*;

enum GridPosition {
EMPTY, YELLOW, RED
}

class Grid {
private int rows;
private int columns;
private int[][] grid;

public Grid(int rows, int columns) {
this.rows = rows;
this.columns = columns;
initGrid();
}

public void initGrid() {
this.grid = new int[rows][columns];
for (int i = 0; i rows; i++) {
for (int j = 0; j columns; j++) {
grid[i][j] = GridPosition.EMPTY.ordinal();
}
}
}

public int[][] getGrid() {
return this.grid;
}

public int getColumnCount() {
return this.columns;
}

public int placePiece(int column, GridPosition piece) {
if (column 0 || column >= this.columns) {
throw new Error(“Invalid column”);
}
if (piece == GridPosition.EMPTY) {
throw new Error(“Invalid piece”);
}
// Place piece in the lowest empty row
for (int row = this.rows – 1; row >= 0; row–) {
if (this.grid[row][column] == GridPosition.EMPTY.ordinal()) {
this.grid[row][column] = piece.ordinal();
return row;
}
}
return -1;
}

public boolean checkWin(int connectN, int row, int col, GridPosition piece) {
// Check horizontal
int count = 0;
for (int c = 0; c this.columns; c++) {
if (this.grid[row][c] == piece.ordinal()) {
count++;
} else {
count = 0;
}
if (count == connectN) {
return true;
}
}

// Check vertical
count = 0;
for (int r = 0; r this.rows; r++) {
if (this.grid[r][col] == piece.ordinal()) {
count++;
} else {
count = 0;
}
if (count == connectN) {
return true;
}
}

// Check diagonal
count = 0;
for (int r = 0; r this.rows; r++) {
int c = row + col – r; // row + col = r + c, for a diagonal
if (c >= 0 && c this.columns && this.grid[r][c] == piece.ordinal()) {
count++;
} else {
count = 0;
}
if (count == connectN) {
return true;
}
}

// Check anti-diagonal
count = 0;
for (int r = 0; r this.rows; r++) {
int c = col – row + r; // row – col = r – c, for an anti-diagonal
if (c >= 0 && c this.columns && this.grid[r][c] == piece.ordinal()) {
count++;
} else {
count = 0;
}
if (count == connectN) {
return true;
}
}
return false;
}
}

class Player {
private String name;
private GridPosition piece;

public Player(String name, GridPosition piece) {
this.name = name;
this.piece = piece;
}

public String getName() {
return this.name;
}

public GridPosition getPieceColor() {
return this.piece;
}
}

class Game {
static Scanner input = new Scanner(System.in);
private Grid grid;
private int connectN;
private Player[] players;
private MapString, Integer> score;
private int targetScore;

public Game(Grid grid, int connectN, int targetScore) {
this.grid = grid;
this.connectN = connectN;
this.targetScore = targetScore;

this.players = new Player[] {
new Player(“Player 1”, GridPosition.YELLOW),
new Player(“Player 2”, GridPosition.RED)
};

this.score = new HashMap();
for (Player player : this.players) {
this.score.put(player.getName(), 0);
}
}

private void printBoard() {
System.out.println(“Board:”);
int[][] grid = this.grid.getGrid();
for (int i = 0; i grid.length; i++) {
String row = “”;
for (int piece : grid[i]) {
if (piece == GridPosition.EMPTY.ordinal()) {
row += “0 “;
} else if (piece == GridPosition.YELLOW.ordinal()) {
row += “Y “;
} else if (piece == GridPosition.RED.ordinal()) {
row += “R “;
}
}
System.out.println(row);
}
System.out.println();
}

private int[] playMove(Player player) {
printBoard();
System.out.println(player.getName() + “‘s turn”);
int colCnt = this.grid.getColumnCount();

System.out.print(“Enter column between 0 and ” + (colCnt – 1) + ” to add piece: “);
int moveColumn = input.nextInt();
int moveRow = this.grid.placePiece(moveColumn, player.getPieceColor());
return new int[] { moveRow, moveColumn };
}

private Player playRound() {
while (true) {
for (Player player : this.players) {
int[] pos = playMove(player);
int row = pos[0];
int col = pos[1];
GridPosition pieceColor = player.getPieceColor();
if (this.grid.checkWin(this.connectN, row, col, pieceColor)) {
this.score.put(player.getName(), this.score.get(player.getName()) + 1);
return player;
}
}
}
}

public void play() {
int maxScore = 0;
Player winner = null;
while (maxScore this.targetScore) {
winner = playRound();
System.out.println(winner.getName() + ” won the round”);
maxScore = Math.max(this.score.get(winner.getName()), maxScore);

this.grid.initGrid(); // reset grid
}
System.out.println(winner.getName() + ” won the game”);
}
}

class Main {
public static void main(String[] args) {
Grid grid = new Grid(6, 7);
Game game = new Game(grid, 4, 10);
game.play();
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

import java.util.*;

enum GridPosition {
    EMPTY, YELLOW, RED
}

class Grid {
    private int rows;
    private int columns;
    private int[][] grid;

    public Grid(int rows, int columns) {
        this.rows = rows;
        this.columns = columns;
        initGrid();
    }

    public void initGrid() {
        this.grid = new int[rows][columns];
        for (int i = 0; i  rows; i++) {
            for (int j = 0; j  columns; j++) {
                grid[i][j] = GridPosition.EMPTY.ordinal();
            }
        }
    }

    public int[][] getGrid() {
        return this.grid;
    }

    public int getColumnCount() {
        return this.columns;
    }

    public int placePiece(int column, GridPosition piece) {
        if (column  0 || column >= this.columns) {
            throw new Error("Invalid column");
        }
        if (piece == GridPosition.EMPTY) {
            throw new Error("Invalid piece");
        }
        // Place piece in the lowest empty row
        for (int row = this.rows - 1; row >= 0; row--) {
            if (this.grid[row][column] == GridPosition.EMPTY.ordinal()) {
                this.grid[row][column] = piece.ordinal();
                return row;
            }
        }
        return -1;
    }

    public boolean checkWin(int connectN, int row, int col, GridPosition piece) {
        // Check horizontal
        int count = 0;
        for (int c = 0; c  this.columns; c++) {
            if (this.grid[row][c] == piece.ordinal()) {
                count++;
            } else {
                count = 0;
            }
            if (count == connectN) {
                return true;
            }
        }

        // Check vertical
        count = 0;
        for (int r = 0; r  this.rows; r++) {
            if (this.grid[r][col] == piece.ordinal()) {
                count++;
            } else {
                count = 0;
            }
            if (count == connectN) {
                return true;
            }
        }

        // Check diagonal
        count = 0;
        for (int r = 0; r  this.rows; r++) {
            int c = row + col - r; // row + col = r + c, for a diagonal
            if (c >= 0 && c  this.columns && this.grid[r][c] == piece.ordinal()) {
                count++;
            } else {
                count = 0;
            }
            if (count == connectN) {
                return true;
            }
        }

        // Check anti-diagonal
        count = 0;
        for (int r = 0; r  this.rows; r++) {
            int c = col - row + r; // row - col = r - c, for an anti-diagonal
            if (c >= 0 && c  this.columns && this.grid[r][c] == piece.ordinal()) {
                count++;
            } else {
                count = 0;
            }
            if (count == connectN) {
                return true;
            }
        }
        return false;
    }
}

class Player {
    private String name;
    private GridPosition piece;

    public Player(String name, GridPosition piece) {
        this.name = name;
        this.piece = piece;
    }

    public String getName() {
        return this.name;
    }

    public GridPosition getPieceColor() {
        return this.piece;
    }
}

class Game {
    static Scanner input = new Scanner(System.in);
    private Grid grid;
    private int connectN;
    private Player[] players;
    private MapString, Integer> score;
    private int targetScore;

    public Game(Grid grid, int connectN, int targetScore) {
        this.grid = grid;
        this.connectN = connectN;
        this.targetScore = targetScore;

        this.players = new Player[] {
            new Player("Player 1", GridPosition.YELLOW),
            new Player("Player 2", GridPosition.RED)
        };

        this.score = new HashMap();
        for (Player player : this.players) {
            this.score.put(player.getName(), 0);
        }
    }

    private void printBoard() {
        System.out.println("Board:");
        int[][] grid = this.grid.getGrid();
        for (int i = 0; i  grid.length; i++) {
            String row = "";
            for (int piece : grid[i]) {
                if (piece == GridPosition.EMPTY.ordinal()) {
                    row += "0 ";
                } else if (piece == GridPosition.YELLOW.ordinal()) {
                    row += "Y ";
                } else if (piece == GridPosition.RED.ordinal()) {
                    row += "R ";
                }
            }
            System.out.println(row);
        }
        System.out.println();
    }

    private int[] playMove(Player player) {
        printBoard();
        System.out.println(player.getName() + "'s turn");
        int colCnt = this.grid.getColumnCount();

        System.out.print("Enter column between 0 and " + (colCnt - 1) + " to add piece: ");
        int moveColumn = input.nextInt();
        int moveRow = this.grid.placePiece(moveColumn, player.getPieceColor());
        return new int[] { moveRow, moveColumn };
    }

    private Player playRound() {
        while (true) {
            for (Player player : this.players) {
                int[] pos = playMove(player);
                int row = pos[0];
                int col = pos[1];
                GridPosition pieceColor = player.getPieceColor();
                if (this.grid.checkWin(this.connectN, row, col, pieceColor)) {
                    this.score.put(player.getName(), this.score.get(player.getName()) + 1);
                    return player;
                }
            }
        }
    }

    public void play() {
        int maxScore = 0;
        Player winner = null;
        while (maxScore  this.targetScore) {
            winner = playRound();
            System.out.println(winner.getName() + " won the round");
            maxScore = Math.max(this.score.get(winner.getName()), maxScore);

            this.grid.initGrid(); // reset grid
        } 
        System.out.println(winner.getName() + " won the game");
    }
}

class Main {
    public static void main(String[] args) {
        Grid grid = new Grid(6, 7);
        Game game = new Game(grid, 4, 10);
        game.play();
    }
}