자바 간단 한 우물 바둑 게임 코드 인 스 턴 스 실현

자바 의 첫 번 째 실험 에서 선생님 은 정자 기 를 만 들 라 고 하 셨 고 컴퓨터 는 무 작위 로 바둑 을 두 었 습 니 다.
그리고 똑똑 할 수 있 을 까 하 는 생각 에 어느 수 를 두 었 는 지 판단 할 수 있다.그 다음 에 지지 않 을 수 밖 에 없고 똑똑 하지 못 해서 사용 자 를 딱딱 하 게 막 을 수 밖 에 없다.smartRobot 의 세 번 째 판단 논 리 는 가장 좋 은 위 치 를 찾 지 못 하고 얻 을 확률 이 비교적 적다.그리고 나 는 할 일이 없 을 때 이 작은 게임 을 해서 성취 감 을 찾 고 싶 었 지만 매번 로봇 을 이 겼 기 때문에 네 다섯 번 삭제 하고 고 쳐 서 마지막 에 되 었 다.
누가 먼저 시작 할 지 선택 할 수 있 지만 startGame 의 코드 는 더욱 지루 해 졌 다.보기 만 해도 어수선 한데 좋 은 방법 이 생각 나 지 않 는 다.
smartRobot 의 코드 는 모두 재 작성 되 었 습 니 다.원래 보다 더 똑똑 합 니 다.다음 네 개의 뿔 에 있 을 때 가장 좋 은 위 치 를 우선 선택 할 수 있 습 니 다.그리고 가장 좋 은 위치 가 없 을 때 빈 것 을 찾 습 니 다.
그리고 스마트 로봇 의 첫 번 째 와 세 번 째 판단 논리 도 좀 더 똑똑 해 졌 다.원래 로봇 을 판단 하고 사용 자 를 판단 하 는 논 리 는 하나의 for 순환 에 놓 여 있 었 지만 가장 좋 은 위 치 를 찾 지 못 해 이 제 는 갈 라 졌 다.
로봇 이 먼저 시작 해 야 새로 추 가 된 로봇 의'잔 머리'를 발휘 할 수 있다.그러나 로봇 의 원래 능력 은 발휘 되 지 않 고 사용자 가 먼저 시작 할 때 만 원래 의 능력 을 발휘 할 수 있다.그래서 각자 장단 점 이 있 고 누가 먼저 시작 하 든 적응 할 수 있 습 니 다.만약 로봇 이 먼저 시작 하고 사용자 의 첫 번 째 바둑 이 사각 위치 에 두 지 않 는 다 면 사용 자 는 반드시 질 것 이다.다른 상황 은 일반적으로 모두 무승부 이다.
누가 먼저 시작 할 지 선택 할 수 있 기 때문에 startGame 코드 가 불필요 한 문 제 를 해결 하 는 방법 은 바로 부분 내부 류 를 사용 하 는 것 이다.내부 클래스 가 접근 할 수 있 는 방법의 국부 대상.
주 논리 startGame:
1.3X3 의 2 차원 배열 로 바둑판 을 저장 합 니 다.
2.사용자 가 1~9 장 기 를 입력 합 니 다.
3.합 법 여 부 를 판단 하고 법칙 에 맞지 않 게 다시 입력 한다.
4.1~9 를 2 차원 좌표 x=(pos-1)/3,y=(pos-1)%3 으로 바 꾸 고 2 차원 배열 의 해당 위 치 를'O'로 한다.
5.사용자 의 승리 여 부 를 판단 하면 종료 합 니 다.무승부 여 부 를 판단 하면 물러난다.
6.로봇 이 바둑 을 둔다(입력 등급 에 따라 서로 다른 함 수 를 사용한다).
7.바둑판 을 인쇄 하여 사용자 와 로봇 의 바둑돌 을 나타 낸다.
8.로봇 의 승리 여 부 를 판단 하면 탈퇴 한다.무승부 여 부 를 판단 하면 물러난다.첫 걸음 으로 돌아 가 는 것 도 아니 고
성공 을 판단 하 는 논리:
모든 줄,열,대각선 이 한 줄 로 연결 되 어 있 는 지 판단 하고 문자 와 함께 판단 하면 됩 니 다.
willBeSuccessful 은 성공 여 부 를 판단 합 니 다.
여기 서 판단 하 는 것 은 줄 이 있 는 지,열 에 두 개의 같은 바둑 알 과 하나의 공백 이 있 는 지,문자 로 덧 붙 인 것 과 판단 하 는 것 이다.
calculate 계산 행렬 대각선:
매 거 류 를 사용 하여 계산 줄 인지 계산 열 인지 좌우 대각선 을 계산 하 는 지 판단 합 니 다.행렬 을 계산 할 때 1~3 의 숫자 가 들 어 오 면 어느 줄 의 열 인지 나타 낸다.
smartRobot 의 첫 번 째 판단 논리:
만약 바둑 알 이 화살표 가 가리 키 는 그 위치 에 있다 면,한 수 를 두 면 승리 할 수 있 을 것 이다.
로봇 은 먼저 자신 이 이런 위치 가 있 는 지,있 으 면 어디 에 있 는 지,승리 하 는 지 를 판단 한다.
방법 은 모든 공백 을 채 우 고 한 번 씩 채 워 서 isSuccessful 을 판단 하 는 것 입 니 다.
없 으 면,상대방 에 게 이런 자리 가 있 는 지 없 는 지 를 판단 하고,있 으 면 이곳 을 막는다.

