当前位置: 首页 > 编程笔记 >

Javafx实现国际象棋游戏

欧阳鸿哲
2023-03-14
本文向大家介绍Javafx实现国际象棋游戏,包括了Javafx实现国际象棋游戏的使用技巧和注意事项,需要的朋友参考一下

本文实例为大家分享了Javafx实现国际象棋游戏的具体代码,供大家参考,具体内容如下

基本规则

  • 棋子马设计“日”的移动方式
  • 设计只能向前直走,每次只能走一格。但走第一步时,可以走一格或两格的移动方式
  • 请为后设计横、直、斜都可以走,步数不受限制,但不能越子的移动方式。
  • 车只能横向或者竖向行走
  • 国王是在以自己为中心的九宫格内行走
  • 骑士只能走对角线

项目目录结构

UML类图关系

以骑士为例

实现基本功能

  • 吃子
  • 不能越子
  • 游戏结束提示
  • 基本移动策略
  • 背景音乐

效果

控制器

PressedAction

package com.Exercise3;

import com.Exercise3.Controller.PressedAction;
import com.Exercise3.Controller.ReleaseAction;
import com.Exercise3.Controller.ResetAction;
import com.Exercise3.view.ChessBoard;
import com.Exercise3.view.ChessPane;
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;

import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.stage.Stage;

public class Test extends Application {

 public static void main(String[] args) {
 launch(args);
 }

 @Override
 public void start(Stage primaryStage) {

 String MEDIA_URL = "file:/E:/IdeaProjects/Experiment/src/com/Exercise3/music/BackgroundMusic.mp3";
 ChessBoard chessBoard = ChessBoard.getInstance(100,40,40);

 //添加媒体资源

 Media media = new Media(MEDIA_URL);
 MediaPlayer mediaPlayer = new MediaPlayer(media);
 mediaPlayer.setAutoPlay(true);
 mediaPlayer.setCycleCount(MediaPlayer.INDEFINITE);
 mediaPlayer.play();


 ChessPane pane = new ChessPane(chessBoard);
 pane.setOnMousePressed(new PressedAction(pane,mediaPlayer));

 pane.setOnMouseReleased(new ReleaseAction(pane));

 BorderPane borderPane = new BorderPane();
 borderPane.setCenter(pane);
 HBox hBox = new HBox();
 hBox.setAlignment(Pos.TOP_CENTER);

 Button button = new Button("悔棋");
 button.setOnAction(new ResetAction(pane));

 hBox.getChildren().add(button);
 borderPane.setBottom(hBox);
 Scene scene = new Scene(borderPane,900,900);
 primaryStage.setScene(scene);
 primaryStage.setTitle("国际象棋");
 primaryStage.show();

 }
}

ReleasedAction

package com.Exercise3.Controller;

import com.Exercise3.entity.Piece.ChessPiece;
import com.Exercise3.entity.PieceType;
import com.Exercise3.view.ChessBoard;
import com.Exercise3.view.ChessPane;
import javafx.event.EventHandler;
import javafx.scene.control.Alert;
import javafx.scene.input.MouseEvent;

import java.util.Stack;

public class ReleaseAction implements EventHandler<MouseEvent> {
 private ChessPane chessPane;
 static Stack<ChessPiece> stack = new Stack<>();

 public ReleaseAction(ChessPane chessPane) {
 this.chessPane = chessPane;
 }

 @Override
 public void handle(MouseEvent e) {
 chessPane.drawBoard();
 ChessBoard chessBoard = chessPane.getChessBoard();
 int x = (int) ((e.getX() - chessBoard.getStartX()) / (chessBoard.getCellLength()));
 int y = (int) ((e.getY() - chessBoard.getStartY()) / (chessBoard.getCellLength()));

 for (ChessPiece o : chessPane.getChessPieces()) {
 if (o.isSelected()) {

 System.out.println(o.isSelected()+" "+o.getRow()+" "+o.getCol());
 if (chessBoard.getCurrSide()==o.getSide()){
  if(o.getMoveStrategy().move(x, y,chessPane.getChessPieces())){
  o.setSelected(false);
  if(judgeGame(x,y)){
  printTip(o.getSide());
  }
  eatPiece(x,y);
  stack.push((ChessPiece) o.clone());
  o.setCol(x);
  o.setRow(y);

  chessBoard.changeSide();
  }

 }

 break;
 }

 }

 chessPane.drawPiece();
 }

