public void listenInput(GameContainer gc, StateBasedGame sbg, int delta) {
Input input = gc.getInput();
if (input.isKeyPressed(Input.KEY_DOWN)) {
cursor = Math.min(cursor + 1, 2);
} else if (input.isKeyPressed(Input.KEY_UP)) {
cursor = Math.max(cursor - 1, 0);
}
if (cursor == 0 && input.isKeyDown(Input.KEY_RIGHT)) {
control.changeVolume(delta * 0.5f);
} else if (cursor == 0 && input.isKeyDown(Input.KEY_LEFT)) {
control.changeVolume(-delta * 0.5f);
}
if (cursor == 1 && input.isKeyDown(Input.KEY_RIGHT)) {
control.goFullScreen(true);
} else if (cursor == 1 && input.isKeyDown(Input.KEY_LEFT)) {
control.goFullScreen(false);
}
if (cursor == 2 && input.isKeyDown(Input.KEY_RIGHT)) {
control.changeBrightness(+5);
} else if (cursor == 2 && input.isKeyDown(Input.KEY_LEFT)) {
control.changeBrightness(-5);
} else if (input.isKeyDown(Input.KEY_ENTER)) {
((GameController) gc).changeState("pause");
// sbg.enterState(((Game)sbg).prevState);
((GameController) gc).changeState(((Game) sbg).prevState);
}
}
public static void loadPlayer(Registry registry) {
Player p = (Player) getPlayers().get(player);
if (p != null) {
p.setTransient(registry);
}
GameController gc = registry.getGameController();
registry.getPlayerManager().clearPlayers();
registry.getPlayerManager().registerPlayer(p);
BlockManager bm = (BlockManager) blockManagers.get(player);
bm.name = "Saved";
bm = (BlockManager) bm.clone();
bm.name = "Clone";
bm.setTransient(registry);
gc.setBlockManager(bm);
PlaceableManager pm = (PlaceableManager) placeableManagers.get(player).clone();
gc.setPlaceableManager(pm);
MonsterManager mm = (MonsterManager) monsterManagers.get(player).clone();
mm.setTransient(registry);
gc.setMonsterManager(mm);
if (p != null) {
p.resetPlayer();
}
// unloadUnused();
}
public static void main(String[] args) {
GameEngine engine = new GameEngine();
GameController controller = new GameController();
gamePanel panel = new gamePanel(engine, controller);
controller.init(panel, engine);
controller.start();
}
@Override
public void update(Observable o, Object arg) {
if (arg instanceof Player) {
Player player = (Player) arg;
int points = player.getPoints();
System.out.println("Spieler" + player.getNum() + "an der Reihe");
if (player.getNum() == 1) {
System.out.println("Spieler1 punkte++");
points1Num.setText("" + points);
} else if (player.getNum() == 2) {
System.out.println("Spieler2 punkte++");
points2Num.setText("" + points);
}
} else {
GameController controller = (GameController) arg;
if (controller.getPlayer().getNum() == 1) {
ImageIcon image = new ImageIcon("../gfx/spieler1_play.png");
l1.setIcon(image);
ImageIcon imageOld = new ImageIcon("../gfx/spieler2.png");
l2.setIcon(imageOld);
System.out.println("spieler gewechselt");
} else {
ImageIcon imageI = new ImageIcon("../gfx/spieler2_play.png");
l2.setIcon(imageI);
ImageIcon imageOldI = new ImageIcon("../gfx/spieler1.png");
l1.setIcon(imageOldI);
}
}
}
@Test
public void testBoardForNull() {
GameController g = new GameController();
Board board = g.getBoard();
for (Tile tile : board.tiles) {
if (tile.getOwnedBy() != null) {
fail("Tile is not initiated with null value");
}
}
Player pTest = new Player("name", 1, null);
}
private void mainLoop() {
mainController.timeStep();
if (world.isGameLost()) {
eventBus.fireEvent(new GameFinishedEvent());
timer.cancel();
}
}
public ImmutableSet<ViewedDrawable> getViewed() {
ImmutableSet<Drawable> draw = controller.watch(viewingRect);
ImmutableSet.Builder<ViewedDrawable> viewed = ImmutableSet.builder();
for (Drawable d : draw) {
viewed.add(ViewedDrawable.wrap(d, this));
}
LOG.log(Level.INFO, viewed.build().toString());
return viewed.build();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
gameController.setTouched(true);
}
return true;
}
/**
* Displays the given game board.
*
* @param board The board to display.
*/
public void displayBoard(Board board) {
int width = board.getWidth();
int height = board.getHeight();
int tileSize = determineTileSize(width, height);
offsetTop = (boardView.getHeight() - (height * tileSize)) / 2;
offsetLeft = (boardView.getWidth() - (width * tileSize)) / 2;
// Start with an empty display.
boardView.removeAllViews();
Ball ball;
Goal goal;
Man man;
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
switch (board.getBoardPiece(x, y)) {
case Board.GOAL:
goal = new Goal(this, tileSize, x, y);
gameController.addGoal(goal);
break;
case Board.BALL:
ball = new Ball(this, tileSize, x, y);
gameController.addBall(ball);
break;
case Board.BALL_IN_GOAL:
goal = new Goal(this, tileSize, x, y);
gameController.addGoal(goal);
ball = new Ball(this, tileSize, x, y);
gameController.addBall(ball);
break;
case Board.MAN:
man = new Man(this, tileSize, x, y);
gameController.setMan(man);
break;
case Board.MAN_ON_GOAL:
goal = new Goal(this, tileSize, x, y);
gameController.addGoal(goal);
man = new Man(this, tileSize, x, y);
gameController.setMan(man);
break;
case Board.WALL:
new Wall(this, tileSize, x, y);
break;
}
if (board.isFloor(x, y)) {
new Floor(this, tileSize, x, y);
}
}
}
}
@Override
public void initialize(URL url, ResourceBundle rb) {
player = GameController.getGameData().getPlayer();
dailyCost = 0;
selectedSkill = pilot_button;
pilot_button.requestFocus();
checkForHire();
Button[] buttons = {
pilot_button, fighter_button, engineer_button, trader_button, investor_button
};
for (Button b : buttons) {
b.setOnMouseClicked(
(MouseEvent t) -> {
selectedSkill = b;
generateCostAndStat();
});
}
name_field.addEventFilter(
KeyEvent.KEY_TYPED,
(KeyEvent event) -> {
if (name_field.getText().length() >= 18) {
event.consume();
}
});
power_slider
.valueProperty()
.addListener(
(ObservableValue<? extends Number> ov, Number old_val, Number new_val) -> {
generateCostAndStat();
});
hire_button.setOnMouseClicked(
(MouseEvent t) -> {
Mercenary merc =
new Mercenary(name_field.getText(), selectedSkill.getText(), power, dailyCost);
player.getShip().addCrew(merc);
checkForHire();
});
}
/** @author sailfish */
public class View {
private Rect viewingRect;
private Rect outputRect;
private final GameController controller = GameController.getInstance();
private double scale;
private double translateX, translateY;
private final Rect idealViewingRect;
private static final Logger LOG = Logger.getLogger(View.class.getName());
public View(Rect viewingRect, Rect outputRect) {
assert (viewingRect != null && !viewingRect.hasZeroArea());
assert (outputRect != null && !outputRect.hasZeroArea());
this.idealViewingRect = viewingRect;
this.viewingRect = viewingRect.expandToAspectRatio(outputRect);
this.outputRect = outputRect;
setScale();
}
public double view(double length) {
return length * scale;
}
public double project(double length) {
return length / scale;
}
public void updateOutputRect(Rect r) {
if (r.hasZeroArea()) {
this.outputRect = new Rect(new Point2d(), 10, 10);
} else {
this.outputRect = r;
}
viewingRect = idealViewingRect.expandToAspectRatio(outputRect);
viewingRect = viewingRect.centerOn(idealViewingRect);
setScale();
}
public Point2d view(Point2d p) {
return new Point2d(view(p.getX() + translateX), view(p.getY() + translateY));
}
public Point2d project(Point2d p) {
return new Point2d(project(p.getX()) - translateX, project(p.getY()) - translateY);
}
public ImmutableSet<ViewedDrawable> getViewed() {
ImmutableSet<Drawable> draw = controller.watch(viewingRect);
ImmutableSet.Builder<ViewedDrawable> viewed = ImmutableSet.builder();
for (Drawable d : draw) {
viewed.add(ViewedDrawable.wrap(d, this));
}
LOG.log(Level.INFO, viewed.build().toString());
return viewed.build();
}
@Override
public String toString() {
return "View{" + "viewingRect=" + viewingRect + ", outputRect=" + outputRect + '}';
}
private void setScale() {
scale = outputRect.width / viewingRect.width;
translateX = outputRect.topLeft.getX() - viewingRect.topLeft.getX();
translateY = outputRect.topLeft.getY() - viewingRect.topLeft.getY();
}
// public static View viewSelectedItems(ObservableSet<Drawable> d){
//
// return null;
// }
}
@FXML
private void playerSetup(ActionEvent e) throws NullPointerException {
Stage newStage = new Stage();
// try {
if (e.getSource() == nextButton2) {
String name = playerName.getText();
String race = raceChoice.getSelectionModel().getSelectedItem().toString();
if (race.length() > 8) {
race = race.toUpperCase().substring(0, race.indexOf(" "));
} else {
race = race.toUpperCase();
}
Player.Race r = Player.Race.valueOf(race);
Color color = colorPick.getValue();
// creating Player
Player p = new Player(name, r, color.toString());
players[count - 1] = p;
if (players[players.length - 1] != null) {
// when players array is full, begins game turns
Turns gameTurns = new Turns(players);
}
if (name.equals("")) { // check if player entered a name
Launcher.primaryStage.setScene(Launcher.errorMessage);
Launcher.primaryStage.setTitle("Enter name!");
} else if (playerColors.contains(color)) {
Launcher.primaryStage.setScene(Launcher.errorMessage);
Launcher.primaryStage.setTitle("Choose new color!");
} else {
playerColors.add(color);
if (count == 1) { // if only one player config screen has been shown go to player 2
Launcher.primaryStage.setTitle("Player 2 Configuration");
Launcher.primaryStage.toFront();
playerName.clear();
raceChoice.getSelectionModel().clearSelection();
colorPick.setValue(Color.WHITE);
count += 1;
} else if (count == 2) {
if (count == numPlayer) { // if user selected only 2 players then show game screen
Launcher.primaryStage.hide();
try {
gameRoot = FXMLLoader.load(getClass().getResource("UIFiles/MainMap.fxml"));
gameScene = new Scene(gameRoot);
Parent startWindow =
FXMLLoader.load(getClass().getResource("UIFiles/playerStart.fxml"));
startScene = new Scene(startWindow);
} catch (Exception e1) {
e1.printStackTrace();
}
newStage.setScene(gameScene);
newStage.setTitle("Game Screen");
newStage.show();
GameController.beginTurn();
// creates land array
landPlots = new Land[9][5]; // 5 rows, 9 columns, col = i, row = j
int count = 0;
for (int i = 0; i < landPlots.length; i++) {
for (int j = 0; j < landPlots[0].length; j++) {
Land newLand = new Land(i, j);
newLand.setType(landTypes[count]);
landPlots[i][j] = newLand;
count++;
}
}
} else { // if user selected more than 2 players, go on to player 3 config
Launcher.primaryStage.setTitle("Player 3 Configuration");
Launcher.primaryStage.toFront();
playerName.clear();
raceChoice.getSelectionModel().clearSelection();
colorPick.setValue(Color.WHITE);
count += 1;
}
} else if (count == 3) {
if (count == numPlayer) {
Launcher.primaryStage.hide();
try {
gameRoot = FXMLLoader.load(getClass().getResource("UIFiles/MainMap.fxml"));
gameScene = new Scene(gameRoot);
Parent startWindow =
FXMLLoader.load(getClass().getResource("UIFiles/playerStart.fxml"));
startScene = new Scene(startWindow);
} catch (Exception e1) {
e1.printStackTrace();
}
newStage.setScene(gameScene);
newStage.setTitle("Game Screen");
newStage.show();
GameController.beginTurn();
// creates land array
landPlots = new Land[9][5]; // 5 rows, 9 columns, col = i, row = j
int count = 0;
for (int i = 0; i < landPlots.length; i++) {
for (int j = 0; j < landPlots[0].length; j++) {
Land newLand = new Land(i, j);
newLand.setType(landTypes[count]);
landPlots[i][j] = newLand;
count++;
}
}
} else {
Launcher.primaryStage.setTitle("Player 4 Configuration");
Launcher.primaryStage.toFront();
playerName.clear();
raceChoice.getSelectionModel().clearSelection();
colorPick.setValue(Color.WHITE);
count += 1;
}
} else if (count == 4) {
Launcher.primaryStage.hide();
try {
gameRoot = FXMLLoader.load(getClass().getResource("UIFiles/MainMap.fxml"));
gameScene = new Scene(gameRoot);
Parent startWindow =
FXMLLoader.load(getClass().getResource("UIFiles/playerStart.fxml"));
startScene = new Scene(startWindow);
} catch (Exception e1) {
e1.printStackTrace();
}
newStage.setScene(gameScene);
newStage.setTitle("Game Screen");
newStage.show();
GameController.beginTurn();
// creates land array
landPlots = new Land[9][5]; // 5 rows, 9 columns, col = i, row = j
int count = 0;
for (int i = 0; i < landPlots.length; i++) {
for (int j = 0; j < landPlots[0].length; j++) {
Land newLand = new Land(i, j);
newLand.setType(landTypes[count]);
landPlots[i][j] = newLand;
count++;
}
}
}
}
} else if (e.getSource() == backButton) {
playerName.clear();
raceChoice.getSelectionModel().clearSelection();
colorPick.setValue(Color.WHITE);
Launcher.primaryStage.setScene(Launcher.rootScene);
Launcher.primaryStage.setTitle("M.U.L.E. Game Setup");
}
/*} catch (NullPointerException error) {
Launcher.primaryStage.setScene(Launcher.errorMessage);
Launcher.primaryStage.setTitle("Error!");
}*/
}
@Override
public void onEvent(int type, Object data) {
if (type == YES) GameController.getInstance().logOut();
}
public void getGameTurn(String gameId, int turn) {
GameEngine.showLoading();
ServerDriver.getGameTurn(GameController.getInstance().getUser().getId(), gameId, turn);
}
public void getGamesList() {
GameEngine.showLoading();
ServerDriver.getListGames(GameController.getInstance().getUser().getId());
}
public void surrenderGame(String gameId) {
ServerDriver.sendGameTurn(
GameController.getInstance().getUser().getId(), gameId, "ended", "defeat");
}
public void enableRandom() {
ServerDriver.enableRandom(GameController.getInstance().getUser().getId());
}
public void update(Canvas canvas) {
gameController.update();
renderer.draw(canvas);
}
public void makeCellAlive(int i, int j) {
controller.makeCellAlive(i, j);
}
@FXML
public void loadGame(ActionEvent event) {
Stage newStage = new Stage();
if (event.getSource() == loadButton) {
loadData = LoadSaveGame.load();
if (loadData != null) {
Controller.loaded = true;
GameController.numPasses = (int) Controller.loadData.get(4);
// GameController.landButton.setDisable(true);
try {
gameRoot = FXMLLoader.load(getClass().getResource("UIFiles/MainMap.fxml"));
gameScene = new Scene(gameRoot);
Parent startWindow = FXMLLoader.load(getClass().getResource("UIFiles/playerStart.fxml"));
startScene = new Scene(startWindow);
} catch (IOException e) {
e.printStackTrace();
}
newStage.setScene(gameScene);
newStage.setTitle("Game Screen");
newStage.show();
GridPane grid = (GridPane) gameRoot;
landPlots = (Land[][]) loadData.get(0);
level = (String) loadData.get(1);
players = (Player[]) loadData.get(3);
for (Player player : players) {
for (Land land : player.getLandOwned()) {
landPlots[land.getCol()][land.getRow()].setOwner(player);
}
}
if (grid != null) {
for (Land[] landArray : landPlots) {
for (Land land : landArray) {
if (land.isOwned()) {
Player owner = land.getOwner();
Rectangle color = new Rectangle();
color.setFill(Color.valueOf(owner.getColor()));
color.setHeight(25);
color.setWidth(25);
color.setOpacity(1);
GridPane.setHalignment(color, HPos.LEFT);
GridPane.setValignment(color, VPos.TOP);
grid.add(color, land.getCol(), land.getRow());
if (land.hasMule()) {
Image mulePic = new Image("gameConfig/UIFiles/Media/aMule.png");
ImageView muleView = new ImageView();
muleView.setImage(mulePic);
muleView.setFitWidth(50);
muleView.setPreserveRatio(true);
GridPane.setHalignment(muleView, HPos.LEFT);
GridPane.setValignment(muleView, VPos.CENTER);
muleView.setId(String.valueOf(land.getCol()) + String.valueOf(land.getRow()));
grid.add(muleView, land.getCol(), land.getRow());
}
}
}
}
}
numPlayer = players.length;
Turns turns = new Turns(players);
turns.setRounds((int) loadData.get(5));
GameController.beginTurn();
} else {
Controller.loaded = false;
}
}
}
private void halt() {
controller.halt();
}
@FXML
void returnToSpacePort() {
GameController.getControl().setScreen(Screens.NEW_SPACE_PORT);
}
public static void main(String[] args) {
// initialize model
GameBoard GamePieces = new GameBoard();
// initialize controller
GameController Controller = new GameController();
// Initialize GUI
Main_Window window = new Main_Window();
window.initialize();
window.initializeDiscardDialog();
// phase
boolean SecondYear = false;
EventQueue.invokeLater(
new Runnable() {
public void run() {
try {
window.Display.setVisible(true);
window.SetDeckCount(GamePieces.GetDeckSize());
window.SetDiscardCount(GamePieces.GetDiscardDeckSize());
window.SetRoomList(GamePieces.GetTurnPlayerPossibleRooms());
window.SetAllRoomList(GamePieces.GetRoomList());
window.SetHand(GamePieces.GetHumanPlayerHand());
window.SetInitialCardImage();
window.SetPlayer1XYPixel(GamePieces.GetJimPosX(), GamePieces.GetJimPosY());
window.SetPlayer2XYPixel(GamePieces.GetSusyPosX(), GamePieces.GetSusyPosY());
window.SetPlayer3XYPixel(GamePieces.GetBobPosX(), GamePieces.GetBobPosY());
window.SetPlayer1Points(GamePieces.GetJimPoints());
window.SetPlayer2Points(GamePieces.GetSusyPoints());
window.SetPlayer3Points(GamePieces.GetBobPoints());
} catch (Exception e) {
e.printStackTrace();
}
}
});
// Game Flow
while (true) {
if ((GamePieces.QPTotal() > 60) && !SecondYear) {
GamePieces.DiscardHand();
GamePieces.Reshuffle();
GamePieces.RemoveYear1Cards();
GamePieces.AddYear2Cards();
SecondYear = true;
window.SetInitialCardImage();
}
window.SetDeckCount(GamePieces.GetDeckSize());
window.SetDiscardCount(GamePieces.GetDiscardDeckSize());
if (GamePieces.GetDeckSize() == 0) {
GamePieces.Reshuffle();
window.SetDeckCount(GamePieces.GetDeckSize());
window.SetDiscardCount(GamePieces.GetDiscardDeckSize());
}
Controller.ProcessPlayerTurn(GamePieces, window);
try {
Thread.sleep(200);
} catch (Exception e) {
System.out.println("Sleep Error");
e.printStackTrace();
}
}
}