smartRobot 의 세 번 째 판단 논리:
만약 바둑 알 이 화살표 가 가리 키 는 위치 에 있다 면 다음 단 계 는 반드시 승리 할 것 이다.왜냐하면 그곳 에 내 려 가면 세 번 째 열,세 번 째 줄 은 모두 두 개의 바둑 알 이기 때문에 상대방 이 어디 를 막 든 실패 할 것 이다.
또한 로봇 이 먼저 자신 에 게 이런 위치 가 있 는 지 판단 하고 있 으 면 다음 과 같다.
willBeSuccessful 을 호출 하여 이러한 위치 가 있 는 지 판단 합 니 다.
없 으 면 상대방 에 게 이런 위치 가 있 는 지,있 으 면 막 힌 다.

smartRobot 의 0 번 째 와 두 번 째 판단 논리:
네 개의 뿔 과 중심 위 치 를 처리 하고 만약 에 사용자 가 중심 에 있다 면 로봇 은 적어도 두 개의 바둑 알 아래 사각 위치 에 있어 야 지지 않 는 다 고 보장 할 수 있다.
수 차례 코드 변경:

import java.util.Arrays;
import java.util.Scanner;
 
public class Experiment_1 {
  public static void main(String[] args) {
    ThreeChess game = new ThreeChess();
    game.startGame();
 
  }
}
 
class ThreeChess{
  private char[][] chessBoard = new char[3][3];
  private int size = 0; //      
  private final int CAPACITY = 9; //       
 
  ThreeChess(){
    for(char[] line : chessBoard){ //     
      Arrays.fill(line, ' ');
    }
  }
 
