diff --git a/.idea/artifacts/WordiadaApp.xml b/.idea/artifacts/WordiadaApp.xml
new file mode 100644
index 0000000..9fa6775
--- /dev/null
+++ b/.idea/artifacts/WordiadaApp.xml
@@ -0,0 +1,23 @@
+<component name="ArtifactManager">
+  <artifact type="javafx" name="WordiadaApp">
+    <output-path>$PROJECT_DIR$/out/artifacts/WordiadaApp</output-path>
+    <properties id="javafx-properties">
+      <options>
+        <option name="appClass" value="desktopUI.Main" />
+        <option name="description" value="" />
+        <option name="htmlPlaceholderId" value="" />
+        <option name="title" value="Wordiada" />
+        <option name="vendor" value="" />
+        <option name="version" value="" />
+      </options>
+    </properties>
+    <root id="root">
+      <element id="archive" name="WordiadaApp.jar">
+        <element id="module-output" name="DesktopUI" />
+      </element>
+      <element id="archive" name="WordiadaEngine.jar">
+        <element id="module-output" name="GameEngine" />
+      </element>
+    </root>
+  </artifact>
+</component>
\ No newline at end of file
diff --git a/.idea/artifacts/WordiadaEngine_jar.xml b/.idea/artifacts/WordiadaEngine_jar.xml
new file mode 100644
index 0000000..f9aadd5
--- /dev/null
+++ b/.idea/artifacts/WordiadaEngine_jar.xml
@@ -0,0 +1,10 @@
+<component name="ArtifactManager">
+  <artifact name="WordiadaEngine:jar">
+    <output-path>$PROJECT_DIR$/out/artifacts/WordiadaEngine_jar</output-path>
+    <root id="root">
+      <element id="archive" name="WordiadaEngine.jar">
+        <element id="module-output" name="GameEngine" />
+      </element>
+    </root>
+  </artifact>
+</component>
\ No newline at end of file
diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
new file mode 100644
index 0000000..1c24f9a
--- /dev/null
+++ b/.idea/kotlinc.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="KotlinCommonCompilerArguments">
+    <option name="languageVersion" value="1.1" />
+    <option name="apiVersion" value="1.1" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..36a8f7e
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+  <component name="WebServicesPlugin" addRequiredLibraries="true" />
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..b6014e4
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/ConsoleUI/ConsoleUI.iml" filepath="$PROJECT_DIR$/ConsoleUI/ConsoleUI.iml" />
+      <module fileurl="file://$PROJECT_DIR$/DesktopUI/DesktopUI.iml" filepath="$PROJECT_DIR$/DesktopUI/DesktopUI.iml" />
+      <module fileurl="file://$PROJECT_DIR$/GameEngine/GameEngine.iml" filepath="$PROJECT_DIR$/GameEngine/GameEngine.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..94a25f7
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/DesktopUI/DesktopUI.iml b/DesktopUI/DesktopUI.iml
new file mode 100644
index 0000000..a739098
--- /dev/null
+++ b/DesktopUI/DesktopUI.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="GameEngine" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/DesktopUI/src/META-INF/MANIFEST.MF b/DesktopUI/src/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..180c316
--- /dev/null
+++ b/DesktopUI/src/META-INF/MANIFEST.MF
@@ -0,0 +1,4 @@
+Manifest-Version: 1.0
+Class-Path: WordiadaEngine.jar
+Main-Class: desktopUI.Main
+
diff --git a/DesktopUI/src/desktopUI/Board/Board.java b/DesktopUI/src/desktopUI/Board/Board.java
new file mode 100644
index 0000000..35aa7b9
--- /dev/null
+++ b/DesktopUI/src/desktopUI/Board/Board.java
@@ -0,0 +1,312 @@
+package desktopUI.Board;
+
+import desktopUI.Tile.SingleLetterController;
+import javafx.fxml.FXMLLoader;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.control.Button;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.Region;
+
+import engine.GameDataFromXml.DataLetter;
+
+import java.awt.*;
+import desktopUI.utils.Common;
+import java.io.IOException;
+import java.util.*;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+public class Board {
+
+    private GridPane boardGridPane;
+    private Callable<Boolean> wordBuilder;
+    private short size;
+    private Map<Button, SingleLetterController> buttonsMap;
+    private List<Button> pressedButtons = new ArrayList<>();
+    private boolean buildWord = false;
+
+    public Board(short size, GridPane boardGridPane) {
+
+        this.size = size;
+        this.boardGridPane = boardGridPane;
+        buttonsMap = new HashMap<>();
+        loadBoard();
+    }
+
+    // get + set
+
+
+    public List<Button> getPressedButtons() {
+        return pressedButtons;
+    }
+
+    public List<int[]> getPressedButtonsIndices() {
+        List<int[]> indexList = new ArrayList<>();
+        for (Button button: pressedButtons) {
+            int[] point = {GridPane.getRowIndex(button), GridPane.getColumnIndex(button)};
+            indexList.add(point);
+        }
+        return indexList;
+    }
+
+    public List<Button> getButtonsFromIndices(List<int[]> buttonsIndices) {
+        List<Button> list = new ArrayList<>();
+        for (int[] index: buttonsIndices) {
+            Button button = (Button)getNodeByRowColumnIndex(index[0], index[1], boardGridPane);
+            list.add(button);
+        }
+        return list;
+    }
+
+    public Map<Button, SingleLetterController> getButtonsMap() {
+        return buttonsMap;
+    }
+
+    // probably will not need this func--->
+    /*public void setAllBoardValues(char [][] boardView, List<DataLetter> dataLetterList){
+        for(int i = 0 ; i < size; i++){
+            for(int j = 0; j < size; j ++){
+                char sign = boardView[i][j];
+                Button button = getNodeByRowColumnIndex(i+1,j+1,boardGridPane);
+                DataLetter dataLetter = findDataLetterBySign(sign, dataLetterList);
+                if(dataLetter == null) {
+                    System.out.println("Error in getting the letters' information from xml properly !");
+                }
+                else {
+                    String setSign = String.format("%c (%d)", sign, dataLetter.getLetter().getScore());
+                    buttonsMap.get(button).setLetter(setSign);
+                }
+            }
+        }
+    }*/
+
+    public void setPressedButtonsValues(char[][] boardView, List<Button> pressedButtons, List<DataLetter> dataLetterList){
+        for(int i = 0 ; i < size; i++) {
+            for (int j = 0; j < size; j++) {
+                char sign = boardView[i][j];
+                Node button = getNodeByRowColumnIndex(i+1,j+1,boardGridPane);
+                DataLetter dataLetter = findDataLetterBySign(sign, dataLetterList);
+                if(isButtonExist(pressedButtons,(Button)button)){
+                    String setSign = String.format("%c (%d)", sign, dataLetter.getLetter().getScore());
+                    buttonsMap.get(button).setLetter(setSign);
+                }
+            }
+        }
+    }
+
+    public void setPressedButtonsValues(char[][] boardView, List<DataLetter> dataLetterList){
+        for (Button button: pressedButtons) {
+            int row = GridPane.getRowIndex(button) - 1;
+            int col = GridPane.getColumnIndex(button) - 1;
+            char sign = boardView[row][col];
+            DataLetter dataLetter = findDataLetterBySign(sign, dataLetterList);
+            String setSign = String.format("%c (%d)", sign, dataLetter.getLetter().getScore());
+            buttonsMap.get(button).setLetter(setSign);
+        }
+    }
+
+    public void updateFromSave(char[][] boardView, List<Button> pressedButtons, List<DataLetter> dataLetterList) {
+        for(int i = 0 ; i < size; i++) {
+            for (int j = 0; j < size; j++) {
+                char sign = boardView[i][j];
+                Button button = (Button) getNodeByRowColumnIndex(i+1,j+1,boardGridPane);
+                DataLetter dataLetter = findDataLetterBySign(sign, dataLetterList);
+                if (sign == ' ') {
+                    buttonsMap.get(button).setLetter("");
+                }
+                else {
+                    String setSign = String.format("%c (%d)", sign, dataLetter.getLetter().getScore());
+                    buttonsMap.get(button).setLetter(setSign);
+                }
+                if (pressedButtons.contains(button)) {
+                    button.setStyle("-fx-border-color: blue;" +
+                            "-fx-background-color: aqua");
+                }
+                else {
+                    button.setStyle("");
+                }
+            }
+        }
+    }
+
+    public void resetPressStyle() {
+        for (Button button: pressedButtons) {
+            button.setStyle("");
+        }
+    }
+
+    public void updateNodeToTile(javafx.scene.control.Button button){
+        SingleLetterController slc = new SingleLetterController(button);
+        slc.initialize();
+        buttonsMap.put(button,slc);
+    }
+
+    private void loadBoard(){
+        for (short row = 1; row < size+1; row++) {
+            for (short col = 1; col < size+1; col++) {
+                Button tile = new Button();
+                tile.setId(String.format("tile%d%d",row,col));
+                tile.setPrefSize(Region.USE_COMPUTED_SIZE,Region.USE_COMPUTED_SIZE);
+                tile.setMinSize(70,70);
+                GridPane.setMargin(tile, new Insets(1, 1, 1, 1));
+                //tile.disableProperty().bind(isClickable.not());
+                tile.setDisable(true);
+                tile.setOnMouseClicked((MouseEvent event) -> {
+                        if (event.getEventType() == MouseEvent.MOUSE_CLICKED) {
+                            boolean allClickable = areAllButtonsClickable();
+                            if(buttonsMap.get(tile).getLetterProperty().getValue()!="" && allClickable){
+                                Common.showError("you Cannot open an already open tile!\n\nTry again!");
+                            }
+                            else {
+                                if (pressedButtons.contains(tile) && tile.getStyle().equals("-fx-border-color: blue;" +
+                                        "-fx-background-color: aqua")) {
+                                    //if (tile.getStyle().equals("-fx-border-color: blue;" + "-fx-background-color: aqua")){
+                                    tile.setStyle("");
+                                    pressedButtons.remove(tile);
+                                    if (buildWord) {
+                                        try {
+                                            wordBuilder.call();
+                                        } catch (Exception e) {
+                                        }
+                                    }
+                                } else {
+                                    tile.setStyle("-fx-border-color: blue;" +
+                                            "-fx-background-color: aqua");
+                                    pressedButtons.add(tile);
+                                    if (buildWord) {
+                                        try {
+                                            wordBuilder.call();
+                                        } catch (Exception e) {
+                                        }
+                                    }
+                                }
+                            }
+
+                        }
+                });
+                this.updateNodeToTile(tile);
+                boardGridPane.add(tile, col, row );
+            }
+        }
+    }
+
+    public Node createTile() {
+        try {
+            FXMLLoader loader = new FXMLLoader();
+            loader.setLocation(getClass().getResource("/desktopUI/Tile/Tile.fxml"));
+            Button singleLetterTile = loader.load();
+
+            SingleLetterController singleLetterController = loader.getController();
+            buttonsMap.put(singleLetterTile, singleLetterController);
+
+            return singleLetterTile;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    //TODO: put those 3 funcs in a static class which support helper funcs without spesific subject
+    //1.   helper gridpane func
+    public Node getNodeByRowColumnIndex ( int row,  int column, GridPane gridPane) {
+        Node result = null;
+
+        java.util.List<Node> children;
+        children = gridPane.getChildren();
+
+        for (Node node : children) {
+            if(GridPane.getRowIndex(node) == row && GridPane.getColumnIndex(node) == column) {
+                result = node;
+                break;
+            }
+        }
+        return result;
+    }
+
+    //2. helper func for findinng a dataLetter type in a list:
+
+    public DataLetter findDataLetterBySign(char sign,List<DataLetter>dataLetterList){
+
+        for(DataLetter dataLetter : dataLetterList){
+            if((dataLetter.getLetter().getSign().get(0).toCharArray())[0] == sign)
+                return dataLetter;
+            }
+        return null;
+    }
+
+
+    //3. helper func to find if item exists in a list
+    public boolean isButtonExist(List<Button> buttons, Button buttonToFind){
+        for(Button button : buttons){
+            if(buttonToFind == button)
+                return true;
+        }
+        return false;
+    }
+
+    public List<Button> getBoardButtonList(){
+        List<Button> retList = new ArrayList<>();
+        retList.addAll(buttonsMap.keySet());
+        return retList;
+    }
+
+    public void setAllDisable(boolean disable) {
+        for (Button button: buttonsMap.keySet()) {
+            button.setDisable(disable);
+        }
+    }
+
+    public void resetPressedButtons() {
+        for (Button button: pressedButtons) {
+            buttonsMap.get(button).setLetter("");
+        }
+    }
+
+    public void resetAllButtons(){
+        for (Button button: buttonsMap.keySet()) {
+            buttonsMap.get(button).setLetter("");
+            button.setStyle("");
+            button.setDisable(true);
+        }
+    }
+
+    public void buildWord(boolean buildWord, Callable<Boolean> wordBuilder) {
+        this.buildWord = buildWord;
+        this.wordBuilder = wordBuilder;
+    }
+
+    public void removeAllBoardButtons(){
+        for(SingleLetterController buttonlLetter : buttonsMap.values())
+            buttonlLetter.setLetter("");
+    }
+    public List<Point> fromSingleLetterToPoint(){
+        List<Point> points = new ArrayList<>();
+
+        for(Button button: pressedButtons){
+            int sizeId = button.getId().length();
+            int col = button.getId().charAt(sizeId-1) - 48;
+            int row = button.getId().charAt(sizeId-2) - 48;
+            Point pointToAdd = new Point(col, row);
+            points.add(pointToAdd);
+        }
+        return  points;
+    }
+
+    public boolean areAllButtonsClickable(){
+        for(Button button : buttonsMap.keySet()){
+            if(button.isDisable())
+                return false;
+        }
+        return true;
+    }
+
+    public boolean areAllTilesShown(){
+        for(SingleLetterController singleLetter : buttonsMap.values()){
+            if(singleLetter.getLetterProperty().getValue().equals(""))
+                return false;
+        }
+        return  true;
+    }
+}
diff --git a/DesktopUI/src/desktopUI/Controller/Controller.java b/DesktopUI/src/desktopUI/Controller/Controller.java
new file mode 100644
index 0000000..047e8cf
--- /dev/null
+++ b/DesktopUI/src/desktopUI/Controller/Controller.java
@@ -0,0 +1,496 @@
+
+package desktopUI.Controller;
+
+import desktopUI.Board.Board;
+import desktopUI.userInfo.UserInfoController;
+import desktopUI.utils.Common;
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.Node;
+import javafx.scene.control.*;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.VBox;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+import desktopUI.GameManager.GameManager;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+ public class Controller {
+
+
+    private Stage primaryStage;
+    private GameManager gameManager;
+    private Board board;
+    private Map<Short, UserInfoController> userInfoControllerMap;
+
+    @FXML private  GridPane boardPane;
+    @FXML private VBox buttonsVBox;
+    @FXML private Button loadXmlButton;
+    @FXML private Button startButton;
+    @FXML private Button diceButton;
+    @FXML private Button moveButton;
+    @FXML private Button retireButton;
+    @FXML private Button exitButton;
+    @FXML private Button helpButton;
+    @FXML private Label turnNumberLabel;
+    @FXML private ScrollPane boardScrollPane;
+    @FXML private Label initInfoGame;
+    @FXML private Label titleInfoGame;
+    @FXML private Label titlePlayerData;
+    @FXML private VBox playerVBox;
+    @FXML private Button checkWord;
+    @FXML private Label buildWordLabel;
+    @FXML private Label tryNumberLabel;
+    @FXML private Label totalTriesLabel;
+    @FXML private Label diceValueLabel;
+    @FXML private Button newGameButton;
+    @FXML private Button playAgainButton;
+    @FXML private Button nextButton;
+    @FXML private Button prevButton;
+
+    private SimpleIntegerProperty selectedTurnNumber;
+    private SimpleStringProperty selectedInitInfoGame;
+    private SimpleStringProperty selectedTitleInfoGame;
+    private SimpleStringProperty selectedTitlePlayerData;
+    private SimpleIntegerProperty diceValueProperty;
+    private SimpleStringProperty wordBuildProperty;
+    private SimpleIntegerProperty tryNumberProperty;
+    private SimpleIntegerProperty totalTriesProperty;
+
+    public Controller(){
+        selectedTurnNumber = new SimpleIntegerProperty();
+        selectedTurnNumber.set(0);
+        selectedInitInfoGame = new SimpleStringProperty();
+        selectedTitleInfoGame = new SimpleStringProperty();
+        selectedTitlePlayerData = new SimpleStringProperty();
+        diceValueProperty = new SimpleIntegerProperty();
+        wordBuildProperty = new SimpleStringProperty();
+        tryNumberProperty = new SimpleIntegerProperty();
+        totalTriesProperty = new SimpleIntegerProperty();
+        gameManager= new GameManager(this);
+   }
+
+    @FXML
+    public void initialize() {
+        turnNumberLabel.textProperty().bind(Bindings.format("%,d", selectedTurnNumber));
+        initInfoGame.textProperty().bind(selectedInitInfoGame);
+        titleInfoGame.textProperty().bind(selectedTitleInfoGame);
+        titlePlayerData.textProperty().bind(selectedTitlePlayerData);
+        buildWordLabel.textProperty().bind(wordBuildProperty);
+        totalTriesLabel.textProperty().bind(Bindings.format("%,d", totalTriesProperty));
+        tryNumberLabel.textProperty().bind(Bindings.format("%,d", tryNumberProperty));
+        diceValueLabel.textProperty().bind(Bindings.format("%,d", diceValueProperty));
+    }
+
+    public void setPrimaryStage(Stage primaryStage) {
+        this.primaryStage = primaryStage;
+    }
+
+    public SimpleIntegerProperty getTurnProperty() {
+        return selectedTurnNumber;
+    }
+
+    public Button getLoadXmlButton() {
+        return loadXmlButton;
+    }
+
+    public Button getMoveButton() {
+        return moveButton;
+    }
+
+    public Button getCheckWord() {
+        return checkWord;
+    }
+
+    public Button getRetireButton() {
+        return retireButton;
+    }
+
+    public Button getStartButton() {
+        return startButton;
+    }
+
+    public Button getDiceButton() {
+        return diceButton;
+    }
+
+    public Button getNextButton() {
+        return nextButton;
+    }
+
+    public Button getPrevButton() {
+        return prevButton;
+    }
+
+    public SimpleStringProperty getWordBuildProperty() {
+        return wordBuildProperty;
+    }
+
+    public Button getPlayAgainButton() {
+        return playAgainButton;
+    }
+
+    public Button getNewGameButton() {
+        return newGameButton;
+    }
+
+    public Map<Short, UserInfoController> getUserInfoMap() {
+        return userInfoControllerMap;
+    }
+
+    public SimpleIntegerProperty getTryNumberProperty() {
+        return tryNumberProperty;
+    }
+
+    // init the score of all users to 0
+    private void initScore() {
+        if (userInfoControllerMap != null) {
+            for (UserInfoController userInfoController : userInfoControllerMap.values()) {
+                userInfoController.setScoreProperty(0);
+            }
+        }
+    }
+
+    // reset the gama ui
+    private void reinitialize() {
+        initScore();
+        board = null;
+        userInfoControllerMap = null;
+        boardPane.getChildren().clear();
+        selectedTurnNumber.set(0);
+        selectedInitInfoGame.set("");
+        selectedTurnNumber.set(0);
+        moveButton.setDisable(true);
+        diceButton.setDisable(true);
+        playerVBox.getChildren().clear();
+        retireButton.setDisable(true);
+    }
+
+    // init turn
+    public void resetTurn(boolean clearButtons) {
+        wordBuildProperty.set("");
+        diceButton.setDisable(false);
+        moveButton.setDisable(true);
+//        buildWord.setDisable(true);
+        checkWord.setDisable(true);
+        board.resetPressStyle();
+        if (clearButtons) {
+            board.resetPressedButtons();
+        }
+        board.getPressedButtons().clear();
+        board.setAllDisable(true);
+        board.buildWord(false, null);
+        tryNumberProperty.set(0);
+        diceValueProperty.set(0);
+        //TODO: check if works
+        if(gameManager.getIsFishMod()){
+            board.removeAllBoardButtons();
+        }
+    }
+
+    public void resetBoard(char[][] board) {
+        this.board.updateFromSave(board, new ArrayList<>(), gameManager.getGameEngine().getCurrentGameData().getKupa());
+    }
+
+    @FXML
+    public void loadXmlFile(){
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.setTitle("Choose xml file");
+        fileChooser.getExtensionFilters().addAll(new FileChooser.ExtensionFilter("XML", "*.xml"));
+        File noy = new File("C:\\Users\\noy\\Desktop\\לימודים\\IdeaProjects\\Wordiada");
+        File ido = new File("D:\\progrmming\\github\\Wordiada");
+        if(noy.exists()) fileChooser.setInitialDirectory(noy);
+        else if (ido.exists()) fileChooser.setInitialDirectory(ido);
+        File xmlFile = fileChooser.showOpenDialog(primaryStage);
+        if (xmlFile == null) {
+            return;
+        }
+        gameManager.loadXML(xmlFile);
+    }
+
+    // init game
+    public void initGame() {
+        reinitialize();
+        userInfoControllerMap = gameManager.getDataPlayers(playerVBox);
+        selectedInitInfoGame.set(gameManager.getInitInfoGame());
+        totalTriesProperty.set(gameManager.getMaxTries());
+        //init board
+        board = new Board(gameManager.getGameEngine().getBoardSize(), boardPane);
+        startButton.setDisable(false);
+        selectedTitleInfoGame.set("Information about the Game:");
+        selectedTitlePlayerData.set("Information about the Players:");
+    }
+
+    // helper func
+    public Node getNodeByRowColumnIndex ( int row,  int column, GridPane gridPane) {
+        Node result = null;
+
+        List <Node> children = gridPane.getChildren();
+
+        for (Node node : children) {
+            if(GridPane.getRowIndex(node) == row && GridPane.getColumnIndex(node) == column) {
+                result = node;
+                break;
+            }
+        }
+        return result;
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+
+    @FXML public void playTurn() {
+        // adding the pressed tile to the list:
+        loadXmlButton.setDisable(true);
+        startButton.setDisable(true);
+        diceButton.setDisable(false);
+        retireButton.setDisable(false);
+        short id = gameManager.startGame();
+        selectPlayer((short)-1, id);
+
+        Alert alert = new Alert(Alert.AlertType.INFORMATION);
+        alert.setTitle("Instructions");
+        alert.setContentText("The game is started!\npress on Throw Die button to see the value of your die, and then you" +
+                             "need to choose tiles on the board as many as the die's value.\nOnce you choose press on the " +
+                             "Make a Move button which will shows you the hidden letters." +
+                             "\n\n Have Fun!!!");
+
+        alert.setHeaderText(null);
+        alert.show();
+    }
+
+    public void selectPlayer(short prevId, short newId) {
+        UserInfoController userController;
+        if (prevId != -1) {
+            userController = userInfoControllerMap.get(prevId);
+            userController.setStyleProperty("");
+            userController.disableDetailsButton(true);
+        }
+        userController = userInfoControllerMap.get(newId);
+        userController.setStyleProperty("-fx-font-weight: bold");
+        userController.disableDetailsButton(false);
+        checkComputer();
+    }
+
+    public void checkComputer() {
+        if (!gameManager.getGameEngine().isGameEnded() && gameManager.isPlayerComputer()) {
+            gameManager.runComputer();
+        }
+    }
+
+    private void setAllDisable() {
+
+        loadXmlButton.setDisable(true);
+        startButton.setDisable(true);
+        diceButton.setDisable(true);
+        moveButton.setDisable(true);
+        retireButton.setDisable(true);
+        exitButton.setDisable(true);
+    }
+
+    @FXML public void makeMove() {
+        //TODO: check if enough tiles to choose tiles  as dice value
+        String notEnoughTilesError = "You need to choose at least one letter!\n\nTry again.";
+
+        if (board.getPressedButtons().isEmpty()) {
+            board.setAllDisable(false);
+            Common.showError(notEnoughTilesError);
+            return;
+        }
+        tryNumberProperty.set(1);
+        gameManager.updateBoard(board.getPressedButtonsIndices());
+    }
+
+    public void updateBoard(char[][] board) {
+        String outputMessageValidMove = "Now you can watch the hidden letters you chose to open!\n\n" +
+                "Try to build a word from those letter by pressing them by the order in which they appear. (If you" +
+                " accidentally pressed the wrong order, that's OK, just press again, so the letters will " +
+                "be covered by a blue background).\n When you have a word in your mind, press on the Check Word Button to continue.\n\nGood Luck!!!";
+
+        Alert alert = new Alert(Alert.AlertType.INFORMATION);
+        alert.setTitle("Message");
+        alert.setContentText(outputMessageValidMove);
+        alert.showAndWait();
+
+        moveButton.setDisable(true);
+        checkWord.setDisable(false);
+        this.board.setPressedButtonsValues(board, gameManager.getGameEngine().getCurrentGameData().getKupa());
+        // this.board.setPressedButtonsValues(board, this.board.getPressedButtons(), gameManager.getGameEngine().getCurrentGameData().getKupa());
+        gameManager.setUnclickableButtons(this.board.getPressedButtons(), this.board.getBoardButtonList());
+        gameManager.setDefaultStyle(this.board.getPressedButtons());
+
+        this.board.buildWord(true, () -> {
+            wordBuildProperty.set(gameManager.buttonsToStr(this.board.getPressedButtons(), gameManager.getGameEngine().getBoard()));
+            return Boolean.TRUE;
+        });
+
+        this.board.getPressedButtons().clear();
+   }
+
+   public void savedBoardUpdate(char[][] board, List<int[]> pressedButtonsIndices) {
+       List<Button> buttons = this.board.getButtonsFromIndices(pressedButtonsIndices);
+       this.board.updateFromSave(board, buttons, gameManager.getGameEngine().getCurrentGameData().getKupa());
+       wordBuildProperty.set(gameManager.buttonsToStr(buttons, board));
+   }
+
+    @FXML public void checkWord(){
+
+        moveButton.setDisable(true);
+
+        String word = gameManager.buttonsToStr(board.getPressedButtons(), gameManager.getGameEngine().getBoard());
+        gameManager.checkWord(word);
+
+        // num turn +
+
+    }
+
+    @FXML
+        public void throwDie() {
+        Alert alert = new Alert(Alert.AlertType.INFORMATION);
+        boolean allShown = false;
+        if(!gameManager.getIsFishMod())
+            allShown = board.areAllTilesShown();
+        //if the game is over
+        if(gameManager.getGameEngine().isGameEnded(allShown)){
+            alert.setTitle("Game is Over");
+            alert.setContentText("Game's Over...\n Choose one of the buttons options");
+            alert.setHeaderText(null);
+            alert.showAndWait();
+            endOfGameStatus();
+        }
+
+        else {
+            moveButton.setDisable(false);
+            alert.setTitle("Dice Throw - Wordiada");
+            alert.setContentText("Throwing dice...");
+            alert.setHeaderText(null);
+            alert.show();
+            gameManager.getDiceValue(diceValueProperty);
+            //board.setIsClickable(true);
+            board.setAllDisable(false);
+            diceButton.setDisable(true);
+            alert.setContentText("Dice value is " + diceValueProperty.get());
+            gameManager.setCurrentDiceValue(diceValueProperty.get());
+        }
+    }
+
+    @FXML
+    public void exitGame() {
+        Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "Are you sure you want to exit?");
+        alert.setHeaderText(null);
+        Optional<ButtonType> result = alert.showAndWait();
+        if (result.isPresent() && result.get() == ButtonType.OK) {
+            gameManager.exitGame();
+        }
+    }
+
+    public void playerRetired(short retiredPlayerId, boolean isRetired) {
+        UserInfoController userInfoController = userInfoControllerMap.get(retiredPlayerId);
+        userInfoController.setStrikeThrough(isRetired);
+    }
+
+    @FXML
+    public void retire() {
+        Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "Are you sure you want to retire?");
+        alert.setHeaderText(null);
+        Optional<ButtonType> result = alert.showAndWait();
+        if (result.isPresent() && result.get() == ButtonType.OK) {
+            gameManager.retire();
+        }
+    }
+
+    //TODO: fix and put back the call in the button - i changed foe testing
+    @FXML
+    public void help() {
+        // Play turn
+        String playTurnHelpTitle = "Instructions";
+        String playTurnHelpContent = "The game is started!\npress on Throw Die button to see the value of your die, and then you" +
+                "need to choose tiles on the board as many as the die's value.\nOnce you choose press on the " +
+                "Make a Move button which will shows you the hidden letters." +
+                "\n\n Have Fun!!!";
+
+        //update board
+        String updateBoardHelpTitle = "Message";
+        String updateBoardHelpContent = "Now you can watch the hidden letters you chose to open!\n\n" +
+                "Try to build a word from those letter by pressing them by the order in which they appear. (If you" +
+                " accidentally pressed the wrong order, that's OK, just press again, so the letters will " +
+                "be covered by a blue background).\n When you have a word in your mind, press on the Check Word Button to continue.\n\nGood Luck!!!";
+
+        String title = null;
+        String content = null;
+
+        if (!diceButton.isDisable()) {
+            title = playTurnHelpTitle;
+            content = playTurnHelpContent;
+        }
+        else if (!moveButton.isDisable()) {
+            title = updateBoardHelpTitle;
+            content = updateBoardHelpContent;
+        }
+
+        Alert alert = new Alert(Alert.AlertType.INFORMATION);
+        alert.setTitle(title);
+        alert.setContentText(content);
+        alert.setHeaderText(null);
+        alert.showAndWait();
+    }
+
+    //show the buttons: new game, play again, prev and next
+    @FXML
+    public void endOfGameStatus(){
+        startButton.setDisable(true);
+        loadXmlButton.setDisable(true);
+        diceButton.setDisable(true);
+        moveButton.setDisable(true);
+        retireButton.setDisable(true);
+        checkWord.setDisable(true);
+        board.resetAllButtons();
+        initScore();
+        next();
+        showEndGameControllers(true);
+        prevButton.setDisable(true);
+    }
+
+    private void showEndGameControllers(boolean show) {
+        newGameButton.setVisible(show);
+        playAgainButton.setVisible(show);
+        prevButton.setVisible(show);
+        nextButton.setVisible(show);
+    }
+
+    @FXML
+    public void loadNewXmlFile() {
+        showEndGameControllers(false);
+        loadXmlButton.setDisable(false);
+        loadXmlFile();
+    }
+
+    @FXML public void playAgain(){
+        showEndGameControllers(false);
+        gameManager.reset();
+    }
+
+    @FXML
+    public void prev(){
+        if (nextButton.isDisable()) {
+            nextButton.setDisable(false);
+        }
+        gameManager.prevSaveData();
+    }
+
+     @FXML
+     public void next(){
+         if (prevButton.isDisable()) {
+             prevButton.setDisable(false);
+         }
+         gameManager.nextSaveData();
+     }
+}
diff --git a/DesktopUI/src/desktopUI/GameManager/GameManager.java b/DesktopUI/src/desktopUI/GameManager/GameManager.java
new file mode 100644
index 0000000..71bbed8
--- /dev/null
+++ b/DesktopUI/src/desktopUI/GameManager/GameManager.java
@@ -0,0 +1,435 @@
+package desktopUI.GameManager;
+
+import desktopUI.Controller.Controller;
+import desktopUI.TaskDialog.TaskDialog;
+import desktopUI.scoreDetail.ScoreDetailController;
+import desktopUI.scoreDetail.WordDetails;
+import desktopUI.userInfo.UserInfoController;
+import desktopUI.utils.Common;
+import engine.ComputerTask;
+import engine.GameEngine;
+import engine.GameEngine.CaptureTheMoment;
+import engine.Player;
+import engine.exceptions.*;
+import javafx.application.Platform;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Button;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.stage.Stage;
+import javafx.util.Pair;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class GameManager {
+    private int currentDiceValue;
+    private int tryNumber = 1;
+    private short currentPlayerId;
+    private boolean isFishMod;
+
+    private GameEngine gameEngine;
+    private Controller controller;
+
+    public GameManager(Controller controller) {
+        this.controller = controller;
+         gameEngine = new GameEngine();
+    }
+
+    public Boolean getIsFishMod() {
+        return isFishMod;
+    }
+
+    public int getCurrentDiceValue() {
+        return currentDiceValue;
+    }
+
+    public void setCurrentDiceValue(int currentDiceValue) {
+        this.currentDiceValue = currentDiceValue;
+    }
+
+    public Map<Short, UserInfoController> getDataPlayers(Pane node){
+        Map<Short, UserInfoController> controllersMap = new HashMap<>();
+        URL infoFXML = getClass().getResource("/desktopUI/userInfo/UserInfo.fxml");
+        for(Player player : gameEngine.getPlayers()) {
+            FXMLLoader loader = new FXMLLoader();
+            loader.setLocation(infoFXML);
+            HBox root = null;
+            try {
+                root = loader.load();
+            }
+            catch (IOException e) {
+                Common.showError("Unable to load user nfo");
+            }
+            UserInfoController userInfoController = loader.getController();
+            userInfoController.setGameManager(this);
+            userInfoController.setIdProperty(player.getId());
+            userInfoController.setNameProperty(player.getName());
+            userInfoController.setPlayerTypeProperty(player.getType());
+            userInfoController.setScoreProperty(player.getScore());
+            controllersMap.put(player.getId(), userInfoController);
+            node.getChildren().add(root);
+        }
+        return controllersMap;
+    }
+
+    public String getInitInfoGame(){
+        //TODO: add the total amount of kupa tiles in the information!
+        return String.format(
+                "Size Board: %d x %d\n" + "\n" +
+                "Score type: %s \n" + "\n" +
+                "Gold Fish Mod: %s\n" + "\n" +
+                "Top ten rare words: \n %s" + "\n" +
+                "Frequency for each letter:\n %s",
+                gameEngine.getBoardSize(), gameEngine.getBoardSize(),
+                gameEngine.getWinScoreMod(),
+                gameEngine.isInGoldFishMod().toString(),
+                gameEngine.getTopTenRareWords(),
+                gameEngine.getFreqEachLetter());
+    }
+
+    public int getMaxTries() {
+        return gameEngine.getMaxRetries();
+    }
+
+    public GameEngine getGameEngine(){return gameEngine;}
+
+    public void loadXML(File xmlFile){
+        new Thread(() -> {
+            try {
+                gameEngine.loadXml(xmlFile.getPath());
+                Platform.runLater(() -> controller.initGame());
+            }
+            catch(WrongPathException e) {
+                Common.showError("Wrong path to Xml file!");
+            }
+            catch(DictionaryNotFoundException e) {
+                Common.showError("There is not dictionary file name \"" + e.getFileName() + "\"!");
+            }
+            catch(BoardSizeException e) {
+                Common.showError("Invalid board size!\n" +
+                        "Min size: " + e.getMinSize() + "\n" +
+                        "Max size: " + e.getMaxSize() + "\n" +
+                        "Actual size: " + e.getSize());
+            }
+            catch(NotXmlFileException e) {
+                Common.showError("This is not an XML file! ");
+            }
+            catch(DuplicateLetterException e) {
+                Common.showError("The letter \'" + e.getLetter() + "\' has a duplicate entry!");
+            }
+            catch(NotValidXmlFileException e) {
+                Common.showError("Not valid Xml file!");
+            }
+            catch(WinTypeException e) {
+                Common.showError("Win mod \"" + e.getWinType() + "\" is not supported!");
+            }
+            catch(NotEnoughLettersException e) {
+                Common.showError("Not enough letters!\n" +
+                        "Need " + e.getExpectedAmount() + " but only have " + e.getCurrentAmount());
+            }
+            catch (NumberOfPlayersException e) {
+                Common.showError("Number of players needs to be between " + e.getMinPlayers() + " to " +
+                            e.getMaxPlayers() + ", and you entered "  + e.getActualNumOfPlayers() + "!");
+            }
+            catch (DuplicatePlayerIdException e) {
+                Common.showError("Duplicate Id player Error!\n" +
+                        "ID number " + e.getDuplicateId() + " is duplicated!");
+        }}).start();
+    }
+
+    public short startGame() {
+        gameEngine.startGame();
+        currentPlayerId = gameEngine.getCurrentPlayerId();
+        isFishMod = gameEngine.getCurrentGameData().getGoldFishMod();
+        updateTurnNumber();
+        return currentPlayerId;
+    }
+
+    public void showWords(int playerId, ScoreDetailController scoreDetailController) {
+        scoreDetailController.setIsCapitalist(gameEngine.isWordScore());
+        long totalWords = 0;
+        Map<String, Pair<Integer, Integer>> words = gameEngine.getPlayerWords(playerId);
+        for (Map.Entry<String, Pair<Integer, Integer>> entry: words.entrySet()) {
+            scoreDetailController.getWords().add(new WordDetails(entry.getKey(), entry.getValue().getKey(), entry.getValue().getValue()));
+            totalWords += entry.getValue().getKey();
+        }
+        scoreDetailController.setWordsAmount(totalWords);
+    }
+
+    public void getDiceValue(SimpleIntegerProperty diceValue) {
+        diceValue.set(gameEngine.getDiceValue());
+    }
+
+    public void setUnclickableButtons(List<Button> stayClickableButtons, List<Button> allBoardButtons){
+        for(Button button : allBoardButtons){
+            if(stayClickableButtons.contains(button)){
+                button.setDisable(false);
+            }
+            else if (!button.getText().equals("")) {
+                button.setDisable(false);
+            }
+            else
+                button.setDisable(true);
+        }
+    }
+
+    public void setDefaultStyle(List<Button> buttonsList){
+        for(Button button : buttonsList){
+            button.setStyle("");
+        }
+    }
+
+    public void updateBoard(List<int[]> selectedButtonsPoints) {
+        boolean enoughTiles;
+        try {
+            enoughTiles = gameEngine.updateBoard(selectedButtonsPoints);
+        } catch (OutOfBoardBoundariesException e) {
+            Common.showError("How did you managed to select one tile out of boundaries?");
+            return;
+        }
+        if (enoughTiles) {
+
+            char[][] board = gameEngine.getBoard();
+            Platform.runLater(() -> controller.updateBoard(board));
+        }
+        else {
+            Common.showError("You chose too many tiles! you need to choose only " + currentDiceValue + " tiles \n\nTry again.");
+
+        }
+    }
+
+    public void retire() {
+        if (gameEngine.isStarted()) {
+            if (gameEngine.retirePlayer()) {
+                short retiredId = currentPlayerId;
+                controller.playerRetired(retiredId, true);
+                nextTurn(false);
+            } else {
+                controller.endOfGameStatus();
+            }
+        }
+    }
+
+    public void exitGame() {
+        Platform.exit();
+    }
+
+    private void updateTurnNumber() {
+        int turn = gameEngine.getStatistics().getNumOfTurns();
+        Platform.runLater(() -> controller.getTurnProperty().set(turn));
+    }
+    private void updateTurnNumber(int turnNum) {
+        Platform.runLater(() -> controller.getTurnProperty().set(turnNum));
+    }
+
+    private void updatePlayerScore() {
+        Map<Short, UserInfoController> userInfoControllerMap = controller.getUserInfoMap();
+        List<Player> players = gameEngine.getPlayers();
+        for (Player player: players) {
+            if (player.getId() == currentPlayerId) {
+                Platform.runLater(() -> userInfoControllerMap.get(player.getId()).setScoreProperty(player.getScore()));
+                break;
+            }
+        }
+    }
+
+    public String buttonsToStr(List<Button>letters, char [][]signs) {
+
+        // int sizeListButtons = letters.size();
+        //  List<Character> word = new ArrayList<>();
+        StringBuilder word = new StringBuilder();
+        for (Button letter : letters) {
+            int sizeIdButton = letter.getId().length();
+            String id = letter.getId();
+            int col = id.getBytes()[sizeIdButton - 1] - 48 - 1;
+            int row = id.getBytes()[sizeIdButton - 2] - 48 - 1;
+            char sign = signs[row][col];
+            word.append(sign);
+        }
+        return  word.toString();
+    }
+
+    //check if ita a good word and calc score if necessary
+    public void checkWord(String word) {
+        Alert alert;
+        switch (gameEngine.isWordValidWithCoordinates(word, tryNumber, new ArrayList<>(controller.getBoard().getPressedButtonsIndices()))) {
+            case CORRECT:
+                alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("Check Word");
+                alert.setContentText("Well done! your word \"" + word + "\" is correct!!!");
+                // should no be here
+                // removeWordFromBoard();
+                alert.setHeaderText(null);
+                alert.showAndWait();
+                nextTurn(true);
+                break;
+            case WRONG:
+                alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("Check Word");
+                alert.setContentText("Uhh.. the word \"" + word + "\" is wrong!!!");
+                alert.setHeaderText(null);
+                alert.showAndWait();
+                tryNumber++;
+                controller.getTryNumberProperty().set(tryNumber);
+                break;
+            case TRIES_DEPLETED:
+                alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("Check Word");
+                alert.setContentText("Oops.. you have got No more tries!!");
+                alert.setHeaderText(null);
+                alert.showAndWait();
+                nextTurn(false);
+                break;
+            case CHARS_NOT_PRESENT:
+                alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("Check Word");
+                alert.setContentText("Oops.. you enter INVALID chars!");
+                alert.setHeaderText(null);
+                alert.showAndWait();
+                tryNumber++;
+                controller.getTryNumberProperty().set(tryNumber);
+                break;
+            case WRONG_CANT_RETRY:
+                alert = new Alert(Alert.AlertType.INFORMATION);
+                alert.setTitle("Check Word");
+                alert.setContentText("Uhh..This word is Wrong.\nThat was your last try..  !");
+                alert.setHeaderText(null);
+                alert.showAndWait();
+                nextTurn(false);
+                break;
+        }
+    }
+
+    private void switchUser() {
+        short newId = gameEngine.getCurrentPlayerId();
+        short prevId;
+        if (newId != currentPlayerId) {
+            prevId = currentPlayerId;
+            Platform.runLater(() -> controller.selectPlayer(prevId, newId));
+            currentPlayerId = newId;
+        }
+        else {
+            controller.checkComputer();
+        }
+    }
+
+    public boolean isPlayerComputer() {
+        return gameEngine.isPlayerComputer();
+    }
+
+    public void runComputer() {
+        FXMLLoader loader = new FXMLLoader();
+        URL infoFXML = getClass().getResource("/desktopUI/TaskDialog/TaskDialog.fxml");
+        loader.setLocation(infoFXML);
+        AnchorPane root;
+        try {
+            root = loader.load();
+        }
+        catch (IOException e) {
+            Common.showError("Unable to show progress window");
+            return;
+        }
+
+
+        Stage stage = new Stage();
+        stage.setTitle("Computer Run - Wordiada");
+        stage.setScene(new Scene(root));
+
+        controller.getDiceButton().setDisable(true);
+        ComputerTask computerTask = new ComputerTask(gameEngine.getCurrentPlayer(), gameEngine);
+        TaskDialog taskDialog = loader.getController();
+        taskDialog.textProperty().bind(computerTask.messageProperty());
+        taskDialog.progressProperty().bind(computerTask.progressProperty());
+        /*taskDialog.setRetire(() -> {
+                retire();
+                return null;
+            });*/
+        computerTask.setOnSucceeded(workerStateEvent -> {
+            Platform.runLater(() -> {
+                stage.hide();
+                stage.close();
+                controller.resetBoard(gameEngine.getBoard());
+            });
+            nextTurn(computerTask.getValue());
+        });
+        new Thread(computerTask).start();
+        stage.show();
+    }
+
+    private void nextTurn(boolean clearButtons) {
+        tryNumber = 1;
+        updatePlayerScore();
+        if (gameEngine.isGameEnded()) {
+            controller.endOfGameStatus();
+        }
+        else {
+            switchUser();
+            updateTurnNumber();
+            Platform.runLater(() -> controller.resetTurn(clearButtons));
+        }
+    }
+
+    /*
+    // should not be here
+    public void removeWordFromBoard(){
+        List<Point> lettersToRemove = controller.getBoard().fromSingleLetterToPoint();
+        gameEngine.getBoardObject().removeLettersFromBoard(lettersToRemove);
+        //update turn info
+        // gameEngine.saveTheTurn(controller.getBoard().getPressedButtons());
+    }
+    */
+
+    public void reset() {
+        new Thread(() -> {
+            gameEngine.reset();
+            tryNumber = 1;
+            Platform.runLater(() -> {
+                controller.initGame();
+                controller.playTurn();
+            });
+        }).start();
+    }
+
+    private void setTurnValues(CaptureTheMoment turnValues){
+        if (turnValues != null) {
+            updateTurnNumber(turnValues.getTurnNumber());
+            updatePlayerScore();
+            updateRetires(turnValues.getPlayers());
+            switchUser();
+            Platform.runLater(() -> controller.savedBoardUpdate(turnValues.getBoard(), turnValues.getSelectedBoardButtons()));
+        }
+        else {
+            Platform.runLater(() -> controller.getNextButton().setDisable(true));
+        }
+    }
+
+    public void prevSaveData() {
+        setTurnValues(gameEngine.prevSaveData());
+        if (!gameEngine.havePrevSave()) {
+            controller.getPrevButton().setDisable(true);
+        }
+    }
+    public void nextSaveData() {
+        setTurnValues(gameEngine.nextSaveData());
+        if (!gameEngine.haveNextSave()) {
+            controller.getNextButton().setDisable(true);
+        }
+    }
+
+    private void updateRetires(List<Player> players) {
+        for (Player player: players) {
+            Platform.runLater(() -> controller.playerRetired(player.getId(), player.isRetired()));
+        }
+    }
+}
+
diff --git a/DesktopUI/src/desktopUI/Main.java b/DesktopUI/src/desktopUI/Main.java
new file mode 100644
index 0000000..7f68baa
--- /dev/null
+++ b/DesktopUI/src/desktopUI/Main.java
@@ -0,0 +1,47 @@
+package desktopUI;
+
+import desktopUI.Controller.Controller;
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.layout.BorderPane;
+import javafx.stage.Stage;
+
+
+import java.net.URL;
+
+public class Main extends Application {
+
+    @Override
+    public void start(Stage primaryStage) throws Exception {
+
+        FXMLLoader loader = new FXMLLoader();
+        URL mainFXML = getClass().getResource("desktopUI.fxml");
+        loader.setLocation(mainFXML);
+        BorderPane root = loader.load();
+        Controller controller = loader.getController();
+        controller.setPrimaryStage(primaryStage);
+        primaryStage.setTitle("Wordiada");
+        primaryStage.setScene(new Scene(root));
+        primaryStage.setMinHeight(root.getMinHeight());
+        primaryStage.setMinWidth(root.getMinWidth());
+        primaryStage.show();
+    }
+
+
+    public static void main(String[] args) {
+        launch(args);
+      //  Application.launch(Main.class, args);
+           // Application.launch(args);
+    }
+
+    /*
+    public void actionPerformed(ActionEvent e) {
+        String actionCommand = ((JButton) e.getSource()).getActionCommand();
+        if (actionCommand == "Load XML")
+            c.showPlayersData();
+    }*/
+
+
+
+}
diff --git a/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.fxml b/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.fxml
new file mode 100644
index 0000000..79d6382
--- /dev/null
+++ b/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.fxml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ProgressBar?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.HBox?>
+
+<AnchorPane nodeOrientation="LEFT_TO_RIGHT" prefHeight="150.0" prefWidth="250.0" xmlns="http://javafx.com/javafx/8.0.112" xmlns:fx="http://javafx.com/fxml/1" fx:controller="desktopUI.TaskDialog.TaskDialog">
+   <Label fx:id="messageLabel" layoutX="14.0" layoutY="14.0" text="Label" />
+   <HBox alignment="CENTER" layoutY="75.0" prefHeight="18.0" prefWidth="619.0">
+      <Label text="Progress" />
+      <ProgressBar fx:id="progressBar" prefHeight="18.0" prefWidth="485.0" progress="0.0" />
+   </HBox>
+   <Separator layoutY="110.0" prefHeight="0.0" prefWidth="619.0" />
+   <Button fx:id="cancelButton" layoutX="567.0" layoutY="113.0" mnemonicParsing="false" text="Cancel" onAction="#onCancel" />
+</AnchorPane>
diff --git a/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.java b/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.java
new file mode 100644
index 0000000..5dc8051
--- /dev/null
+++ b/DesktopUI/src/desktopUI/TaskDialog/TaskDialog.java
@@ -0,0 +1,41 @@
+package desktopUI.TaskDialog;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.ProgressBar;
+
+import java.util.concurrent.Callable;
+
+public class TaskDialog {
+    @FXML private Label messageLabel;
+    @FXML private ProgressBar progressBar;
+
+    private Callable<Void> retire;
+
+    public TaskDialog() {
+    }
+
+    public StringProperty textProperty() {
+        return messageLabel.textProperty();
+    }
+
+    public DoubleProperty progressProperty() {
+        return progressBar.progressProperty();
+    }
+
+    public void setRetire(Callable<Void> retire) {
+        this.retire = retire;
+    }
+
+    @FXML
+    public void onCancel() {
+        try {
+            retire.call();
+        }
+        catch (Exception e) {
+
+        }
+    }
+}
diff --git a/DesktopUI/src/desktopUI/Tile/SingleLetterController.java b/DesktopUI/src/desktopUI/Tile/SingleLetterController.java
new file mode 100644
index 0000000..9534168
--- /dev/null
+++ b/DesktopUI/src/desktopUI/Tile/SingleLetterController.java
@@ -0,0 +1,41 @@
+package desktopUI.Tile;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+
+public class SingleLetterController {
+
+    @FXML private Button letterButton;
+    private SimpleStringProperty letterProperty;
+
+
+
+
+    public SingleLetterController(Button button) {
+        letterProperty = new SimpleStringProperty();
+        letterButton = button;
+
+    }
+
+    @FXML
+    public void initialize() {
+        letterButton.textProperty().bind(letterProperty);
+        letterProperty.set("");
+        //scoreLabel.textProperty().bind(Bindings.format("(%d)", scoreProperty));
+    }
+
+    public void setLetter(String letter) {
+        letterProperty.set(letter);
+    }
+
+    public SimpleStringProperty getLetterProperty() {
+        return letterProperty;
+    }
+
+    public Button getLetterButton() {
+        return letterButton;
+    }
+
+
+}
diff --git a/DesktopUI/src/desktopUI/Tile/Tile.fxml b/DesktopUI/src/desktopUI/Tile/Tile.fxml
new file mode 100644
index 0000000..a471fef
--- /dev/null
+++ b/DesktopUI/src/desktopUI/Tile/Tile.fxml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.HBox?>
+
+
+<HBox prefHeight="16.0" prefWidth="32.0" xmlns="http://javafx.com/javafx/8.0.112" xmlns:fx="http://javafx.com/fxml/1" fx:controller="desktopUI.Tile.Tile">
+   <children>
+      <Label fx:id="letterLabel" text="A" />
+      <Label fx:id="scoreLabel" text="(50)" />
+   </children>
+   <padding>
+      <Insets left="2.0" />
+   </padding>
+</HBox>
diff --git a/DesktopUI/src/desktopUI/desktopUI.fxml b/DesktopUI/src/desktopUI/desktopUI.fxml
new file mode 100644
index 0000000..d5d1ef1
--- /dev/null
+++ b/DesktopUI/src/desktopUI/desktopUI.fxml
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.control.SplitPane?>
+<?import javafx.scene.effect.ColorAdjust?>
+<?import javafx.scene.layout.AnchorPane?>
+<?import javafx.scene.layout.BorderPane?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.RowConstraints?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.text.Font?>
+
+<BorderPane minHeight="541.0" minWidth="800.0" prefHeight="401.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8.0.112" xmlns:fx="http://javafx.com/fxml/1" fx:controller="desktopUI.Controller.Controller">
+   <top>
+      <Label text="Wordiada" BorderPane.alignment="CENTER">
+         <font>
+            <Font name="Aharoni Bold" size="34.0" />
+         </font>
+      </Label>
+   </top>
+   <left>
+      <VBox fx:id="buttonsVBox" alignment="TOP_CENTER" minHeight="-Infinity" minWidth="-Infinity" prefHeight="200.0" prefWidth="130.0" spacing="10.0" BorderPane.alignment="CENTER">
+        <Button fx:id="loadXmlButton" alignment="TOP_CENTER" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#loadXmlFile" prefHeight="30.0" prefWidth="110.0" text="Load XML">
+           <VBox.margin>
+              <Insets />
+           </VBox.margin></Button>
+        <Button fx:id="startButton" disable="true" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#playTurn" prefHeight="30.0" prefWidth="110.0" text="Start Game">
+           <VBox.margin>
+              <Insets />
+           </VBox.margin>
+        </Button><Button fx:id="diceButton" disable="true" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#throwDie" prefHeight="30.0" prefWidth="110.0" text="Throw Die">
+           <VBox.margin>
+              <Insets />
+           </VBox.margin></Button>
+        <Button fx:id="moveButton" disable="true" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#makeMove" prefHeight="30.0" prefWidth="110.0" text="Make a move">
+           <VBox.margin>
+              <Insets />
+           </VBox.margin></Button>
+        <Button fx:id="checkWord" disable="true" mnemonicParsing="false" onAction="#checkWord" prefHeight="31.0" prefWidth="110.0" text="Check Word" />
+        <Button fx:id="retireButton" disable="true" mnemonicParsing="false" onAction="#retire" prefHeight="31.0" prefWidth="110.0" text="Retire" />
+        <Button fx:id="exitButton" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#exitGame" prefHeight="30.0" prefWidth="110.0" text="Exit">
+           <VBox.margin>
+              <Insets />
+           </VBox.margin>
+        </Button>
+        <Button fx:id="helpButton" onAction="#help" text="?" />
+        <Button fx:id="newGameButton" mnemonicParsing="false" text="New Game" onAction="#loadNewXmlFile" visible="false" />
+        <Button fx:id="playAgainButton" mnemonicParsing="false" text="Play Again" onAction="#playAgain" visible="false" />
+        <Button fx:id="prevButton" mnemonicParsing="false" text="Prev" onAction="#prev" visible="false" />
+        <Button fx:id="nextButton" mnemonicParsing="false" text="Next" onAction="#next" visible="false" />
+      </VBox>
+   </left>
+   <center>
+       <VBox>
+         <ScrollPane fx:id="boardScrollPane" minHeight="450.0" minWidth="443.0" BorderPane.alignment="CENTER">
+           <GridPane fx:id="boardPane">
+             <columnConstraints>
+               <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" />
+             </columnConstraints>
+             <rowConstraints>
+               <RowConstraints minHeight="10.0" vgrow="SOMETIMES" />
+             </rowConstraints>
+           </GridPane>
+         </ScrollPane>
+         <GridPane alignment="BOTTOM_CENTER" minHeight="55.0" maxHeight="60.0" prefHeight="55.0">
+           <columnConstraints>
+             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+           </columnConstraints>
+           <rowConstraints>
+             <RowConstraints minHeight="10.0" vgrow="SOMETIMES" />
+             <RowConstraints minHeight="10.0" vgrow="SOMETIMES" />
+             <RowConstraints minHeight="10.0" vgrow="SOMETIMES" />
+             <RowConstraints minHeight="10.0" vgrow="SOMETIMES" />
+           </rowConstraints>
+           <Label text="Turn No." />
+           <Label fx:id="turnNumberLabel" text="0" GridPane.columnIndex="1" />
+           <Label text="Try No." GridPane.rowIndex="2" />
+           <Label fx:id="tryNumberLabel" text="0" GridPane.columnIndex="1" GridPane.rowIndex="2" />
+           <Label text="Total tries" GridPane.rowIndex="1" />
+           <Label fx:id="totalTriesLabel" text="0" GridPane.columnIndex="1" GridPane.rowIndex="1" />
+           <Label text="Dice value:" GridPane.columnIndex="2" />
+           <Label fx:id="diceValueLabel" GridPane.columnIndex="3" />
+           <Label text="Word:" GridPane.columnIndex="2" GridPane.rowIndex="1" />
+           <Label fx:id="buildWordLabel" text="word" GridPane.columnIndex="3" GridPane.rowIndex="1" />
+         </GridPane>
+       </VBox>
+   </center>
+   <right>
+      <SplitPane dividerPositions="0.5" minHeight="-Infinity" minWidth="-Infinity" orientation="VERTICAL" prefHeight="360.0" prefWidth="227.0" BorderPane.alignment="CENTER">
+        <ScrollPane layoutX="-1.0">
+            <VBox>
+               <Label fx:id="titlePlayerData" underline="true">
+                   <padding>
+                       <Insets left="10.0" />
+                   </padding>
+                   <effect>
+                       <ColorAdjust brightness="0.27" contrast="1.0" />
+                   </effect>
+               </Label>
+                <!--
+                <HBox spacing="5.0">
+                    <Label text="Turn No." />
+                    <Label fx:id="turnNumber" text="0" />
+                </HBox>
+                <HBox spacing="5.0">
+                    <Label fx:id="player1" text="Player" />
+                    <Label fx:id="notAvailable" text="N/A" />
+                </HBox>
+                -->
+               <VBox fx:id="playerVBox" />
+            </VBox>
+        </ScrollPane>
+        <ScrollPane layoutX="1.0" layoutY="5.0">
+            <AnchorPane>
+                <Label fx:id="initInfoGame" layoutY="33.0" />
+                <Label fx:id="titleInfoGame" layoutX="12.0" prefHeight="21.0" textAlignment="CENTER" underline="true">
+                  <effect>
+                      <ColorAdjust brightness="0.27" contrast="1.0" />
+                  </effect></Label>
+            </AnchorPane>
+        </ScrollPane>
+      </SplitPane>
+   </right>
+</BorderPane>
diff --git a/DesktopUI/src/desktopUI/scoreDetail/ScoreDetail.fxml b/DesktopUI/src/desktopUI/scoreDetail/ScoreDetail.fxml
new file mode 100644
index 0000000..ed01e66
--- /dev/null
+++ b/DesktopUI/src/desktopUI/scoreDetail/ScoreDetail.fxml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.control.TableColumn?>
+<?import javafx.scene.control.TableView?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.control.cell.*?>
+
+<VBox prefHeight="300.0" xmlns="http://javafx.com/javafx/8.0.112" xmlns:fx="http://javafx.com/fxml/1" fx:controller="desktopUI.scoreDetail.ScoreDetailController">
+  <HBox>
+    <Label text="Number of words:" />
+    <Label fx:id="wordCountLabel" text="0">
+       <HBox.margin>
+          <Insets left="5.0" />
+       </HBox.margin>
+    </Label>
+    <VBox.margin>
+        <Insets bottom="5.0" left="5.0" top="5.0" />
+    </VBox.margin>
+  </HBox>
+  <Separator prefWidth="200.0" />
+  <TableView fx:id="wordsTableView">
+    <columns>
+      <TableColumn text="Word">
+         <cellValueFactory><PropertyValueFactory property="word" />
+         </cellValueFactory>
+      </TableColumn>
+      <TableColumn text="Amount">
+         <cellValueFactory><PropertyValueFactory property="amount" />
+         </cellValueFactory>
+      </TableColumn>
+      <TableColumn fx:id="scoreTableColumn" text="Score">
+         <cellValueFactory><PropertyValueFactory property="score" />
+         </cellValueFactory>
+      </TableColumn>
+    </columns>
+  </TableView>
+</VBox>
diff --git a/DesktopUI/src/desktopUI/scoreDetail/ScoreDetailController.java b/DesktopUI/src/desktopUI/scoreDetail/ScoreDetailController.java
new file mode 100644
index 0000000..b49e5d5
--- /dev/null
+++ b/DesktopUI/src/desktopUI/scoreDetail/ScoreDetailController.java
@@ -0,0 +1,45 @@
+package desktopUI.scoreDetail;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleLongProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+
+public class ScoreDetailController {
+    @FXML private Label wordCountLabel;
+    @FXML private TableView<WordDetails> wordsTableView;
+    @FXML private TableColumn scoreTableColumn;
+    private ObservableList<WordDetails> data;
+    private SimpleLongProperty wordsCountProperty;
+    private SimpleBooleanProperty isCapitalistProperty;
+
+    public ScoreDetailController() {
+        data = FXCollections.observableArrayList();
+        wordsCountProperty = new SimpleLongProperty();
+        isCapitalistProperty = new SimpleBooleanProperty(false);
+    }
+
+    public void initialize() {
+        wordCountLabel.textProperty().bind(Bindings.format("%,d", wordsCountProperty));
+        scoreTableColumn.visibleProperty().bind(isCapitalistProperty);
+        wordsTableView.setItems(data);
+        wordsTableView.setPlaceholder(new Label("The user don't have words"));
+    }
+
+    public void setWordsAmount(long amount) {
+        wordsCountProperty.set(amount);
+    }
+
+    public ObservableList<WordDetails> getWords() {
+        return data;
+    }
+
+    public void setIsCapitalist(boolean isCapitalist) {
+        isCapitalistProperty.set(isCapitalist);
+    }
+}
diff --git a/DesktopUI/src/desktopUI/scoreDetail/WordDetails.java b/DesktopUI/src/desktopUI/scoreDetail/WordDetails.java
new file mode 100644
index 0000000..80f5e47
--- /dev/null
+++ b/DesktopUI/src/desktopUI/scoreDetail/WordDetails.java
@@ -0,0 +1,29 @@
+package desktopUI.scoreDetail;
+
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleLongProperty;
+import javafx.beans.property.SimpleStringProperty;
+
+public class WordDetails {
+    private final SimpleStringProperty word = new SimpleStringProperty();
+    private final SimpleLongProperty amount = new SimpleLongProperty();
+    private final SimpleIntegerProperty score = new SimpleIntegerProperty();
+
+    public WordDetails(String word, long amount, int score) {
+        this.word.set(word);
+        this.amount.set(amount);
+        this.score.set(score);
+    }
+
+    public String getWord() {
+        return word.get();
+    }
+
+    public long getAmount() {
+        return amount.get();
+    }
+
+    public int getScore() {
+        return score.get();
+    }
+}
\ No newline at end of file
diff --git a/DesktopUI/src/desktopUI/userInfo/StrikeThrough.css b/DesktopUI/src/desktopUI/userInfo/StrikeThrough.css
new file mode 100644
index 0000000..89236fa
--- /dev/null
+++ b/DesktopUI/src/desktopUI/userInfo/StrikeThrough.css
@@ -0,0 +1,3 @@
+.label .text {
+    -fx-strikethrough: true;
+}
\ No newline at end of file
diff --git a/DesktopUI/src/desktopUI/userInfo/UserInfo.fxml b/DesktopUI/src/desktopUI/userInfo/UserInfo.fxml
new file mode 100644
index 0000000..592931a
--- /dev/null
+++ b/DesktopUI/src/desktopUI/userInfo/UserInfo.fxml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.HBox?>
+
+<HBox fx:id="userInfoHBox" alignment="CENTER" spacing="3.0" xmlns="http://javafx.com/javafx/8.0.112" xmlns:fx="http://javafx.com/fxml/1" fx:controller="desktopUI.userInfo.UserInfoController">
+  <Label fx:id="nameLabel" text="name" />
+  <Label text="ID:" />
+  <Label fx:id="idLabel" text="ID#" />
+  <Label fx:id="playerTypeLabel" text="type" />
+  <Label text="Score:" />
+  <Label fx:id="scoreLabel" text="score#" />
+  <Button fx:id="detailsButton" disable="true" mnemonicParsing="false" text="Details" onAction="#showWords" />
+</HBox>
diff --git a/DesktopUI/src/desktopUI/userInfo/UserInfoController.java b/DesktopUI/src/desktopUI/userInfo/UserInfoController.java
new file mode 100644
index 0000000..f7e294d
--- /dev/null
+++ b/DesktopUI/src/desktopUI/userInfo/UserInfoController.java
@@ -0,0 +1,108 @@
+package desktopUI.userInfo;
+
+import com.sun.javafx.beans.IDProperty;
+import desktopUI.GameManager.GameManager;
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.SimpleFloatProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+
+import java.net.URL;
+
+public class UserInfoController {
+    @FXML private HBox userInfoHBox;
+    @FXML private Label nameLabel;
+    @FXML private Label idLabel;
+    @FXML private Label playerTypeLabel;
+    @FXML private Label scoreLabel;
+    @FXML private Button detailsButton;
+
+    private SimpleStringProperty nameProperty;
+    private SimpleStringProperty playerTypeProperty;
+    private SimpleIntegerProperty idProperty;
+    private SimpleFloatProperty scoreProperty;
+    private SimpleStringProperty styleProperty;
+
+    private GameManager gameManager;
+
+    public UserInfoController() {
+        nameProperty = new SimpleStringProperty();
+        playerTypeProperty = new SimpleStringProperty();
+        idProperty = new SimpleIntegerProperty();
+        scoreProperty = new SimpleFloatProperty();
+        styleProperty = new SimpleStringProperty();
+    }
+
+    public void setGameManager(GameManager gameManager) {
+        this.gameManager = gameManager;
+    }
+
+    @FXML
+    public void initialize() {
+        nameLabel.textProperty().bind(nameProperty);
+        idLabel.textProperty().bind(Bindings.format("%d", idProperty));
+        playerTypeLabel.textProperty().bind(Bindings.format("(%s)", playerTypeProperty));
+        scoreLabel.textProperty().bind(Bindings.format("%.1f", scoreProperty));
+        nameLabel.styleProperty().bind(styleProperty);
+        idLabel.styleProperty().bind(styleProperty);
+        playerTypeLabel.styleProperty().bind(styleProperty);
+        scoreLabel.styleProperty().bind(styleProperty);
+    }
+
+    public void setNameProperty(String nameProperty) {
+        this.nameProperty.set(nameProperty);
+    }
+
+    public void setPlayerTypeProperty(String playerTypeProperty) {
+        this.playerTypeProperty.set(playerTypeProperty);
+    }
+
+    public void setIdProperty(int idProperty) {
+        this.idProperty.set(idProperty);
+    }
+
+    public void setScoreProperty(float scoreProperty) {
+        this.scoreProperty.set(scoreProperty);
+    }
+
+    public void setStyleProperty(String styleProperty) {
+        this.styleProperty.set(styleProperty);
+    }
+
+    public void disableDetailsButton(boolean isDisable) {
+        detailsButton.setDisable(isDisable);
+    }
+
+    @FXML
+    public void showWords() throws Exception {
+        FXMLLoader loader = new FXMLLoader();
+        URL mainFXML = getClass().getResource("/desktopUI/scoreDetail/ScoreDetail.fxml");
+        loader.setLocation(mainFXML);
+        VBox root = loader.load();
+
+        gameManager.showWords(idProperty.get(), loader.getController());
+
+        Stage stage = new Stage();
+        stage.setTitle("Player Words - Wordiada");
+        stage.setScene(new Scene(root));
+        stage.show();
+    }
+
+    public void setStrikeThrough(boolean set) {
+        String css = getClass().getResource("/desktopUI/userInfo/StrikeThrough.css").toExternalForm();
+        if (set) {
+            userInfoHBox.getStylesheets().addAll(css);
+        }
+        else {
+            userInfoHBox.getStylesheets().removeAll(css);
+        }
+    }
+}
diff --git a/DesktopUI/src/desktopUI/utils/Common.java b/DesktopUI/src/desktopUI/utils/Common.java
new file mode 100644
index 0000000..84121ee
--- /dev/null
+++ b/DesktopUI/src/desktopUI/utils/Common.java
@@ -0,0 +1,27 @@
+package desktopUI.utils;
+
+import javafx.application.Platform;
+import javafx.scene.control.Alert;
+
+public class Common {
+    public static void showError(String error) {
+        Platform.runLater(() -> {
+            Alert alert = new Alert(Alert.AlertType.ERROR);
+            alert.setHeaderText(null);
+            alert.setContentText(error);
+            alert.showAndWait();
+        });
+    }
+
+
+    //TODO: change all the code areas i used this func without call it
+    public static void showMessage(String title, String message, Alert.AlertType type){
+        Platform.runLater(() -> {
+            Alert alert = new Alert(type);
+            alert.setTitle(title);
+            alert.setContentText(message);
+            alert.setHeaderText(null);
+            alert.showAndWait();
+        });
+    }
+}
diff --git a/DesktopUI/src/desktopUI/utils/HelperFuncs.java b/DesktopUI/src/desktopUI/utils/HelperFuncs.java
new file mode 100644
index 0000000..cd9686b
--- /dev/null
+++ b/DesktopUI/src/desktopUI/utils/HelperFuncs.java
@@ -0,0 +1,11 @@
+package desktopUI.utils;
+
+import engine.Player;
+
+import java.util.List;
+
+//TODO: remove here all the funcs with the notes to move to a static class
+public class HelperFuncs {
+
+
+}
diff --git a/DesktopUI/src/desktopUI/view/Board.java b/DesktopUI/src/desktopUI/view/Board.java
new file mode 100644
index 0000000..e45e47f
--- /dev/null
+++ b/DesktopUI/src/desktopUI/view/Board.java
@@ -0,0 +1,8 @@
+package desktopUI.view;
+
+
+import javafx.scene.layout.GridPane;
+
+public class Board  extends GridPane {
+
+}
diff --git a/GameEngine/src/META-INF/MANIFEST.MF b/GameEngine/src/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..59499bc
--- /dev/null
+++ b/GameEngine/src/META-INF/MANIFEST.MF
@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+
diff --git a/GameEngine/src/engine/Board.java b/GameEngine/src/engine/Board.java
index a105000..5d1991c 100644
--- a/GameEngine/src/engine/Board.java
+++ b/GameEngine/src/engine/Board.java
@@ -3,6 +3,9 @@
 import engine.exceptions.OutOfBoardBoundariesException;
 import engine.jaxb.schema.generated.Letter;
 
+import javax.xml.soap.Node;
+import java.awt.*;
+import java.util.List;
 import java.util.Random;
 import java.util.HashMap;
 import java.util.Map;
@@ -10,7 +13,7 @@
 
 public class Board {
 
-    public static class Point{
+      static class Point{
         private int x;
         private int y;
 
@@ -73,7 +76,7 @@ public class Cell{
     static final short MAX_SIZE = 50;
     static final short MIN_SIZE = 5;
 
-    char[][] getBoard_onlySigns() {
+    public char[][] getBoard_onlySigns() {
         char[][] board = new char[size][size];
         for (int row = 0; row < size; row++) {
             for (int col = 0; col < size; col++) {
@@ -82,9 +85,19 @@ char[][] getBoard_onlySigns() {
         }
         return board;
     }
+    public Cell [][] getBoardFullDetails(){
+        return board;
+    }
 
-    Cell[][] getFullBoardDetails(){return board;}
-
+    public char [][] getBoardWithAllSignsShown(){
+        char[][] reSBoard = new char[size][size];
+        for (int row = 0; row < size; row++) {
+            for (int col = 0; col < size; col++) {
+                reSBoard[row][col] = this.board[row][col].sign.toCharArray()[0];
+            }
+        }
+            return reSBoard;
+    }
 
     //C'tor
     Board(short _size, List<GameDataFromXml.DataLetter> letters, int totalAmountLetters){
@@ -121,6 +134,7 @@ char[][] getBoard_onlySigns() {
         kupa.addAll(letters);
     }
 
+    public Map <Letter,List<Point>> getInitLetters(){return  initLetters;}
     private Point getRandomPoint() {
         int x,y;
         Random xy = new Random();
@@ -228,4 +242,43 @@ void removeLettersFromBoard(String word) {
             }
          }
     }
+
+    public void removePointsFromBoard(List<int[]> pointToRemove) {
+        List<java.awt.Point> points = new ArrayList<>();
+        for (int[] point: pointToRemove) {
+            points.add(new java.awt.Point(point[1], point[0]));
+        }
+        removeLettersFromBoard(points);
+    }
+
+    public void removeLettersFromBoard(List <java.awt.Point> pointsToRemove) {
+        Random random = new Random();
+        GameDataFromXml.DataLetter dataLetter;
+
+        for(java.awt.Point point : pointsToRemove){
+            int row = (int)point.getY() - 1;
+            int col = (int)point.getX() - 1;
+            for (Letter letter: initLetters.keySet()) {
+                if (letter.getSign().get(0).equals(board[row][col].sign)) {
+                    initLetters.get(letter).remove(new Point(col, row));
+                    break;
+                }
+            }
+            do {
+                int letter = random.nextInt(initLetters.size());
+                dataLetter = kupa.get(letter);
+            } while(!(dataLetter.getAmount() > 0));
+            Letter letter = dataLetter.getLetter();
+            initLetters.get(letter).add(new Point(col, row));
+            dataLetter.setAmount(dataLetter.getAmount() - 1);
+            board[row][col].sign = letter.getSign().get(0);
+            board[row][col].isShown = false;
+            leftCards--;
+        }
+    }
+
+    public Cell getCellByPos(int x, int y){
+        return board[y][x];
+    }
+
 }
\ No newline at end of file
diff --git a/GameEngine/src/engine/ComputerTask.java b/GameEngine/src/engine/ComputerTask.java
new file mode 100644
index 0000000..2a54502
--- /dev/null
+++ b/GameEngine/src/engine/ComputerTask.java
@@ -0,0 +1,138 @@
+package engine;
+
+import engine.exceptions.OutOfBoardBoundariesException;
+import javafx.concurrent.Task;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class ComputerTask extends Task<Boolean> {
+    private static final short SLEEP_TIME = 500;
+
+    private Player player;
+    private GameEngine gameEngine;
+    private int diceValue;
+    private int tryNumber;
+    private List<Button> currentSelectedButtons = new ArrayList<>(); // remove - No use
+    private String currentSelectedWord;
+    private List<int[]> selectedPoints = new ArrayList<>();
+
+
+    public ComputerTask(Player player, GameEngine gameEngine) {
+        this.player = player;
+        this.gameEngine = gameEngine;
+    }
+
+    public List<int[]> getSelectedPoints() {
+        return selectedPoints;
+    }
+
+    public void setCurrentSelectedButtons(List<Button> currentSelectedButtons) {
+        this.currentSelectedButtons = currentSelectedButtons;
+    }
+
+    public List<Button> getCurrentSelectedButtons() {
+        return currentSelectedButtons;
+    }
+
+    @Override
+    protected Boolean call() {
+        tryNumber = 1;
+        getDiceValue();
+        selectTilesToShow();
+        GameEngine.WordCheck result;
+        int maxRetries = gameEngine.getMaxRetries() + 1;
+        updateProgress(0, maxRetries);
+        do {
+            result = buildWord();
+            tryNumber++;
+            updateProgress(tryNumber, maxRetries);
+        } while(result == GameEngine.WordCheck.WRONG || result == GameEngine.WordCheck.CHARS_NOT_PRESENT);
+
+        if (result == GameEngine.WordCheck.CORRECT) {
+            updateMessage("The word " + currentSelectedWord + " is CORRECT!");
+            sleepForAWhile(SLEEP_TIME * 2);
+        }
+
+        return result == GameEngine.WordCheck.CORRECT;
+    }
+
+    private static void sleepForAWhile(long sleepTime) {
+        if (sleepTime != 0) {
+            try {
+                Thread.sleep(sleepTime);
+            } catch (InterruptedException ignored) {
+
+            }
+        }
+    }
+
+    private void getDiceValue() {
+        updateMessage("Getting dice value...");
+        sleepForAWhile(SLEEP_TIME);
+        diceValue = gameEngine.getDiceValue();
+        updateMessage("Dice value is: " + diceValue + ".");
+        sleepForAWhile(SLEEP_TIME);
+    }
+
+    private void selectTilesToShow() {
+        selectedPoints.clear();
+        updateMessage("Selecting " + diceValue + " tiles to show...");
+        sleepForAWhile(SLEEP_TIME);
+        List<Board.Point> points = gameEngine.getUnShownPoints();
+        List<int[]> selectedPoints = new ArrayList<>();
+        Random random = new Random();
+        for (int i = 0; i < diceValue; i++) {
+            updateProgress(i + 1, diceValue);
+            int[] p = new int[2];
+            do {
+                Board.Point point = points.get(random.nextInt(points.size()));
+                p[0] = point.getY();
+                p[1] = point.getX();
+            } while (selectedPoints.contains(p));
+
+            selectedPoints.add(p);
+        }
+        this.selectedPoints = selectedPoints;
+        try {
+            gameEngine.updateBoard(selectedPoints);
+        } catch (OutOfBoardBoundariesException e) {
+            e.printStackTrace();
+        }
+        updateMessage("Selection completed.");
+        sleepForAWhile(SLEEP_TIME);
+    }
+
+    private GameEngine.WordCheck buildWord() {
+        String tryNumberStr = "Try number: "+ tryNumber + "\n";
+        updateMessage(tryNumberStr +"Building a word...");
+        sleepForAWhile(SLEEP_TIME);
+        char[][] board = gameEngine.getBoard();
+        StringBuilder word = new StringBuilder();
+        List<int[]> selectedChars = new ArrayList<>();
+        // build the word from the board
+        for (int row = 0; row < gameEngine.getBoardSize(); row++) {
+            for (int col = 0; col < gameEngine.getBoardSize(); col++) {
+                char c = board[row][col];
+                if (c != '\0' && c != ' ') {
+                    word.append(c);
+                    selectedChars.add(new int[]{row + 1, col + 1});
+                }
+                if (word.length() >= 2) {
+                    break;
+                }
+            }
+            if (word.length() >= 2) {
+                break;
+            }
+        }
+        currentSelectedWord = word.toString();
+        selectedPoints = selectedChars;
+        updateMessage(tryNumberStr + "The word is \"" + word + "\"");
+        sleepForAWhile(SLEEP_TIME);
+        return gameEngine.isWordValidWithCoordinates(word.toString(), tryNumber, selectedChars);
+    }
+
+}
diff --git a/GameEngine/src/engine/Dictionary.java b/GameEngine/src/engine/Dictionary.java
index 406d89d..00b26af 100644
--- a/GameEngine/src/engine/Dictionary.java
+++ b/GameEngine/src/engine/Dictionary.java
@@ -1,27 +1,47 @@
 package engine;
 
 import engine.exceptions.DictionaryNotFoundException;
+import engine.jaxb.schema.generated.Letter;
 
 import java.io.File;
 import java.io.FileNotFoundException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Scanner;
+import java.util.*;
 
-class Dictionary {
+public class Dictionary {
     private long numberOfWords = 0;
     private Map<String, Word> words = new HashMap<>();
+    private List<String> top10RareWords = new ArrayList<>();
+    enum FreqSegment { COMMON, LESS_COMMON, RARE }
 
-    private class Word {
+    public class Word {
         private String word;
         private long count = 0;
         private float frequency;
+        private FreqSegment freqSegment;
+        private int score = 0;
 
-        private Word(String word) {
+        public Word(String word) {
             this.word = word;
             count = 1;
         }
 
+        public void setWord(String word) {
+            this.word = word;
+        }
+
+        public void setCount(long count) {
+            this.count = count;
+        }
+
+
+        int getScore() {
+            return score;
+        }
+
+        public String getWord() {
+            return word;
+        }
+
         private long getCount() {
             return count;
         }
@@ -38,6 +58,10 @@ private void advanceCount() {
             count++;
         }
 
+        private void setScore(int score) {
+            this.score = score;
+        }
+
         @Override
         public int hashCode() {
             int hash = 13;
@@ -87,11 +111,14 @@ public boolean equals(Object obj) {
             }
         }
         calcFrequency();
+        setSegment();
     }
 
-
-    boolean hasWord(String word) {
-        return words.containsKey(word);
+    public Word stringToWord(String word){
+        return new Word(word);
+    }
+    Word hasWord(String word) {
+        return words.getOrDefault(word, null);
     }
 
     long getNumberOfWords() {
@@ -108,4 +135,70 @@ private void calcFrequency() {
             word.setFrequency(freq);
         }
     }
+
+    private void setSegment() {
+        long firstSegmentSize = numberOfWords / 3;
+        long secondSegmentSize = firstSegmentSize * 2;
+        long totalWordsProcessed = 0;
+        long totalDistinctWordsProcessed = 0;
+        FreqSegment currentSegment = FreqSegment.COMMON;
+        List<Word> wordList = new ArrayList<>();
+        wordList.addAll(words.values());
+        wordList.sort(Comparator.comparing(word -> (-word.count)));
+        for (Word word: wordList) {
+            totalDistinctWordsProcessed++;
+            if (totalWordsProcessed > secondSegmentSize) {
+                currentSegment = FreqSegment.RARE;
+            }
+            else if (totalWordsProcessed > firstSegmentSize) {
+                currentSegment = FreqSegment.LESS_COMMON;
+            }
+            word.freqSegment = currentSegment;
+            totalWordsProcessed += word.count;
+            if (totalDistinctWordsProcessed >= words.size() - 10) {
+                top10RareWords.add(word.word);
+            }
+        }
+    }
+
+    private int getSegmentScore(String strWord) {
+        Word word = words.get(strWord);
+        switch (word.freqSegment){
+            case COMMON:
+                return 1;
+            case LESS_COMMON:
+                return 2;
+            case RARE:
+                return 3;
+            default:
+                return 0;
+        }
+    }
+
+    void calcWordsScore(List<Letter> letters) {
+        for (Map.Entry<String, Word> entry: words.entrySet()) {
+            Word word = entry.getValue();
+            for(Character ch: entry.getKey().toCharArray()) {
+                for (Letter letter : letters) {
+                    if (letter.getSign().get(0).equals(ch.toString())) {
+                        word.score += letter.getScore();
+                        break;
+                    }
+                }
+            }
+            word.score *= getSegmentScore(entry.getKey());
+        }
+    }
+
+    float getScore(String word) {
+        return words.get(word).score;
+    }
+
+    public String getTop10RareWords() {
+        StringBuilder topTenRareWords = new StringBuilder();
+        for(String letter : top10RareWords){
+            topTenRareWords.append(letter + "\n");
+        }
+        return topTenRareWords.toString();
+    }
 }
diff --git a/GameEngine/src/engine/GameDataFromXml.java b/GameEngine/src/engine/GameDataFromXml.java
index 374c0f7..3289ddf 100644
--- a/GameEngine/src/engine/GameDataFromXml.java
+++ b/GameEngine/src/engine/GameDataFromXml.java
@@ -16,7 +16,7 @@
 import javax.xml.bind.Unmarshaller;
 
 
-class GameDataFromXml {
+public class GameDataFromXml {
 
     public class DataLetter{
        private Letter letter; // sign , score, freq
@@ -40,6 +40,7 @@ public void setLetter(Letter letter) {
         }
     }
 
+    private boolean isGoldFishMode;
     private GameDescriptor gameDescriptor;
     private List<DataLetter> letters = new ArrayList<>();
     private int totalAmountOfLetters = 0;
@@ -51,9 +52,9 @@ public void setLetter(Letter letter) {
     private short totalTargetDeckSize; //כמות אריחים
     private final static String JAXB_XML_GAME_PACKAGE_NAME = "engine.jaxb.schema.generated";
     private Board board;
-    private Players players;
+    private Map<Short, Player> players = new HashMap<>();
     private Dictionary dictionary;
-    private enum WinAccordingTo {WORD_COUNT, WORD_SCORE}
+    public enum WinAccordingTo {WORD_COUNT, WORD_SCORE}
     private WinAccordingTo winAccordingTo;
 
     // get and set funcs:
@@ -64,15 +65,34 @@ int getNumOfTries() {
         return numOfTries;
     }
 
+    void initializeDataFromXml(File file) {
+        // TODO: add and fix code
+    }
+
+    public WinAccordingTo getWinAccordingTo(){
+        return winAccordingTo;
+    }
+    public boolean getGoldFishMod(){
+        return isGoldFishMode;
+    }
+
+
     void initializeDataFromXml(String pathToXml)
             throws WrongPathException, NotValidXmlFileException, DictionaryNotFoundException, WinTypeException,
-            NotXmlFileException, BoardSizeException, DuplicateLetterException, NotEnoughLettersException {
+            NotXmlFileException, BoardSizeException, DuplicateLetterException, NotEnoughLettersException,
+            NumberOfPlayersException, DuplicatePlayerIdException {
 
         loadXml(pathToXml);
-        Structure struct;
-        struct = gameDescriptor.getStructure();
+        Structure struct = gameDescriptor.getStructure();
         buildDataLetters(struct);
 
+        //init gold fish mode
+        try {
+            isGoldFishMode = gameDescriptor.getGameType().isGoldFishMode();
+        }
+        catch (NullPointerException e) {
+            isGoldFishMode = false;
+        }
         //init board size
         boardSize = struct.getBoardSize();
         //init num of wings
@@ -82,15 +102,37 @@ void initializeDataFromXml(String pathToXml)
         //init dictionary file name
         dictFileName = struct.getDictionaryFileName();
 
-        initDictionary(pathToXml);
+        initDictionary(pathToXml, struct);
         initBoard();
 
         //init players
-        players = gameDescriptor.getPlayers();
 
+        List<Player> players = gameDescriptor.getPlayers().getPlayer();
+        if ((players.size() < engine.Player.MIN_PLAYERS) || (players.size() > engine.Player.MAX_PLAYERS)) {
+            throw new NumberOfPlayersException(players.size(), engine.Player.MIN_PLAYERS, engine.Player.MAX_PLAYERS);
+        }
+        for (Player player: players) {
+            short id = player.getId();
+            if (this.players.containsKey(id)) {
+                throw new DuplicatePlayerIdException(id);
+            }
+            this.players.put(id, player);
+        }
+        
+        //init score type
         initWinType();
     }
 
+    void resetBoard() {
+        try {
+            Structure struct = gameDescriptor.getStructure();
+            buildDataLetters(struct);
+            initBoard();
+        }
+        catch (Exception e) {
+        }
+    }
+
     //creates the xml details:
     private static GameDescriptor deserializeFrom(InputStream in) throws JAXBException {
         JAXBContext jc = JAXBContext.newInstance(JAXB_XML_GAME_PACKAGE_NAME);
@@ -118,6 +160,7 @@ private void loadXml(String pathToXml) throws NotXmlFileException, WrongPathExce
         }
     }
 
+
     // builds the letters variable and calculates the each letter's frequency
     private void buildDataLetters(Structure struct) throws DuplicateLetterException {
         // creates list of data letters
@@ -153,18 +196,19 @@ private void verifyLettersAppearOnce() throws DuplicateLetterException {
     }
 
     // check if dictionary exists and pars it
-    private void initDictionary(String pathToXml) throws DictionaryNotFoundException {
+    private void initDictionary(String pathToXml, Structure struct) throws DictionaryNotFoundException {
         pathToXml = pathToXml.substring(0, pathToXml.length() - 4); // minus 4 for ".xml"
         while (!pathToXml.endsWith("\\")) {
             pathToXml = pathToXml.substring(0, pathToXml.length() - 1);
         }
         dictFilePath = pathToXml + "dictionary\\" + dictFileName;
         dictionary = new Dictionary(dictFilePath);
+        dictionary.calcWordsScore(struct.getLetters().getLetter());
     }
 
     // initialize board after size check
     private void initBoard() throws BoardSizeException, NotEnoughLettersException {
-        if ((boardSize < Board.MIN_SIZE) && (boardSize > Board.MAX_SIZE)) {
+        if ((boardSize < Board.MIN_SIZE) || (boardSize > Board.MAX_SIZE)) {
             throw new BoardSizeException(boardSize, Board.MIN_SIZE, Board.MAX_SIZE);
         }
         if (totalAmountOfLetters < boardSize * boardSize) {
@@ -194,7 +238,7 @@ Board getBoard() {
         return board;
     }
 
-    Dictionary getDictionary() {
+    public Dictionary getDictionary() {
         return dictionary;
     }
 
@@ -202,25 +246,21 @@ void updateBoard(List<int[]> points) throws OutOfBoardBoundariesException {
         board.update(points);
     }
 
-    List<engine.jaxb.schema.generated.Player> getPlayers() throws NumberOfPlayersException{
-        List<Player> players;
+    List<engine.jaxb.schema.generated.Player> getPlayers(){
+        List<Player> players = new ArrayList<>();
         if (this.players == null) {
             return new ArrayList<>();
         }
-        players = this.players.getPlayer();
-        if (players.size() > 2) {
-            //TODO: fix when supporting more than 2
-            throw new NumberOfPlayersException(players.size(), engine.Player.MIN_PLAYERS, engine.Player.MIN_PLAYERS);
-        }
+        players.addAll(this.players.values());
         return players;
     }
 
-    float calcScore(String word) {
+    public float calcScore(String word) {
         if (winAccordingTo == WinAccordingTo.WORD_COUNT) {
             return 1;
         }
         else if (winAccordingTo == WinAccordingTo.WORD_SCORE) {
-            return 1;
+            return dictionary.getScore(word);
         }
         else {
             return 0;
@@ -231,10 +271,8 @@ int getKupaAmount() {
         return board.getKupaAmount();
     }
 
-    List<DataLetter> getKupa() {
+    public List<DataLetter> getKupa() {
         return board.getKupa();
     }
-    Board getBoardClass(){
-        return board;
-    }
+
 }
diff --git a/GameEngine/src/engine/GameEngine.java b/GameEngine/src/engine/GameEngine.java
index b75826d..e95e893 100644
--- a/GameEngine/src/engine/GameEngine.java
+++ b/GameEngine/src/engine/GameEngine.java
@@ -1,19 +1,24 @@
 package  engine;
 
+import java.io.File;
 import java.lang.String;
 
-import com.sun.xml.internal.bind.v2.schemagen.xmlschema.Import;
 import engine.exceptions.*;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
+import java.util.*;
+
 import engine.Board.Point;
+import engine.GameDataFromXml.*;
+
+import engine.jaxb.schema.generated.Letter;
+import javafx.scene.control.Button;
+import javafx.util.Pair;
 
 public class GameEngine {
 
     private Player currentPlayer;
     private int nextPlayerNumber = 1;
+    private int numOfPlayers;
     private List<Player> players;
     private List<GameDataFromXml> gdfx = new ArrayList<>();
     private GameDataFromXml currentGameData;
@@ -22,18 +27,100 @@ public class GameEngine {
     private long startTime;
     private int numberOfTurns = 0;
     private int tryNumber;
+    private Map <Integer, CaptureTheMoment> turnData = new HashMap<>();
+    private int pointerForTurnData = -1;
     public enum WordCheck {
             CORRECT, WRONG, WRONG_CANT_RETRY, CHARS_NOT_PRESENT, TRIES_DEPLETED
     }
 
+
+    //TODO: we need also save dice value , num of tries?
+    public static class CaptureTheMoment{
+        private  List<Player> players;
+        private List<int[]> selectedBoardButtons; //for showing the selected word
+        private Player currentPlayer;
+        private int turnNumber;
+        private char[][] board;
+
+        public CaptureTheMoment(){}
+
+        public void setCurrentPlayer(Player currentPlayer) {
+            this.currentPlayer = currentPlayer;
+        }
+
+        public void setPlayers(List<Player> players) {
+            this.players = new ArrayList<>();
+            for (Player player: players) {
+                if (player.getId() == currentPlayer.getId()) {
+                    this.players.add(currentPlayer);
+                }
+                else {
+                    this.players.add(new Player(player));
+                }
+            }
+        }
+
+        public void setSelectedPoints(List<int[]> selectedBoardButtons) {
+            this.selectedBoardButtons = selectedBoardButtons;
+        }
+
+        public void setTurnNumber(int turnNumber) {
+            this.turnNumber = turnNumber;
+        }
+
+        void setBoard(char[][] board) {
+            this.board = board;
+        }
+
+        public char[][] getBoard() {
+            return board;
+        }
+
+        public Player getCurrentPlayer() {
+            return currentPlayer;
+        }
+
+        public List<Player> getPlayers() {
+            return players;
+        }
+
+        public int getTurnNumber() {
+            return turnNumber + 1;
+        }
+
+        public List<int[]> getSelectedBoardButtons() {
+            return selectedBoardButtons;
+        }
+    }
+
+    public Map<Integer, CaptureTheMoment> getTurnData() {
+        return turnData;
+    }
+
+    public void setGameStarted(boolean gameStarted) {
+        isGameStarted = gameStarted;
+    }
+
     public void loadXml(String pathToXml)
             throws WrongPathException, DictionaryNotFoundException, BoardSizeException, NotXmlFileException,
-            DuplicateLetterException, NotValidXmlFileException, WinTypeException, NotEnoughLettersException {
+            DuplicateLetterException, NotValidXmlFileException, WinTypeException, NotEnoughLettersException,
+            NumberOfPlayersException, DuplicatePlayerIdException {
         GameDataFromXml gd = new GameDataFromXml();
         gd.initializeDataFromXml(pathToXml);
         gdfx.add(gd);
     }
 
+    public void loadXml(File file)
+            throws WrongPathException, DictionaryNotFoundException, BoardSizeException, NotXmlFileException,
+            DuplicateLetterException, NotValidXmlFileException, WinTypeException, NotEnoughLettersException {
+        GameDataFromXml gd = new GameDataFromXml();
+        gd.initializeDataFromXml(file);
+        gdfx.add(gd);
+    }
+
+    public void reset() {
+        currentGameData.resetBoard();
+    }
 
     public boolean isXmlLoaded() {
         return !gdfx.isEmpty();
@@ -43,20 +130,36 @@ public boolean isStarted() {
         return isGameStarted;
     }
 
-    public void startGame() throws NumberOfPlayersException {
-        currentGameData =  gdfx.get(0);
-        players = new ArrayList<>();
-        List<engine.jaxb.schema.generated.Player> _players = currentGameData.getPlayers();
+    private List<Player> getPlayersList() {
+        List<Player> players = new ArrayList<>();
+        GameDataFromXml gd = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        List<engine.jaxb.schema.generated.Player> _players = gd.getPlayers();
+
         for (engine.jaxb.schema.generated.Player p: _players) {
-            players.add(new Player(p.getName().get(0)));
-        }
-        while (players.size() < 2) {
-            players.add(new Player("Player" + players.size()));
+            players.add(new Player(p.getName().get(0), p.getId(),p.getType()));
         }
-        currentPlayer = players.get(0);
+        return players;
+    }
+
+    public void startGame() {
         isGameStarted = true;
-        startTime = System.currentTimeMillis();
+        currentGameData =  gdfx.get(gdfx.size() - 1);
+        players = getPlayersList();
+        numOfPlayers = players.size();
+        currentPlayer = players.get(0);
         tryNumber = 1;
+        numberOfTurns = 0;
+        pointerForTurnData = -1;
+        turnData.clear();
+        startTime = System.currentTimeMillis();
+    }
+
+    public Player getCurrentPlayer() {
+        return currentPlayer;
+    }
+
+    public boolean isPlayerComputer() {
+        return currentPlayer.isComputer();
     }
 
     public Status getStatus() {
@@ -65,7 +168,9 @@ public Status getStatus() {
         return new Status(
                 gd.getBoard().getBoard_onlySigns(),
                 currentPlayer != null ? currentPlayer.getName() : null,
-                gd.getBoard().getKupaAmount()
+                gd.getBoard().getKupaAmount(),
+                currentPlayer != null ? currentPlayer.getScore() : 0,
+                currentPlayer != null ? currentPlayer.getId() : 0
         );
     }
 
@@ -85,55 +190,74 @@ public boolean updateBoard(List<int[]> points) throws OutOfBoardBoundariesExcept
 
     public char[][] getBoard() {
         return currentGameData.getBoard().getBoard_onlySigns();
+    }
 
+    public short getBoardSize(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getBoard().getBoardSize();
     }
 
     private boolean canRetry() {
-        return tryNumber <= currentGameData.getNumOfTries();
+        return tryNumber <= currentGameData.getNumOfTries() + 1;
     }
 
     public int getMaxRetries() {
-        return currentGameData.getNumOfTries();
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getNumOfTries();
     }
 
     public WordCheck isWordValid(String word, int tries) {
+        return isWordValidWithCoordinates(word, tries, null);
+    }
+
+    public WordCheck isWordValidWithCoordinates(String word, int tries, List<int[]> selectedPoints) {
         if (tries == tryNumber && canRetry()) {
             if (!currentGameData.getBoard().hasChars(word)) {
+                tryNumber++;
                 return WordCheck.CHARS_NOT_PRESENT;
             }
-            if (currentGameData.getDictionary().hasWord(word)) {
-                currentGameData.getBoard().removeLettersFromBoard(word);
-                currentPlayer.updateScore(word, currentGameData.calcScore(word));
+            Dictionary.Word dictWord = currentGameData.getDictionary().hasWord(word);
+            if (dictWord != null) {
+                // this was the old version
+                // currentGameData.getBoard().removeLettersFromBoard(word);
+                currentPlayer.updateScore(dictWord, currentGameData.calcScore(word));
                 tryNumber = 1;
+                saveTheTurn(selectedPoints);
+                currentGameData.getBoard().removePointsFromBoard(selectedPoints);
+                numberOfTurns++;
                 return WordCheck.CORRECT;
             }
             tryNumber++;
             if (!canRetry()) {
+                saveTheTurn(new ArrayList<>());
                 nextPlayer();
                 return WordCheck.WRONG_CANT_RETRY;
             }
             return WordCheck.WRONG;
         }
+        saveTheTurn(new ArrayList<>());
         nextPlayer();
         return WordCheck.TRIES_DEPLETED;
     }
 
     private void nextPlayer() {
-        currentPlayer = players.get(nextPlayerNumber);
-        nextPlayerNumber = (nextPlayerNumber + 1) % players.size();
+        do {
+            currentPlayer = players.get(nextPlayerNumber);
+            nextPlayerNumber = (nextPlayerNumber + 1) % players.size();
+        } while (currentPlayer.isRetired());
         numberOfTurns++;
         tryNumber = 1;
     }
 
     public Statistics getStatistics() {
-        return new Statistics(players, System.currentTimeMillis() - startTime, numberOfTurns, currentGameData);
+        return new Statistics(players, System.currentTimeMillis() - startTime, numberOfTurns + 1, currentGameData);
     }
 
     public List<Board.Point> getUnShownPoints(){
             List<Board.Point> unShownPoints = new ArrayList<>();
             for(int row = 0; row <currentGameData.getBoard().getBoardSize(); row++){
                 for(int col = 0; col < currentGameData.getBoard().getBoardSize(); col++){
-                    if(!(currentGameData.getBoard().getFullBoardDetails()[row][col].isShown)) {
+                    if(!(currentGameData.getBoard().getBoardFullDetails()[row][col].isShown)) {
                         Point p = new Board.Point (row+1,col+1);
                         unShownPoints.add(p);
                     }
@@ -142,12 +266,24 @@ public List<Board.Point> getUnShownPoints(){
             return unShownPoints;
     }
 
-    public boolean isGameEnded(){
+    public boolean isGameEnded() {
         //if no more left cards in kupa and all the tails in the board are shown
-        return (currentGameData.getBoard().getKupaAmount() == 0) || (getUnShownPoints().isEmpty());
+        if ((numOfPlayers < 2 || currentGameData.getBoard().getKupaAmount() == 0) || (getUnShownPoints().isEmpty())) {
+            isGameStarted = false;
+            return true;
+        }
+        return false;
+    }
 
+    public boolean isGameEnded(boolean allTilesShown) {
+        if ((numOfPlayers < 2 || currentGameData.getBoard().getKupaAmount() == 0) || allTilesShown) {
+            isGameStarted = false;
+            return true;
+        }
+        return false;
     }
 
+
     public String getWinnerName(boolean userEnd) {
         Player winner = null;
         // TODO: fix when having more than 2 players
@@ -165,4 +301,115 @@ public String getWinnerName(boolean userEnd) {
         }
         return winner == null ? "" : winner.getName();
     }
+
+    public List<Player> getPlayers() {
+        return isGameStarted ? players : getPlayersList();
+    }
+
+    public short getCurrentPlayerId() {
+        return currentPlayer.getId();
+    }
+
+    public Board getBoardObject(){
+        return currentGameData.getBoard();
+    }
+
+    public Boolean isInGoldFishMod(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getGoldFishMod();
+    }
+
+    public WinAccordingTo getWinScoreMod(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getWinAccordingTo();
+    }
+
+    public boolean isWordScore(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getWinAccordingTo().equals(WinAccordingTo.WORD_SCORE);
+    }
+
+    public String getFreqEachLetter(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        StringBuilder freqLetters = new StringBuilder();
+        for(Letter letter : gameDataFromXml.getBoard().getInitLetters().keySet()) {
+            freqLetters.append(letter.getSign().get(0) + " : " + letter.getFrequency()+ "\n");
+        }
+        return freqLetters.toString();
+    }
+
+    public String getTopTenRareWords(){
+        GameDataFromXml gameDataFromXml = isGameStarted ? currentGameData : gdfx.get(gdfx.size() - 1);
+        return gameDataFromXml.getDictionary().getTop10RareWords();
+    }
+    public GameDataFromXml getCurrentGameData(){
+        return currentGameData;
+    }
+
+
+    public Map<String, Pair<Integer, Integer>> getPlayerWords(int playerId) {
+        Map<String, Pair<Integer, Integer>> words = new HashMap<>();
+        List<Player> players = isGameEnded() ? turnData.get(pointerForTurnData).players : this.players;
+        for (Player player: players) {
+            if (player.getId() == playerId) {
+                for (Map.Entry<Dictionary.Word, Integer> entry: player.getWords().entrySet()) {
+                    words.put(entry.getKey().getWord(), new Pair<>(entry.getValue(), entry.getKey().getScore()));
+                }
+                return words;
+            }
+        }
+        return null;
+    }
+
+    public boolean retirePlayer() {
+        currentPlayer.retire();
+        saveTheTurn(new ArrayList<>());
+        numOfPlayers--;
+        if (numOfPlayers < 2) {
+            isGameStarted = false;
+            return false;
+        }
+        nextPlayer();
+        return true;
+    }
+
+    //TODO: decide where to call this func - should be after each move
+    private void saveTheTurn(List<int[]> selectedPoints){
+        CaptureTheMoment captureTheMoment = new CaptureTheMoment();
+        captureTheMoment.setCurrentPlayer(new Player(currentPlayer));
+        captureTheMoment.setPlayers(players);
+        captureTheMoment.setTurnNumber(numberOfTurns);
+        captureTheMoment.setSelectedPoints(selectedPoints);
+        captureTheMoment.setBoard(getBoard());
+        turnData.put(numberOfTurns, captureTheMoment);
+    }
+
+    public CaptureTheMoment getSpecificTurn(){
+        return turnData.get(pointerForTurnData);
+    }
+
+    private CaptureTheMoment getCurrentSave() {
+        CaptureTheMoment captureTheMoment = turnData.get(pointerForTurnData);
+        currentPlayer = captureTheMoment == null ? null : captureTheMoment.currentPlayer;
+        players = captureTheMoment == null ? null : captureTheMoment.players;
+        return captureTheMoment;
+    }
+
+    public CaptureTheMoment prevSaveData() {
+        pointerForTurnData--;
+        return getCurrentSave();
+    }
+
+    public boolean havePrevSave() {
+        return pointerForTurnData > 0;
+    }
+
+    public CaptureTheMoment nextSaveData() {
+        pointerForTurnData++;
+        return getCurrentSave();
+    }
+
+    public boolean haveNextSave() {
+        return pointerForTurnData < turnData.size() - 1;
+    }
 }
diff --git a/GameEngine/src/engine/Player.java b/GameEngine/src/engine/Player.java
index 3570e2b..211a48a 100644
--- a/GameEngine/src/engine/Player.java
+++ b/GameEngine/src/engine/Player.java
@@ -2,36 +2,101 @@
 
 import java.util.*;
 
-class Player {
+public class Player {
+    public enum Type {
+        HUMAN, COMPUTER
+    }
+    private short id;
 
     private String name;
     private float score;
-    private List<String> words;
+    private Type type;
+    private Map<Dictionary.Word, Integer> words;
+    private boolean isRetired = false;
     static final short MAX_PLAYERS = 6;
     static final short MIN_PLAYERS = 2;
 
-    Player(String name) {
+    Player(String name, short id, String type) {
         this.name = name;
-        score = 0;
-        words = new ArrayList<>();
+        this.id = id;
+        this.score = 0;
+        if(type.equals("Human"))
+            this.type = Type.HUMAN;
+        else
+            this.type = Type.COMPUTER;
+        words = new HashMap<>();
+    }
+
+    Player(Player other) {
+        name = other.name;
+        id = other.id;
+        score = other.score;
+        type = other.type;
+        words = new HashMap<>();
+        words.putAll(other.words);
+        isRetired = other.isRetired;
     }
 
-    void updateScore(String word, float score) {
+    public void updateScore(Dictionary.Word word, float score) {
         this.score += score;
-        words.add(word);
+        words.put(word, words.containsKey(word) ? words.get(word) + 1 : 1);
     }
 
-    String getName() {
+    public String getName() {
         return name;
     }
 
-    float getScore() {
+    public float getScore() {
         return score;
     }
 
-    List<String> getWords() {
-        List<String> l = new ArrayList<>();
-        l.addAll(words);
-        return l;
+    public String getType() {
+        return type.name().toLowerCase();
+    }
+
+    public short getId() {
+        return id;
+    }
+
+    public boolean isRetired() {
+        return isRetired;
+    }
+
+    void retire() {
+        this.isRetired = true;
+    }
+
+    boolean isComputer() {
+        return type == Type.COMPUTER;
+    }
+
+    Map<Dictionary.Word, Integer> getWords() {
+        return new HashMap<>(this.words);
+    }
+
+    void reset() {
+        score = 0;
+        words.clear();
+        isRetired = false;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s id: %d (%s) Score:", name, id, type.name().toLowerCase());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Player player = (Player) o;
+
+        return id == player.id;
+    }
+
+    @Override
+    public int hashCode() {
+        return id;
     }
 }
diff --git a/GameEngine/src/engine/Statistics.java b/GameEngine/src/engine/Statistics.java
index 10f39db..1fefcee 100644
--- a/GameEngine/src/engine/Statistics.java
+++ b/GameEngine/src/engine/Statistics.java
@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class Statistics {
 
@@ -24,8 +25,13 @@ public String getName() {
         }
 
         public List<String> getWords() {
-
-            return player.getWords();
+            List<String> list = new ArrayList<>();
+            for (Map.Entry<Dictionary.Word, Integer> entry: player.getWords().entrySet()) {
+                for (int i = 0; i < entry.getValue(); i++) {
+                    list.add(entry.getKey().getWord());
+                }
+            }
+            return list;
         }
 
         public float getScore() {
@@ -85,7 +91,8 @@ public long getTotalWords() {
     }
 
     public long getWordCount(String word) {
-        return dict.hasWord(word) ? dict.getWordAmount(word) : 0;
+        Dictionary.Word dictWord = dict.hasWord(word);
+        return dictWord != null ? dict.getWordAmount(word) : 0;
     }
 
     public List<Letter> getLetters() {
diff --git a/GameEngine/src/engine/Status.java b/GameEngine/src/engine/Status.java
index eeb312c..49511f5 100644
--- a/GameEngine/src/engine/Status.java
+++ b/GameEngine/src/engine/Status.java
@@ -3,12 +3,16 @@
 public class Status {
     private int leftTiles;
     private String playerName;
+    private short playerId;
+    private float score;
     private char[][] board;
 
-    Status(char[][] board, String playerName, int leftTiles) {
+    Status(char[][] board, String playerName, int leftTiles, float score, short playerId) {
         this.board = board;
         this.leftTiles = leftTiles;
         this.playerName = playerName;
+        this.score = score;
+        this.playerId = playerId;
     }
 
     public int getLeftTiles() {
@@ -22,4 +26,12 @@ public String getPlayerName() {
     public char[][] getBoard() {
         return board;
     }
+
+    public short getPlayerId() {
+        return playerId;
+    }
+
+    public float getScore() {
+        return score;
+    }
 }
diff --git a/GameEngine/src/engine/exceptions/DuplicatePlayerIdException.java b/GameEngine/src/engine/exceptions/DuplicatePlayerIdException.java
new file mode 100644
index 0000000..d094a6e
--- /dev/null
+++ b/GameEngine/src/engine/exceptions/DuplicatePlayerIdException.java
@@ -0,0 +1,14 @@
+package engine.exceptions;
+
+public class DuplicatePlayerIdException extends Exception {
+    private short duplicateId;
+
+    public DuplicatePlayerIdException(short duplicateId) {
+        super();
+        this.duplicateId = duplicateId;
+    }
+
+    public short getDuplicateId() {
+        return duplicateId;
+    }
+}
diff --git a/GameEngine/src/engine/jaxb/schema/generated/ObjectFactory.java b/GameEngine/src/engine/jaxb/schema/generated/ObjectFactory.java
index 3357aa8..ad48f97 100644
--- a/GameEngine/src/engine/jaxb/schema/generated/ObjectFactory.java
+++ b/GameEngine/src/engine/jaxb/schema/generated/ObjectFactory.java
@@ -16,7 +16,7 @@
  * for XML content. The Java representation of XML 
  * content can consist of schema derived interfaces 
  * and classes representing the binding of schema 
- * type definitions, element declarations and model 
+ * type definitions, element declarations and GameManager
  * groups.  Factory methods for each of these are 
  * provided in this class.
  *