Merge branch 'master' into power-ups

src/de/brickedleveleditor/game/levels/LevelPackWriter.java

+package de.brickedleveleditor.game.levels;
+import de.bricked.game.bricks.Brick;
+import de.bricked.game.levels.Level;
+import de.bricked.game.paddle.PaddleSize;
+import de.bricked.game.powerups.PowerUp;
+
+
+import java.util.ArrayList;
+
+public class LevelPackWriter
+{
+    private ArrayList<Level> levels;
+
+    public LevelPackWriter()
+    {
+        levels = new ArrayList<>();
+    }
+
+    public void writePack()
+    {
+
+    }
+
+    private String getBoard(ArrayList<Brick> bricks)
+    {
+        StringBuilder builder = new StringBuilder();
+        for(Brick brick : bricks)
+        {
+            String brickName = brick.getType().getID();
+            String powerupName = "";
+            PowerUp powerUp = brick.getPowerUp();
+            if(powerUp == null)
+            {
+                powerupName = "0";
+            }
+            else
+            {
+                powerupName = String.valueOf(powerUp.getID());
+            }
+            builder.append(brickName + powerupName + " ");
+        }
+        builder.delete(builder.length()-1,builder.length());
+        System.out.println(builder.toString());
+        return builder.toString();
+    }
+
+    public void addLevel(String levelname, String author, int position, int difficulty, int startLives, PaddleSize paddleSize, ArrayList<Brick> bricks)
+    {
+        Level level = new Level(levelname, author, position, difficulty, startLives, paddleSize, getBoard(bricks));
+        levels.add(level);
+    }
+}

src/de/brickedleveleditor/main/Main.java

+package de.brickedleveleditor.main;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+import de.brickedleveleditor.ui.Controller;
+import javafx.application.Application;
+import javafx.event.EventHandler;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+import logger.LogLevel;
+import logger.Logger;
+import tools.Worker;
+
+public class Main extends Application
+{
+	public static final ResourceBundle bundle = ResourceBundle.getBundle("de/brickedleveleditor/main/", Locale.GERMANY);
+	
+	@Override
+	public void start(Stage stage)
+	{
+		try
+		{
+			FXMLLoader loader = new FXMLLoader(getClass().getClassLoader().getResource("de/brickedleveleditor/ui/GUI.fxml"));
+			Parent root = (Parent)loader.load();
+
+			Scene scene = new Scene(root, 800, 600);		
+
+			((Controller)loader.getController()).init(stage);
+
+			stage.setTitle(bundle.getString("app.name"));
+			stage.setScene(scene);
+			stage.setResizable(true);
+
+			stage.setOnCloseRequest(new EventHandler<WindowEvent>()
+			{
+				public void handle(WindowEvent we)
+				{
+					Worker.shutdown();
+					System.exit(0);
+				}
+			});
+
+			stage.show();
+		}
+		catch(Exception e)
+		{
+			Logger.log(LogLevel.ERROR, Logger.exceptionToString(e));
+		}
+	}
+
+	public static void main(String[] args)
+	{
+		if(Arrays.asList(args).contains("debug"))
+		{
+			Logger.setLevel(LogLevel.ALL);
+			Logger.log(LogLevel.INFO, "Running in Debug Mode");
+			Logger.log(LogLevel.INFO, bundle.getString("app.name") + " - v" + bundle.getString("version.name") + " - (versioncode: " + bundle.getString("version.code") + ") from " + bundle.getString("version.date"));
+		}
+		else
+		{
+			Logger.setLevel(LogLevel.ERROR);
+		}	
+
+		launch(args);
+	}
+}
\ No newline at end of file

src/de/brickedleveleditor/main/_de.properties

+app.name=Bricked LevelEditor
+version.code=0
+version.name=0.0.0
+version.date=19.10.16
+author=Max Wittig, Robert Goldmann
\ No newline at end of file

src/de/brickedleveleditor/ui/BrickLabel.java