  //【    】
  public void startGame(){
    System.out.println("┌───┬───┬───┐");
    System.out.println("│ 1 │ 2 │ 3 │");
    System.out.println("├───┼───┼───┤");
    System.out.println("│ 4 │ 5 │ 6 │");
    System.out.println("├───┼───┼───┤");
    System.out.println("│ 7 │ 8 │ 9 │");
    System.out.println("└───┴───┴───┘");
    System.out.println("   1 ~ 9         ");
    System.out.println("O     ，*      ");
    Scanner in = new Scanner(System.in);
 
    System.out.print("      ：
\t1.  
\t2.   
Input: ");
    int whoFirst = in.nextInt();
    System.out.print("       ：
\t1. 999+
\t2. 250
Input: ");
    int level = in.nextInt();
 
    class Play{ //    
      //    -1    
      int robotPlay(){
        if(level == 1)
          smartRobot();
        else
          sillyRobot();
 
        printChessBroad();
        if(isSuccessful() == -1) {
          System.out.println("     (/ □ \\)");
          return -1;
        }else if (size == CAPACITY){
          System.out.println("==    ==");
          return -1;
        }
        return 0;
      }
      int userPlay(){
        int pos;
        while(true){
          System.out.print("    : ");
          pos = in.nextInt();
          if(pos < 1
              || pos > 9
              || chessBoard[(pos - 1) / 3][(pos - 1) % 3] != ' '){
            System.out.println("    ，    ！");
            continue;
          } else {
            chessBoard[(pos - 1)/3][(pos - 1) % 3] = 'O';
            size++;
            break;
          }
        }
 
        if(isSuccessful() == 1){
          printChessBroad();
          System.out.println("  ，    t(*°°*)s");
          return -1;
        } else if(size == CAPACITY){
          printChessBroad();
          System.out.println("==    ==");
          return -1;
        }
        return 0;
      }
    }
 
    Play play = new Play();
    if(whoFirst == 2){
      while(true){
        //1.     
        if(play.robotPlay() == -1)
          return;
 
        //2.    
        if(play.userPlay() == -1)
          return;
      }
    } else {
      while(true){
        //1.    
        if(play.userPlay() == -1)
          return;
 
        //2.     
        if(play.robotPlay() == -1)
          return;
      }
    }
  }
 
  //【     】
  private void sillyRobot(){ //    
    int l, c;
    while(true){
      l = (int)(Math.random() * 3);
      c = (int)(Math.random() * 3);
      if(chessBoard[l][c] == ' '){
        chessBoard[l][c] = '*';
        break;
      }
    }
    size++;
  }
 
  private int corner = 2;
  private void smartRobot(){ //        
    if(chessBoard[1][1] == ' '){ //      
      chessBoard[1][1] = '*';
      size++;
      return;
    }
 
    //1.              （          ，           ）
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        if(chessBoard[i][j] == ' '){ //【1】          ，         ，       ；
          chessBoard[i][j] = '*';
          if(isSuccessful() == -1){ //【1】     ，        ，    ；
            size++;
            return ;
          }
          else
            chessBoard[i][j] = ' ';
        }
      }
    }
 
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        //【2】   【1】
        if(chessBoard[i][j] == ' '){
          chessBoard[i][j] = 'O'; //【2】            
          if(isSuccessful() == 1){ //【2】             ，    。
            chessBoard[i][j] = '*';
            size++;
            return ;
          } else
            chessBoard[i][j] = ' ';
        }
      }
    }
 
    //2.           ，           ，      。         。           。
    if(corner > 0){
      corner--;
      for(int i = 0; i < 3; i++){ //                
        if(i == 1)
          continue;
        boolean NoBigO = true;
        for(int j = 0; j < 3; j++){
          if(chessBoard[i][j] == 'O')
            NoBigO = false;
        }
        for(int j = 0; j < 3 && NoBigO; j++){
          if(chessBoard[i][j] == ' '){
            chessBoard[i][j] = '*';
            size++;
            return;
          }
        }
      }
 
      for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
          if(j == 1 || i == 1)
            continue;
          if(chessBoard[i][j] == ' '){
            chessBoard[i][j] = '*';
            size++;
            return;
          }
        }
      }
    } //end if
 
    //3.           ，          （        ）
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        if(chessBoard[i][j] == ' '){
          chessBoard[i][j] = '*';
          if(willBeSuccessful(-1)){
            size++;
            return;
          } else
            chessBoard[i][j] = ' ';
        }
      }
    }
 
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        if(chessBoard[i][j] == ' '){
          chessBoard[i][j] = 'O';
          if (willBeSuccessful(1)) {
            chessBoard[i][j] = '*';
            size++;
            return;
          } else
            chessBoard[i][j] = ' ';
        }
      }
    }
 
    sillyRobot();
  }
 
  //【    】
  private void printChessBroad(){
    System.out.println("







































"); //    
    System.out.println("┌───┬───┬───┐");
    System.out.println("│ " + chessBoard[0][0] + " │ " + chessBoard[0][1] + " │ " + chessBoard[0][2] + " │");
    System.out.println("├───┼───┼───┤");
    System.out.println("│ " + chessBoard[1][0] + " │ " + chessBoard[1][1] + " │ " + chessBoard[1][2] + " │");
    System.out.println("├───┼───┼───┤");
    System.out.println("│ " + chessBoard[2][0] + " │ " + chessBoard[2][1] + " │ " + chessBoard[2][2] + " │");
    System.out.println("└───┴───┴───┘");
  }
 
  //【      】
  private enum Choice{
    LINE,      // 
    COLUMN,     // 
    RIGHT_DIAGONAL, //    
    LEFT_DIAGONAL; //    
  }
  private int calculate(Choice choice, int i){ //   、 、          
    switch (choice){
      case LINE:
        return chessBoard[i][0] + chessBoard[i][1] + chessBoard[i][2];
      case COLUMN:
        return chessBoard[0][i] + chessBoard[1][i] + chessBoard[2][i];
      case RIGHT_DIAGONAL:
        return chessBoard[0][0] + chessBoard[1][1] + chessBoard[2][2];
      case LEFT_DIAGONAL:
        return chessBoard[0][2] + chessBoard[1][1] + chessBoard[2][0];
    }
    return 0;
  }
  private int isSuccessful(){
    /*
      -1   ；  1   ；  0      。
       ：126 == '*' + '*' + '*'
       ：237 == 'O' + 'O' + 'O'
    */
    for(int i = 0; i < 3; i++){
      if(calculate(Choice.LINE, i) == 237 || calculate(Choice.COLUMN, i) == 237)
        return 1;
      if(calculate(Choice.LINE, i) == 126 || calculate(Choice.COLUMN, i) == 126)
        return -1;
    }
    if(calculate(Choice.LEFT_DIAGONAL, 0) == 237 || calculate(Choice.RIGHT_DIAGONAL, 0) == 237)
      return 1;
    if(calculate(Choice.LEFT_DIAGONAL, 0) == 126 || calculate(Choice.RIGHT_DIAGONAL, 0) == 126)
      return -1;
    return 0; //    
  }
 
  private boolean willBeSuccessful(int who){ //who：-1        ，+1       。
    //   、 、    2        ，    ，
    //190 == 2 * 'O' + ' '
    //116 == 2 * '*' + ' '
 
    int n = 0;
    int s = (who == 1) ? 190 : 116; //  or        
 
    for(int i = 0; i < 3; i++){
      if(calculate(Choice.LINE, i) == s)
        n++;
      if(calculate(Choice.COLUMN, i) == s)
        n++;
    }
    //          ，           
    return n > 1;
  }
}

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.