 public void eatPiece(int x,int y){
 chessPane.getChessPieces().removeIf(e->{
 if(e.getCol()==x&&e.getRow()==y){
 stack.push(e);
 return true;
 }
 return false;
 });
 }

 public boolean judgeGame(int x,int y){
 for(ChessPiece e:chessPane.getChessPieces()){
 if(e.getCol()==x&&e.getRow()==y&&(
  e.getType()== PieceType.KINGBLACK||e.getType()==PieceType.KINGWHITE))
 return true;
 }

 return false;
 }

 public void printTip(char side){
 Alert alert = new Alert(Alert.AlertType.INFORMATION);
 alert.setContentText((side=='B'?"黑":"白")+"方取得胜利");
 alert.setTitle("游戏结束");
 alert.showAndWait();
 }


}

ResetAction

package com.Exercise3.Controller;

import com.Exercise3.entity.Piece.ChessPiece;
import com.Exercise3.view.ChessPane;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;


import java.util.Stack;

public class ResetAction implements EventHandler<ActionEvent>{
 private ChessPane chessPane;
 public ResetAction(ChessPane chessPane) {
 this.chessPane = chessPane;
 }

 @Override
 public void handle(ActionEvent e) {
 Stack<ChessPiece> stack = ReleaseAction.stack;
 if(!stack.empty()){
 chessPane.getChessPieces().removeIf(o->o.equals(stack.peek()));//去除原来的棋子
 chessPane.getChessPieces().add(stack.pop());//将以前压入堆栈的棋子重新加入

 chessPane.drawBoard();
 chessPane.drawPiece();
 }
 }
}

实体

棋子

ChessPiece

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.CarStrategy;

public class Car extends ChessPiece {
 public Car(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new CarStrategy(getCol(),getRow()));
 }
}

Car

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.CarStrategy;

public class Car extends ChessPiece {
 public Car(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new CarStrategy(getCol(),getRow()));
 }
}

Horse

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.HorseStategy;

public class Horse extends ChessPiece{
 public Horse(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new HorseStategy(getCol(),getRow()));
 }
}

King

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.KingStrategy;

public class King extends ChessPiece {
 public King(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new KingStrategy(getCol(),getRow()));
 }
}

Knight

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.KnightStrategy;

public class Knight extends ChessPiece {
 public Knight(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new KnightStrategy(getCol(),getRow()));
 }
}

Queen

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.QueenStrategy;

public class Queen extends ChessPiece {
 public Queen(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new QueenStrategy(getCol(),getRow()));
 }
}

Soldier

package com.Exercise3.entity.Piece;

import com.Exercise3.entity.PieceType;
import com.Exercise3.entity.Strategy.SoldierStategy;

public class Soldier extends ChessPiece{
 public Soldier(PieceType type, int row, int col) {
 super(type, row, col);
 setMoveStrategy(new SoldierStategy(getCol(),getRow(),getSide()));
 }

}

移动策略

MoveStategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.Set;

public interface MoveStrategy {
 boolean move(int x, int y, Set<ChessPiece> chessPieces);
}

CarStrategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Set;

public class CarStrategy implements MoveStrategy {
 private int curX;
 private int curY;

 public CarStrategy() {
 }

 public CarStrategy(int curX, int curY) {
 this.curX = curX;
 this.curY = curY;
 }

 public boolean move(int x, int y, Set<ChessPiece> chessPieces) {
 if(x!=curX&&y!=curY)
 return false;
 if(isOverPiece(Math.min(curX,x),Math.min(curY,y),
 Math.max(curX,x),Math.max(curY,y),chessPieces))
 return false;
 curX = x;
 curY = y;
 return true;
 }

 public static boolean isOverPiece(int stX,int stY,int edX,int edY,Set<ChessPiece> chessPieces){
 for(ChessPiece e:chessPieces)
 if((e.getRow()>stY&&e.getRow()<edY)&&e.getCol()==stX||
  (e.getCol()>stX&&e.getCol()<edX&&e.getRow()==stY))
 return true;
 return false;
 }


 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

HorseStrategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Set;

public class HorseStategy implements MoveStrategy{
 private int curX;
 private int curY;