+package de.brickedleveleditor.ui;
+
+
+import de.bricked.game.bricks.BrickType;
+import de.bricked.game.powerups.PowerUpType;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+
+public class BrickLabel extends Label
+{
+    private BrickType brickType;
+    private PowerUpType powerUpType;
+
+    public BrickLabel()
+    {
+    }
+
+    public BrickLabel(BrickType brickType, PowerUpType powerUpType)
+    {
+        super(brickType.getID() + powerUpType.getId());
+        this.brickType = brickType;
+        this.powerUpType = powerUpType;
+
+    }
+
+    public BrickLabel(String text, Node graphic)
+    {
+        super(text, graphic);
+    }
+
+    public BrickType getBrickType()
+    {
+        return brickType;
+    }
+
+    public void setBrickType(BrickType brickType)
+    {
+        this.brickType = brickType;
+        setText(this.brickType.getID()+this.powerUpType.getId());
+    }
+
+    public PowerUpType getPowerUpType()
+    {
+        return powerUpType;
+    }
+
+    public void setPowerUpType(PowerUpType powerUpType)
+    {
+        this.powerUpType = powerUpType;
+        setText(this.brickType.getID()+this.powerUpType.getId());
+    }
+}

src/de/brickedleveleditor/ui/Controller.java

+package de.brickedleveleditor.ui;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+import de.bricked.game.bricks.Brick;
+import de.bricked.game.bricks.BrickType;
+import de.bricked.game.powerups.PowerUpType;
+import de.brickedleveleditor.game.levels.LevelPackWriter;
+import de.bricked.game.paddle.PaddleSize;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.fxml.FXML;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.scene.control.Label;
+import javafx.scene.control.MenuItem;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Paint;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+import logger.LogLevel;
+import logger.Logger;
+import tools.Worker;
+
+public class Controller
+{
+    @FXML
+    private AnchorPane anchorPane;
+    @FXML
+    private VBox sidebarVBox;
+    @FXML
+    private GridPane gridPane;
+    @FXML private MenuItem saveMenuItem;
+    private BrickType[] brickTypes = BrickType.values();
+    private Image currentlySelectedBrickImage;
+    private Image currentlySelectedPowerupImage;
+    private final int WIDTH = 18;
+    private final int HEIGHT = 18;
+
+    public Stage stage;
+    public final ResourceBundle bundle = ResourceBundle.getBundle("de/brickedleveleditor/main/", Locale.GERMANY);
+    private HashMap<BrickType, Image> bricksTextures;
+    private ArrayList<Image> powerupTextures;
+    private LevelPackWriter levelPackWriter;
+
+    public void init(Stage stage)
+    {
+        powerupTextures = new ArrayList<>();
+        levelPackWriter = new LevelPackWriter();
+        gridPane.setMaxSize(50, 50);
+        this.stage = stage;
+        bricksTextures = new HashMap<>();
+        loadPowerupTextures();
+        addPowerupsToVBox();
+        loadBrickTextures();
+        addBricksToVBox();
+        fillGridPaneWithAirBricks();
+        currentlySelectedBrickImage = bricksTextures.get(BrickType.HARD);
+        currentlySelectedPowerupImage = powerupTextures.get(0);
+        stage.setOnCloseRequest(new EventHandler<WindowEvent>()
+        {
+            public void handle(WindowEvent event)
+            {
+                Worker.shutdown();
+                System.exit(0);
+            }
+        });
+
+        saveMenuItem.setOnAction(new EventHandler<ActionEvent>()
+        {
+            @Override
+            public void handle(ActionEvent event)
+            {
+                String levelName = "";
+                String author = "";
+                int position = 0;
+                int difficulty = 1;
+                int startLives = 1;
+                PaddleSize initPadSize = PaddleSize.EXTRA_LARGE;
+                levelPackWriter.addLevel(levelName, author, position, difficulty, startLives, initPadSize, getBrickArrayList());
+            }
+        });
+    }
+
+    private void loadPowerupTextures()
+    {
+        String fileExt = ".png";
+        String rootPath = "de/bricked/resources/textures/powerups/";
+        //powerup[0] means no powerup --> set to null
+        powerupTextures.add(null);
+        for (int i=1; i < PowerUpType.types.length; i++)
+        {
+            File powerupPath = new File(rootPath + PowerUpType.types[i].getId() + fileExt);
+            try
+            {
+                Image image = new Image(powerupPath.getPath());
+                powerupTextures.add(image);
+            }
+            catch (Exception e)
+            {
+                Logger.log(LogLevel.ERROR, Logger.exceptionToString(e));
+            }
+        }
+    }
+
+    private void loadBrickTextures()
+    {
+        String fileExt = ".png";
+        String rootPath = "de/bricked/resources/textures/bricks/";
+        for (BrickType brickType : brickTypes)
+        {
+            File brickPath = new File(rootPath + brickType.getTextureIDs()[0] + fileExt);
+            System.out.println(brickPath.getAbsolutePath());
+            try
+            {
+                Image image = new Image(brickPath.getPath());
+                bricksTextures.put(brickType, image);
+            }
+            catch (Exception e)
+            {
+                Logger.log(LogLevel.ERROR, Logger.exceptionToString(e));
+            }
+        }
+    }
+
+    private HashMap<Image, BrickType> getReversedBrickHashMap()
+    {
+        HashMap<Image, BrickType> reversedHashMap = new HashMap<Image, BrickType>();
+        for (BrickType key : bricksTextures.keySet())
+        {
+            reversedHashMap.put(bricksTextures.get(key), key);
+        }
+        return reversedHashMap;
+    }
+
+    public ArrayList<Brick> getBrickArrayList()
+    {
+        ArrayList<Brick> bricks = new ArrayList<>();
+        Object[] gridPaneChildren = gridPane.getChildren().toArray();
+        for(int i = 0; i < gridPaneChildren.length; i++)
+        {
+            if(gridPaneChildren[i] instanceof BrickLabel)
+            {
+                BrickLabel currentLabel = (BrickLabel)gridPaneChildren[i];
+                Brick brick = new Brick(currentLabel.getBrickType(),
+                        PowerUpType.getInstance(currentLabel.getPowerUpType()));
+                bricks.add(brick);
+            }
+        }
+        return bricks;
+    }
+
+    private void addBricksToVBox()
+    {
+        for (BrickType brickType : brickTypes)
+        {
+            Label brickLabel = new Label(brickType.toString());
+            brickLabel.setBackground(getBackGroundFromImage(bricksTextures.get(brickType)));
+            brickLabel.setOnMouseClicked(new EventHandler<MouseEvent>()
+            {
+                @Override
+                public void handle(MouseEvent event)
+                {
+                    currentlySelectedBrickImage = bricksTextures.get(brickType);
+                    Logger.log(LogLevel.DEBUG, brickType.toString() + " selected");
+                }
+            });
+            HBox brickHBox = new HBox(brickLabel);
+            sidebarVBox.getChildren().add(brickHBox);
+        }
+    }
+
+    private void addPowerupsToVBox()
+    {
+        for(int i=1; i < powerupTextures.size(); i++)
+        {
+            Image powerupImage = powerupTextures.get(i);
+            Label powerupLabel = new Label(PowerUpType.types[i].toString());
+            powerupLabel.setOnMouseClicked(new EventHandler<MouseEvent>()
+            {
+                @Override
+                public void handle(MouseEvent event)
+                {
+                    currentlySelectedPowerupImage = powerupImage;
+                }
+            });
+            powerupLabel.setBackground(getBackGroundFromImage(powerupTextures.get(i)));
+            HBox powerupHBox = new HBox(powerupLabel);
+            VBox.setMargin(sidebarVBox, new Insets(50, 10, 10, 10));
+            sidebarVBox.getChildren().add(powerupHBox);
+        }
+    }
+
+    private Background getBackGroundFromImage(Image image)
+    {
+        BackgroundImage backgroundImage = new BackgroundImage(image,
+                BackgroundRepeat.NO_REPEAT,BackgroundRepeat.NO_REPEAT,
+                BackgroundPosition.CENTER,BackgroundSize.DEFAULT);
+        Background background = new Background(backgroundImage);
+        return background;
+    }
+
+    private void initGrid()
+    {
+        gridPane.getColumnConstraints().clear();
+        double xPercentage = 1.0 / WIDTH;
+        for (int i = 0; i < WIDTH; i++)
+        {
+            ColumnConstraints c = new ColumnConstraints();
+            c.setPercentWidth(xPercentage * 100);
+            gridPane.getColumnConstraints().add(c);
+        }
+
+        gridPane.getRowConstraints().clear();
+        double yPercentage = 1.0 / HEIGHT;
+        for (int i = 0; i < HEIGHT; i++)
+        {
+            RowConstraints c = new RowConstraints();
+            c.setPercentHeight(yPercentage * 100);
+            gridPane.getRowConstraints().add(c);
+        }
+        gridPane.setGridLinesVisible(true);
+    }
+
+    private void fillGridPaneWithAirBricks()
+    {
+        initGrid();
+        for (int i = 0; i < WIDTH; i++)
+        {
+            for (int k = 0; k < HEIGHT; k++)
+            {
+                BrickType brickType = BrickType.AIR;
+                PowerUpType powerUpType = PowerUpType.NONE;
+                Image image = bricksTextures.get(brickType);
+                BrickLabel label = new BrickLabel(brickType, powerUpType);
+                label.setMinSize(30, 25);
+                label.setBackground(getBackGroundFromImage(image));
+                gridPane.add(label, k, i);
+                label.setAlignment(Pos.CENTER);
+                label.setTextFill(Paint.valueOf("black"));
+
+                label.setOnMouseClicked(new EventHandler<MouseEvent>()
+                {
+                    @Override
+                    public void handle(MouseEvent event)
+                    {
+                        label.setBackground(getBackGroundFromImage(currentlySelectedBrickImage));
+                        label.setPowerUpType(PowerUpType.values()[powerupTextures.indexOf(currentlySelectedPowerupImage)]);
+                        label.setBrickType(getReversedBrickHashMap().get(currentlySelectedBrickImage));
+                    }
+                });
+            }
+        }
+    }
+
+    public void about()
+    {
+        Alert alert = new Alert(AlertType.INFORMATION);
+        alert.setTitle("About " + bundle.getString("app.name"));
+        alert.setHeaderText(bundle.getString("app.name"));
+        alert.setContentText("Version:     " + bundle.getString("version.name") + "\r\nDate:         " + bundle.getString("version.date") + "\r\nAuthors:     " + bundle.getString("author") + "\r\n");
+        Stage dialogStage = (Stage) alert.getDialogPane().getScene().getWindow();
+        dialogStage.centerOnScreen();
+        alert.showAndWait();
+    }
+}
\ No newline at end of file