 public HorseStategy(int curX, int curY) {
 this.curX = curX;
 this.curY = curY;
 }


 @Override
 public boolean move(int x, int y, Set<ChessPiece> chessPieces) {
 if((Math.abs(curX-x)==1&&Math.abs(curY-y)==2)||
 (Math.abs(curX-x)==2&&Math.abs(curY-y)==1)){
 curX = x;
 curY = y;
 return true;
 }
 return false;
 }

 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

KingStrategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Set;

public class KingStrategy implements MoveStrategy {
 private int curX;
 private int curY;

 public KingStrategy(int curX, int cuY) {
 this.curX = curX;
 this.curY = cuY;
 }

 @Override
 public boolean move(int x, int y, Set<ChessPiece> chessPieces) {
 if(Math.abs(curX-x)<=1&&Math.abs(curY-y)<=1){
 curX = x;
 curY = y;
 return true;
 }

 return false;
 }

 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

KnightStrage

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class KnightStrategy implements MoveStrategy {
 private int curX;
 private int curY;

 public KnightStrategy(int curX, int curY) {
 this.curX = curX;
 this.curY = curY;
 }

 @Override
 public boolean move(int x, int y, Set<ChessPiece> chessPieces) {
 if(Math.abs(x-curX)==Math.abs(y-curY)){
 if(isOverPiece(Math.min(curX,x),Math.min(curY,y),
  Math.max(curX,x),Math.max(curY,y),chessPieces))
 return false;
 curX=x;
 curY=y;
 return true;
 }
 return false;
 }

 public static boolean isOverPiece(int stX,int stY,int edX,int edY,Set<ChessPiece> chessPieces){
 for(ChessPiece e:chessPieces){
 if(e.getCol()-stX==edX-e.getCol()&&edY-e.getRow()==e.getRow()-stY){
 System.out.println(e.isSelected()+" "+e.getRow()+" "+e.getCol());
 return true;
 }
 }

 return false;
 }
 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

QueeStrategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Set;


public class QueenStrategy implements MoveStrategy{
 private int curX;
 private int curY;

 public QueenStrategy(int curX, int curY) {
 this.curX = curX;
 this.curY = curY;
 }

 @Override
 public boolean move (int x, int y, Set<ChessPiece> chessPieces) {
 if(Math.abs(x-curX)==Math.abs(y-curY)||!(x!=curX&&y!=curY)){
 if(isOverPiece(Math.min(curX,x),Math.min(curY,y),
  Math.max(curX,x),Math.max(curY,y),chessPieces))
 return false;
 curX = x;
 curY = y;
 return true;
 }
 return false;
 }

 public boolean isOverPiece (int stX,int stY,int edX,int edY,Set<ChessPiece> chessPieces) {
 for(ChessPiece e:chessPieces){
 if(e.getRow()!=stY&&e.getCol()!=stX){
 return KnightStrategy.isOverPiece(stX,stY,edX,edY,chessPieces);
 }
 else{
 return CarStrategy.isOverPiece(stX,stY,edX,edY,chessPieces);
 }
 }
 return false;
 }


 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

SoldierStrategy

package com.Exercise3.entity.Strategy;

import com.Exercise3.entity.Piece.ChessPiece;

import java.util.List;
import java.util.Set;

public class SoldierStategy implements MoveStrategy{
 private int curX;
 private int curY;
 private char side;
 private boolean firstMove = true;

 public SoldierStategy(int curX, int curY,char side) {
 this.curX = curX;
 this.curY = curY;
 this.side = side;
 }


 @Override
 public boolean move(int x, int y, Set<ChessPiece> chessPieces) {
 //直线移动
 if(curY==y){
 switch (side){
 case 'B': {
  if(isFirstMove()&&(x==curX+1||curX+2==x)){
  setFirstMove(false);
  curY = y;
  curX = x;
  return true;
  }
  else if(!isFirstMove()&&curX+1==x){
  curY = y;
  curX = x;
  return true;
  }
  break;
 }

 case 'W':{
  if(isFirstMove()&&(x==curX-1||x==curX-2)){
  setFirstMove(false);
  curY = y;
  curX = x;
  return true;
  }
  else if(!isFirstMove()&&curX-1==x){
  curY = y;
  curX = x;
  return true;
  }
  break;
 }
 }
 }

 //吃子移动
 for(ChessPiece e:chessPieces){
 if(Math.abs(e.getRow()-curY)==1){
 if(e.getCol()-curX==1&&e.getSide()=='W'||
 curX-e.getCol()==1&&e.getSide()=='B'){
  curY = y;
  curX = x;
  return true;
 }

 }
 }

 return false;
 }



 public boolean isFirstMove() {
 return firstMove;
 }

 public void setFirstMove(boolean firstMove) {
 this.firstMove = firstMove;
 }

 public int getCurX() {
 return curX;
 }

 public void setCurX(int curX) {
 this.curX = curX;
 }

 public int getCurY() {
 return curY;
 }

 public void setCurY(int curY) {
 this.curY = curY;
 }
}

棋子类型

package com.Exercise3.entity;

public enum PieceType {
 KINGBLACK("KingBlack","com/Exercise3/img/KingBlack.jpg"),
 QUEENBLACK("QueenBlack","com/Exercise3/img/QueenBlack.jpg"),
 CARBLACK("CarBlack","com/Exercise3/img/CarBlack.jpg"),
 HORSEBLACK("HorseBlack","com/Exercise3/img/HorseBlack.jpg"),
 SOLDIERBLACK("SoldierBlack","com/Exercise3/img/SoldierBlack.jpg"),
 KNIGHTBLACK("KnightBlack","com/Exercise3/img/KnightBlack.jpg"),

 KINGWHITE("KingWhite","com/Exercise3/img/KingWhite.jpg"),
 QUEENWHITE("QueenWhite","com/Exercise3/img/QueenWhite.jpg"),
 CARWHITE("CarWhite","com/Exercise3/img/CarWhite.jpg"),
 HORSEWHITE("HorseWhite","com/Exercise3/img/HorseWhite.jpg"),
 SOLDIERWHITE("SoldierWhite","com/Exercise3/img/SoldierWhite.jpg"),
 KNIGHTWHITE("KnightWhite","com/Exercise3/img/KnightWhite.jpg");


 private String desc;
 private PieceType(String desc,String url ){
 this.desc = desc;
 this.url = url;
 }

 private String url;

 public String getDesc(){
 return desc;
 }

 public String getUrl() {
 return url;
 }
}

视图

package com.Exercise3.view;

public class ChessBoard {
 static ChessBoard chessBoard = null;
 private int row;
 private int col;
 private double cellLength;
 private double startX;
 private double startY;
 private char currSide;

 private ChessBoard(double cellLength, double startX, double startY) {
 this.row = 8;
 this.col = 8;
 this.cellLength = cellLength;
 this.startX = startX;
 this.startY = startY;
 this.currSide = 'B';
 }

 public static ChessBoard getInstance(double cellLength, double startX, double startY){
 if(chessBoard == null)
 return new ChessBoard(cellLength,startX,startY);
 return chessBoard;
 }

 public ChessBoard getInstance(){
 return chessBoard;
 }

 public int getCol() {
 return col;
 }


 public int getRow() {
 return row;
 }

 public double getCellLength() {
 return cellLength;
 }

 public void changeSide(){
 currSide=(currSide=='B'?'W':'B');
 }

 public void setCellLength(double cellLength) {
 this.cellLength = cellLength;
 }

 public double getStartX() {
 return startX;
 }

 public void setStartX(double startX) {
 this.startX = startX;
 }

 public double getStartY() {
 return startY;
 }

 public void setStartY(double startY) {
 this.startY = startY;
 }

 public char getCurrSide() {
 return currSide;
 }
}
package com.Exercise3.view;

import com.Exercise3.entity.Piece.*;
import com.Exercise3.entity.PieceType;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.image.*;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;

import java.util.*;

public class ChessPane extends Pane {
 private Set<ChessPiece> chessPieces;
 private ChessBoard chessBoard;
 private Canvas canvas;
 private GraphicsContext gc;

 public ChessPane(ChessBoard chessBoard) {
 this.chessBoard = chessBoard;
 setChessPiece();
 canvas = new Canvas(900,900);
 gc = canvas.getGraphicsContext2D();
 draw();
 }


 public void draw(){
 drawBoard();
 drawPiece();
 getChildren().add(canvas);
 }


 public void drawBoard(){
 gc.clearRect(0,0,900,900);
 double x = chessBoard.getStartX();
 double y = chessBoard.getStartY();
 double cell = chessBoard.getCellLength();


 boolean flag = false;
 for(int i=0;i<chessBoard.getRow();i++){
 flag = !flag;
 for(int j=0;j<chessBoard.getCol();j++){
 gc.setFill(flag? Color.valueOf("#EDEDED"):Color.valueOf("CDC5BF"));
 gc.fillRect(x+j*cell,y+i*cell,cell,cell);
 flag = !flag;
 }
 }


 gc.setStroke(Color.GRAY);
 gc.strokeRect(x,y,cell*chessBoard.getCol(),cell*chessBoard.getRow());

 }

 public void drawPiece(){
 double cell = chessBoard.getCellLength();
 chessPieces.forEach( e->{
 if(e.isSelected()){
 gc.setFill(Color.valueOf("#6495ED"));
 gc.fillRect(chessBoard.getStartX()+e.getCol()*cell,
  chessBoard.getStartY()+e.getRow()*cell,
  cell,cell);
 }

 Image image = new Image(e.getType().getUrl());
 gc.drawImage(image,
  chessBoard.getStartX()+10 + e.getCol() * cell,
  chessBoard.getStartY()+10 + e.getRow() * cell,
  cell-20, cell-20);
 });
 }


 //加入棋子
 public void setChessPiece() {
 chessPieces = new HashSet<>();
 chessPieces.add(new Car(PieceType.CARBLACK,0,0));
 chessPieces.add(new Horse(PieceType.HORSEBLACK,1,0));
 chessPieces.add(new Knight(PieceType.KNIGHTBLACK,2,0));
 chessPieces.add(new King(PieceType.KINGBLACK,3,0));
 chessPieces.add(new Queen(PieceType.QUEENBLACK,4,0));
 chessPieces.add(new Knight(PieceType.KNIGHTBLACK,5,0));
 chessPieces.add(new Horse(PieceType.HORSEBLACK,6,0));
 chessPieces.add(new Car(PieceType.CARBLACK,7,0));
 for(int i=0;i<8;i++){
 chessPieces.add(new Soldier(PieceType.SOLDIERBLACK,i,1));
 }


 chessPieces.add(new Car(PieceType.CARWHITE,0,7));
 chessPieces.add(new Horse(PieceType.HORSEWHITE,1,7));
 chessPieces.add(new Knight(PieceType.KNIGHTWHITE,2,7));
 chessPieces.add(new King(PieceType.KINGWHITE,3,7));
 chessPieces.add(new Queen(PieceType.QUEENWHITE,4,7));
 chessPieces.add(new Knight(PieceType.KNIGHTWHITE,5,7));
 chessPieces.add(new Horse(PieceType.HORSEWHITE,6,7));
 chessPieces.add(new Car(PieceType.CARWHITE,7,7));
 for(int i=0;i<8;i++){
 chessPieces.add(new Soldier(PieceType.SOLDIERWHITE,i,6));
 }
 }

 public ChessBoard getChessBoard() {
 return chessBoard;
 }

 public void setChessBoard(ChessBoard chessBoard) {
 this.chessBoard = chessBoard;
 }

 public Set<ChessPiece> getChessPieces() {
 return chessPieces;
 }

 public void setChessPieces(Set<ChessPiece> chessPieces) {
 this.chessPieces = chessPieces;
 }

 public Canvas getCanvas() {
 return canvas;
 }

 public void setCanvas(Canvas canvas) {
 this.canvas = canvas;
 }

 public GraphicsContext getGc() {
 return gc;
 }

 public void setGc(GraphicsContext gc) {
 this.gc = gc;
 }
}

测试

package com.Exercise3;

import com.Exercise3.Controller.PressedAction;
import com.Exercise3.Controller.ReleaseAction;
import com.Exercise3.Controller.ResetAction;
import com.Exercise3.view.ChessBoard;
import com.Exercise3.view.ChessPane;
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;

import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.stage.Stage;

public class Test extends Application {

 public static void main(String[] args) {
 launch(args);
 }

 @Override
 public void start(Stage primaryStage) {

 String MEDIA_URL = "file:/E:/IdeaProjects/Experiment/src/com/Exercise3/music/BackgroundMusic.mp3";
 ChessBoard chessBoard = ChessBoard.getInstance(100,40,40);

 //添加媒体资源

 Media media = new Media(MEDIA_URL);
 MediaPlayer mediaPlayer = new MediaPlayer(media);
 mediaPlayer.setAutoPlay(true);
 mediaPlayer.setCycleCount(MediaPlayer.INDEFINITE);
 mediaPlayer.play();


 ChessPane pane = new ChessPane(chessBoard);
 pane.setOnMousePressed(new PressedAction(pane,mediaPlayer));

 pane.setOnMouseReleased(new ReleaseAction(pane));

 BorderPane borderPane = new BorderPane();
 borderPane.setCenter(pane);
 HBox hBox = new HBox();
 hBox.setAlignment(Pos.TOP_CENTER);

 Button button = new Button("悔棋");
 button.setOnAction(new ResetAction(pane));

 hBox.getChildren().add(button);
 borderPane.setBottom(hBox);
 Scene scene = new Scene(borderPane,900,900);
 primaryStage.setScene(scene);
 primaryStage.setTitle("国际象棋");
 primaryStage.show();

 }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持小牛知识库。

 类似资料:
  • DreamChess 是一款开放源码、跨平台(可在 Windows、Mac OS X 及 Linux 上运行)的 3D 国际象棋游戏。该游戏包含自身的引擎 Dreamer,提供各种国际象棋棋盘,并具有背景音乐及声效等其他附属功能。

  • 我已经有一个Board对象,包含一个碎片列表。Piece是一个抽象类,有一个位置(x,y)和一个颜色(黑色或白色)。然后是King、Queen、Knight这三个类,实现了Piece类。 谢谢

  • 本文向大家介绍javafx实现五子棋游戏,包括了javafx实现五子棋游戏的使用技巧和注意事项,需要的朋友参考一下 需求描述 一个五子棋游戏,能实现双方黑白对决,当一方获胜时给出提示信息,利用GUI界面实现 项目结构如下图 一、实体 FiveChess类 提供五子棋实体包含的所有信息 判断游戏是否结束 play方法改变chess[][]棋盘中的数据 二、视图 ChessPane类继承Pane类实现

  • 我正在下国际象棋,除了一件事,我几乎得到了所有的东西:我需要使棋手不可能将棋子移动到棋盘上。我很难解决这个问题。 我现在用伪代码生成的有效移动是:类getMoveLocations(我定义了一个位置为国际象棋中的一个方块):如果这个位置在边界内,这个位置的棋子是敌人的棋子,并且模拟的移动不会导致棋盘被检查,然后将该位置添加到工件可以移动到的可能位置。 问题是我如何检查棋盘是否“在检查中”。在我的代

  • 我目前正在创建一个国际象棋游戏,包括以下几个类: ChessPiece-对于所有不同的棋子,由一个Movement行为实例变量组成 移动行为-接口实现的当铺移动行为,KingMovement行为等类,以定义如何每个片类型移动 ChessBoard-由ChessPiece[][] 2D数组组成,具有addPiece()/RemvePiece()/replace ePiece()等功能 玩家-小班帮助

  • 我刚刚学习了Android和Java编程(里面非常noob),我想问一些关于Android编程和Socket服务器的问题。 我得到一个任务,创建一个简单的国际象棋应用程序(不包括AI),棋子的位置将从TCP套接字中检索: 服务器:xinuc.org 端口:7387 我被告知使用Socket Persistent,因为服务器会在每秒更新典当的位置,典当的位置将以这种格式发送 [卒典][横位][竖位]