src/de/brickedleveleditor/ui/GUI.fxml

+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Menu?>
+<?import javafx.scene.control.MenuBar?>
+<?import javafx.scene.control.MenuItem?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.RowConstraints?>
+<?import javafx.scene.layout.VBox?>
+
+<AnchorPane fx:id="anchorPane" prefHeight="600.0" prefWidth="800.0" xmlns="http://javafx.com/javafx/8.0.65" xmlns:fx="http://javafx.com/fxml/1" fx:controller="de.brickedleveleditor.ui.Controller">
+   <children>
+      <MenuBar layoutX="40.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
+        <menus>
+            <Menu mnemonicParsing="false" text="File">
+              <items>
+                <MenuItem fx:id="saveMenuItem" mnemonicParsing="false" text="Save" />
+                  <MenuItem mnemonicParsing="false" text="Unspecified Action" />
+              </items>
+            </Menu>
+          <Menu mnemonicParsing="false" text="Hilfe">
+            <items>
+              <MenuItem mnemonicParsing="false" onAction="#about" text="Über" />
+            </items>
+          </Menu>
+        </menus>
+      </MenuBar>
+      <VBox fx:id="sidebarVBox" alignment="CENTER" layoutX="614.0" layoutY="29.0" prefHeight="572.0" prefWidth="186.0" AnchorPane.bottomAnchor="-1.0" AnchorPane.topAnchor="29.0" />
+      <GridPane fx:id="gridPane" alignment="CENTER" gridLinesVisible="true" layoutX="14.0" layoutY="58.0" prefHeight="526.0" prefWidth="595.0" AnchorPane.bottomAnchor="16.0" AnchorPane.leftAnchor="14.0" AnchorPane.rightAnchor="191.0" AnchorPane.topAnchor="58.0">
+        <columnConstraints>
+          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+        </columnConstraints>
+        <rowConstraints>
+          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+        </rowConstraints>
+      </GridPane>
+   </children>
+</AnchorPane>