mirror of
https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git
synced 2025-09-13 14:22:54 +02:00
Compare commits
1 Commits
b_puderbac
...
revert-71a
| Author | SHA1 | Date | |
|---|---|---|---|
|
9abf7350e4 |
28
.gitignore
vendored
28
.gitignore
vendored
@@ -1,28 +0,0 @@
|
||||
# Gradle
|
||||
.gradle
|
||||
build
|
||||
|
||||
# VSC
|
||||
bin
|
||||
|
||||
# IntelliJ
|
||||
*.iml
|
||||
.idea
|
||||
out
|
||||
|
||||
# Eclipse
|
||||
.classpath
|
||||
.project
|
||||
|
||||
# Libraries
|
||||
*.so
|
||||
*.dylib
|
||||
*.dll
|
||||
*.jar
|
||||
*.class
|
||||
|
||||
.DS_Store
|
||||
!Projekte/gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
45.j3o
|
||||
KingGeorge.j3o
|
||||
1
Dokumente/.gitignore
vendored
1
Dokumente/.gitignore
vendored
@@ -1 +0,0 @@
|
||||
#
|
||||
3
Projekte/.gitattributes
vendored
3
Projekte/.gitattributes
vendored
@@ -1,3 +0,0 @@
|
||||
*.bat text eol=crlf
|
||||
gradlew text eol=lf
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="BattleshipApp (Mac)" type="Application" factoryName="Application"
|
||||
singleton="false">
|
||||
<option name="MAIN_CLASS_NAME" value="pp.battleship.client.BattleshipApp"/>
|
||||
<module name="Projekte.battleship.client.main"/>
|
||||
<option name="VM_PARAMETERS" value="-XstartOnFirstThread"/>
|
||||
<option name="WORKING_DIRECTORY" value="$MODULE_WORKING_DIR$"/>
|
||||
<extension name="coverage">
|
||||
<pattern>
|
||||
<option name="PATTERN" value="pp.battleship.client.*"/>
|
||||
<option name="ENABLED" value="true"/>
|
||||
</pattern>
|
||||
</extension>
|
||||
<method v="2">
|
||||
<option name="Make" enabled="true"/>
|
||||
</method>
|
||||
</configuration>
|
||||
</component>
|
||||
@@ -1,18 +0,0 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="BattleshipApp" type="Application" factoryName="Application" singleton="false"
|
||||
nameIsGenerated="true">
|
||||
<option name="MAIN_CLASS_NAME" value="pp.battleship.client.BattleshipApp"/>
|
||||
<module name="Projekte.battleship.client.main"/>
|
||||
<option name="VM_PARAMETERS" value="-Djava.util.logging.config.file=logging.properties"/>
|
||||
<option name="WORKING_DIRECTORY" value="$MODULE_WORKING_DIR$"/>
|
||||
<extension name="coverage">
|
||||
<pattern>
|
||||
<option name="PATTERN" value="pp.battleship.client.*"/>
|
||||
<option name="ENABLED" value="true"/>
|
||||
</pattern>
|
||||
</extension>
|
||||
<method v="2">
|
||||
<option name="Make" enabled="true"/>
|
||||
</method>
|
||||
</configuration>
|
||||
</component>
|
||||
@@ -1,17 +0,0 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="BattleshipServer" type="Application" factoryName="Application"
|
||||
nameIsGenerated="true">
|
||||
<option name="MAIN_CLASS_NAME" value="pp.battleship.server.BattleshipServer"/>
|
||||
<module name="Projekte.battleship.server.main"/>
|
||||
<option name="WORKING_DIRECTORY" value="$MODULE_WORKING_DIR$"/>
|
||||
<extension name="coverage">
|
||||
<pattern>
|
||||
<option name="PATTERN" value="pp.battleship.server.*"/>
|
||||
<option name="ENABLED" value="true"/>
|
||||
</pattern>
|
||||
</extension>
|
||||
<method v="2">
|
||||
<option name="Make" enabled="true"/>
|
||||
</method>
|
||||
</configuration>
|
||||
</component>
|
||||
@@ -1,24 +0,0 @@
|
||||
<component name="ProjectRunConfigurationManager">
|
||||
<configuration default="false" name="Projekte [test]" type="GradleRunConfiguration" factoryName="Gradle">
|
||||
<ExternalSystemSettings>
|
||||
<option name="executionName" />
|
||||
<option name="externalProjectPath" value="$PROJECT_DIR$" />
|
||||
<option name="externalSystemIdString" value="GRADLE" />
|
||||
<option name="scriptParameters" value="--continue" />
|
||||
<option name="taskDescriptions">
|
||||
<list />
|
||||
</option>
|
||||
<option name="taskNames">
|
||||
<list>
|
||||
<option value="test" />
|
||||
</list>
|
||||
</option>
|
||||
<option name="vmOptions" />
|
||||
</ExternalSystemSettings>
|
||||
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
|
||||
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
|
||||
<DebugAllEnabled>false</DebugAllEnabled>
|
||||
<RunAsTest>false</RunAsTest>
|
||||
<method v="2" />
|
||||
</configuration>
|
||||
</component>
|
||||
@@ -1,188 +0,0 @@
|
||||
# Beispielprogramme des Programmierprojekts
|
||||
|
||||
Hier ist der Quellcode für das in der Einarbeitungsphase genutzte Spiel
|
||||
_Battleships_ zu finden. Die Quellen bestehen aus den folgenden
|
||||
Gradle-Unterprojekten:
|
||||
|
||||
* _:battleship:server_
|
||||
* _:battleship:client_
|
||||
* _:battleship:model_
|
||||
* _:battleship:converter_
|
||||
* _:common_
|
||||
* _:jme-common_
|
||||
|
||||
_Battleships_ ist ein netzwerkbasiertes Spiel und besteht aus einem Server- und
|
||||
einem Clientanteil, die in den Unterprojekten _:battleship:server_ und
|
||||
_:battleship:client_ realisiert sind. Beide nutzen das Unterprojekt
|
||||
_:battleship:model_, das den gemeinsamen Modellanteil enthält.
|
||||
|
||||
Die Unterprojekte _:common_ und _:jme-common_ enthalten Hilfsklassen.
|
||||
|
||||
Das Unterprojekt _:battleship:converter_ wird für _Battleships_ selbst nicht
|
||||
benötigt, sondern enthält lediglich den Code, um ein im Spiel verwendetes
|
||||
3d-Modell eines Schlachtschiffs in eine _J3O_-Datei umzuwandeln, die von jME
|
||||
einfacher geladen werden kann.
|
||||
|
||||
## 1 Vorbereitung
|
||||
|
||||
Für das Programmierprojekt empfehlen wir die Verwendung von Java 20. Unter Linux
|
||||
sollte [_Eclipse Temurin_](https://adoptium.net/temurin/releases/?version=20)
|
||||
als JDK verwendet werden, andere JDKs können unter Linux Probleme verursachen.
|
||||
Auf anderen Betriebssystemen empfehlen wir aber ebenfalls Temurin. Im Folgenden
|
||||
ist beschrieben, wie Sie Temurin installieren und die Umgebungsvariable
|
||||
**JAVA_HOME** richtig setzen, damit Sie Gradle (siehe unten) verwenden können.
|
||||
|
||||
### 1.1 Installation von Temurin
|
||||
|
||||
Laden Sie [_Eclipse Temurin_](https://adoptium.net/temurin/releases/?version=20)
|
||||
entsprechend Ihrem Betriebssystem und Ihrer Prozessorarchitektur herunter und
|
||||
entpacken Sie das Archiv in einem Verzeichnis Ihrer Wahl auf Ihrem Rechner.
|
||||
|
||||
### 1.2 Setzen von JAVA_HOME
|
||||
|
||||
Zur Verwendung mit Gradle muss die Umgebungsvariable **JAVA_HOME** richtig
|
||||
gesetzt werden. Folgen Sie dazu den nachfolgenden Anweisungen entsprechend Ihrem
|
||||
Betriebssystem:
|
||||
|
||||
* **Windows:**
|
||||
|
||||
Öffnen Sie ihre Powershell (Core) bzw. ihr Windows Terminal mit Powershell
|
||||
(Core). Überprüfen Sie, ob die Umgebungsvariable korrekt gesetzt ist:
|
||||
`Get-ChildItem -Path Env:JAVA_HOME`
|
||||
Falls kein oder ein falscher Pfad gesetzt ist, setzen Sie diesen mit dem
|
||||
folgenden Kommando (in einer Zeile):
|
||||
`[System.Environment]::SetEnvironmentVariable('JAVA_HOME','<Pfad zum SDK>',[System.EnvironmentVariableTarget]::User)`
|
||||
|
||||
Alternativ können Sie die GUI verwenden. Unter Windows 10 klicken Sie die
|
||||
Windows-Taste und dann das Zahnrad um die Einstellungen zu öffnen. Dort wählen
|
||||
Sie "System", dann "Info" (links unten) und nun
|
||||
"Erweiterte Systemeinstellungen" (rechts) um den Dialog "Systemeigenschaften"
|
||||
zu starten. Im Reiter "Erweitert" klicken Sie
|
||||
"Umgebungsvariablen..." und klicken dann unter "Benutzervariablen" den Knopf
|
||||
"Neu..." um JAVA_HOME anzulegen oder "Bearbeiten" um ihn zu ändern. Geben Sie
|
||||
als Name `JAVA_HOME` und als Wert den Pfad ein. Schließen Sie mit "OK".
|
||||
|
||||
> **(!) Beachten Sie, dass Sie die jeweilige Applikation neu starten müssen**,
|
||||
> um von der gesetzten Umgebungsvariablen Notiz zu nehmen.
|
||||
> Dies betrifft auch die Shell, die Sie gerade verwenden.
|
||||
|
||||
* **UNIX (Linux/MacOS):**
|
||||
|
||||
Öffnen oder erstellen Sie die Datei `~/.profile` (wenn Sie die Bash verwenden;
|
||||
bei anderen Shells sind es andere Dateien) und ergänzen Sie am Ende der Datei
|
||||
die Zeile:
|
||||
|
||||
`export JAVA_HOME="<Pfad zum entpackten Archiv>"`
|
||||
cd Ersetzen Sie dabei `<Pfad zum entpackten Archiv>` mit dem entsprechenden Pfad.
|
||||
Zum Beispiel:
|
||||
|
||||
`export JAVA_HOME="/home/user/jdk-20.0.2"`
|
||||
|
||||
Fügen Sie dann die folgende Zeile hinzu:
|
||||
|
||||
`export PATH="$JAVA_HOME/bin:$PATH"`
|
||||
|
||||
## 2 Programmstart
|
||||
|
||||
Grundsätzlich kann man das gesamte Projekt einfach in IntelliJ öffnen. Details
|
||||
dazu sind im Aufgabenblatt zur Einarbeitungsaufgabe zu finden. Im Folgenden ist
|
||||
beschrieben, wie die _Batttleships_ unmittelbar von der Kommandozeile gestartet
|
||||
werden können.
|
||||
|
||||
Um _Battleships_ spielen zu können, muss man zuerst das Server-Programm auf
|
||||
einem Rechner und dann zweimal das Client-Programm auf beliebigen Rechnern
|
||||
starten, die TCP/IP-Verbindungen zum Server erlauben. Natürlich ist es auch
|
||||
möglich, alle drei Programme auf demselben Rechner zu starten.
|
||||
|
||||
Es empfiehlt sich der Start von der Kommandozeile. Will man alle drei Programme
|
||||
auf demselben Rechner starten, sollte man dazu drei Shell-Instanzen öffnen und
|
||||
in jeder eines der Programme starten. Auf diese Weise können die
|
||||
Logging-Ausgaben der drei Programme voneinander unterschieden werden.
|
||||
|
||||
Das Server-Programm startet man unmittelbar mit Gradle mit
|
||||
|
||||
`./gradlew :battleship:server:run`
|
||||
|
||||
Unter Windows kann es je nach Shell (Eingabeaufforderung cmd) erforderlich sein,
|
||||
`/` jeweils durch `\ ` zu ersetzen.
|
||||
|
||||
Im Verzeichnis `battleship/server` befindet sich die Datei `config.propeties`,
|
||||
worüber sich der Server konfigurieren lässt. Mit der Zeile `port=1234` lässt
|
||||
sich der verwendete Server-Port (hier 1234) einstellen. Außerdem befindet sich
|
||||
dort die Datei `logging.properties`, womit das Logging des Servers konfiguriert
|
||||
wird.
|
||||
|
||||
Das Client-Programm startet man unmittelbar mit Gradle mit
|
||||
|
||||
`./gradlew :battleship:client:run`
|
||||
|
||||
Die Datei `logging.properties` im Verzeichnis `battleship/client` konfiguriert
|
||||
das Logging des Clients.
|
||||
|
||||
Alternativ kann man auch die Start-Skripte
|
||||
|
||||
* `./battleship/server/build/install/battleship-server/bin/battleship-server`
|
||||
* `./battleship/client/build/install/battleship/bin/battleship`
|
||||
|
||||
direkt in der Kommandozeile starten. Allerdings müssen sie zuvor mittels
|
||||
|
||||
`./gradlew installDist`
|
||||
|
||||
erzeugt worden sein. Beachten Sie aber, dass nur im **aktuellen
|
||||
Arbeitsverzeichnis** nach den Dateien `config.properties` und
|
||||
`logging.properties` gesucht wird und diese geladen werden. Das heißt, dass die
|
||||
vordefinierten Dateien in den Verzeichnissen `battleship/server` und
|
||||
`battleship/client` nur dann gelesen werden, wenn Sie diese Verzeichnisse als
|
||||
aktuelle Arbeitsverzeichnisse nutzen. Wie üblich müssen Sie dazu in der
|
||||
Kommandozeile
|
||||
|
||||
`cd battleship/server`
|
||||
|
||||
bzw.
|
||||
|
||||
`cd battleship/client`
|
||||
|
||||
eingeben.
|
||||
|
||||
## 3 Hinweise zu _Battleships_
|
||||
|
||||
Der _Battleships_-Client hat ein Menü, in das man immer mit der
|
||||
Esc-Taste kommt. Aus dem Menü heraus lässt sich das Programm auch schließen.
|
||||
Beachte, dass sich beim Laden und Speichern eines Spiels kein Dateidialog
|
||||
öffnet. Vielmehr muss man den Dateipfad in das Dialogfeld eingeben. Da
|
||||
JSON-Dateien geschrieben werden, empfiehlt sich das Datei-Suffix _.json_.
|
||||
|
||||
## 4 Allgemeine Gradle-Tasks:
|
||||
|
||||
- `./gradlew clean`
|
||||
|
||||
Entfernt alle `build`-Verzeichnisse und alle erzeugten Dateien.
|
||||
|
||||
- `./gradlew classes`
|
||||
|
||||
Übersetzt den Quellcode und legt unter build den Bytecode sowie
|
||||
Ressourcen ab.
|
||||
|
||||
- `./gradlew javadoc`
|
||||
|
||||
Erzeugt die Dokumentation aus den JavaDoc-Kommentaren im Verzeichnis
|
||||
`build/docs/javadoc` des jeweiligen Unterprojekts.
|
||||
|
||||
- `./gradlew test`
|
||||
|
||||
Führt die JUnit-Tests durch. Ergebnisse sind im Verzeichnis
|
||||
`build/reports/tests` des jeweiligen Unterprojekts zu finden.
|
||||
|
||||
- `./gradlew build`
|
||||
|
||||
Führt die JUnit-Tests durch und erstellt in `build/distributions`
|
||||
gepackte Distributionsdateien
|
||||
|
||||
- `./gradlew installDist`
|
||||
|
||||
Erstellt unter `battleship/client/build/install` und
|
||||
`battleship/server/build/install` Verzeichnisse, die jeweils eine ausführbare
|
||||
Distribution samt Start-Skripten enthält (siehe oben).
|
||||
|
||||
---
|
||||
Juli 2024
|
||||
@@ -1,29 +0,0 @@
|
||||
plugins {
|
||||
id 'buildlogic.jme-application-conventions'
|
||||
}
|
||||
|
||||
description = 'Battleship Client'
|
||||
|
||||
dependencies {
|
||||
implementation project(":jme-common")
|
||||
implementation project(":battleship:model")
|
||||
implementation 'org.jmonkeyengine:jme3-core:3.6.0-stable'
|
||||
implementation 'org.jmonkeyengine:jme3-effects:3.6.0-stable'
|
||||
|
||||
|
||||
|
||||
implementation libs.jme3.desktop
|
||||
implementation project(path: ':battleship:server')
|
||||
implementation project(path: ':battleship:server')
|
||||
|
||||
|
||||
runtimeOnly libs.jme3.awt.dialogs
|
||||
runtimeOnly libs.jme3.plugins
|
||||
runtimeOnly libs.jme3.jogg
|
||||
runtimeOnly libs.jme3.testdata
|
||||
}
|
||||
|
||||
application {
|
||||
mainClass = 'pp.battleship.client.BattleshipApp'
|
||||
applicationName = 'battleship'
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
########################################
|
||||
## Programming project code
|
||||
## UniBw M, 2022, 2023, 2024
|
||||
## www.unibw.de/inf2
|
||||
## (c) Mark Minas (mark.minas@unibw.de)
|
||||
########################################
|
||||
#
|
||||
# Battleship client configuration
|
||||
#
|
||||
# Specifies the map used by the opponent in single mode.
|
||||
# Single mode is activated if this property is set.
|
||||
#map.opponent=maps/map2.json
|
||||
#
|
||||
# Specifies the map used by the player in single mode.
|
||||
# The player must define their own map if this property is not set.
|
||||
map.own=maps/map1.json
|
||||
#
|
||||
# Coordinates of the shots fired by the RobotClient in the order listed.
|
||||
# Example:
|
||||
# 2, 0,\
|
||||
# 2, 1,\
|
||||
# 2, 2,\
|
||||
# 2, 3
|
||||
# defines four shots, namely at the coordinates
|
||||
# (x=2, y=0), (x=2, y=1), (x=2, y=2), and (x=2, y=3)
|
||||
robot.targets=2, 0,\
|
||||
2, 1,\
|
||||
2, 2,\
|
||||
2, 3
|
||||
#
|
||||
# Delay in milliseconds between each shot fired by the RobotClient.
|
||||
robot.delay=500
|
||||
#
|
||||
# The dimensions of the game map used in single mode.
|
||||
# 'map.width' defines the number of columns, and 'map.height' defines the number of rows.
|
||||
map.width=10
|
||||
map.height=10
|
||||
#
|
||||
# The number of ships of each length available in single mode.
|
||||
# The value is a comma-separated list where each element corresponds to the number of ships
|
||||
# with a specific length. For example:
|
||||
# ship.nums=4, 3, 2, 1
|
||||
# This configuration means:
|
||||
# - 4 ships of length 1
|
||||
# - 3 ships of length 2
|
||||
# - 2 ships of length 3
|
||||
# - 1 ship of length 4
|
||||
ship.nums=4, 3, 2, 1
|
||||
#
|
||||
# Screen settings
|
||||
#
|
||||
# Color of the text displayed at the top of the overlay.
|
||||
# The format is (red, green, blue, alpha) where each value ranges from 0 to 1.
|
||||
overlay.top.color=1, 1, 1, 1
|
||||
#
|
||||
# Application settings configuration
|
||||
# Determines whether the settings window is shown at startup.
|
||||
settings.show=false
|
||||
#
|
||||
# Specifies the width of the application window in pixels.
|
||||
settings.resolution.width=1200
|
||||
#
|
||||
# Specifies the height of the application window in pixels.
|
||||
settings.resolution.height=800
|
||||
#
|
||||
# Determines whether the application runs in full-screen mode.
|
||||
settings.full-screen=false
|
||||
#
|
||||
# Enables or disables gamma correction to improve color accuracy.
|
||||
settings.use-gamma-correction=true
|
||||
#
|
||||
# Indicates whether the statistics window is displayed during gameplay.
|
||||
statistics.show=false
|
||||
@@ -1,8 +0,0 @@
|
||||
handlers=java.util.logging.ConsoleHandler
|
||||
.level=INFO
|
||||
pp.level=FINE
|
||||
com.jme3.network.level=INFO
|
||||
;com.jme3.util.TangentBinormalGenerator.level=SEVERE
|
||||
java.util.logging.ConsoleHandler.level=FINER
|
||||
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
|
||||
;java.util.logging.SimpleFormatter.format=[%4$s %2$s] %5$s%n
|
||||
@@ -1,66 +0,0 @@
|
||||
{
|
||||
"width": 10,
|
||||
"height": 10,
|
||||
"ships": [
|
||||
{
|
||||
"length": 4,
|
||||
"x": 2,
|
||||
"y": 8,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 2,
|
||||
"y": 5,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 5,
|
||||
"y": 6,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 4,
|
||||
"y": 4,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 7,
|
||||
"y": 4,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 4,
|
||||
"y": 2,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
{
|
||||
"width": 10,
|
||||
"height": 10,
|
||||
"ships": [
|
||||
{
|
||||
"length": 4,
|
||||
"x": 0,
|
||||
"y": 5,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 0,
|
||||
"y": 9,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 2,
|
||||
"y": 6,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 4,
|
||||
"y": 12,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 4,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 1,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
{
|
||||
"width": 10,
|
||||
"height": 10,
|
||||
"ships": [
|
||||
{
|
||||
"length": 4,
|
||||
"x": 0,
|
||||
"y": 5,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 0,
|
||||
"y": 9,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 2,
|
||||
"y": 6,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 4,
|
||||
"y": 8,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 4,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 1,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
{
|
||||
"width": 10,
|
||||
"height": 10,
|
||||
"ships": [
|
||||
{
|
||||
"length": 4,
|
||||
"x": 0,
|
||||
"y": 5,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 0,
|
||||
"y": 4,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 3,
|
||||
"x": 2,
|
||||
"y": 6,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 4,
|
||||
"y": 8,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 4,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 2,
|
||||
"x": 2,
|
||||
"y": 1,
|
||||
"rot": "DOWN"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 2,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 6,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
},
|
||||
{
|
||||
"length": 1,
|
||||
"x": 8,
|
||||
"y": 0,
|
||||
"rot": "RIGHT"
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,437 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.logging.LogManager;
|
||||
|
||||
import com.jme3.app.DebugKeysAppState;
|
||||
import com.jme3.app.SimpleApplication;
|
||||
import com.jme3.app.StatsAppState;
|
||||
import com.jme3.font.BitmapFont;
|
||||
import com.jme3.font.BitmapText;
|
||||
import com.jme3.input.KeyInput;
|
||||
import com.jme3.input.MouseInput;
|
||||
import com.jme3.input.controls.ActionListener;
|
||||
import com.jme3.input.controls.KeyTrigger;
|
||||
import com.jme3.input.controls.MouseButtonTrigger;
|
||||
import com.jme3.system.AppSettings;
|
||||
import com.simsilica.lemur.GuiGlobals;
|
||||
import com.simsilica.lemur.style.BaseStyles;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import pp.battleship.client.gui.BattleAppState;
|
||||
import pp.battleship.client.gui.BgMusic;
|
||||
import pp.battleship.client.gui.EditorAppState;
|
||||
import pp.battleship.client.gui.SeaAppState;
|
||||
import pp.battleship.game.client.BattleshipClient;
|
||||
import pp.battleship.game.client.ClientGameLogic;
|
||||
import pp.battleship.game.client.ServerConnection;
|
||||
import pp.battleship.game.singlemode.BattleshipClientConfig;
|
||||
import pp.battleship.game.singlemode.ServerConnectionMockup;
|
||||
import pp.battleship.notification.ClientStateEvent;
|
||||
import pp.battleship.notification.GameEventListener;
|
||||
import pp.battleship.notification.InfoTextEvent;
|
||||
import pp.dialog.DialogBuilder;
|
||||
import pp.dialog.DialogManager;
|
||||
import pp.graphics.Draw;
|
||||
|
||||
/**
|
||||
* The main class for the Battleship client application.
|
||||
* It manages the initialization, input setup, GUI setup, and game states for the client.
|
||||
*/
|
||||
public class BattleshipApp extends SimpleApplication implements BattleshipClient, GameEventListener {
|
||||
|
||||
/**
|
||||
* Logger for logging messages within the application.
|
||||
*/
|
||||
private static final Logger LOGGER = System.getLogger(BattleshipApp.class.getName());
|
||||
|
||||
/**
|
||||
* Path to the styles script for GUI elements.
|
||||
*/
|
||||
private static final String STYLES_SCRIPT = "Interface/Lemur/pp-styles.groovy"; //NON-NLS
|
||||
|
||||
/**
|
||||
* Path to the font resource used in the GUI.
|
||||
*/
|
||||
private static final String FONT = "Interface/Fonts/Default.fnt"; //NON-NLS
|
||||
|
||||
/**
|
||||
* Path to the client configuration file, if one exists.
|
||||
*/
|
||||
private static final File CONFIG_FILE = new File("client.properties");
|
||||
|
||||
/**
|
||||
* Input mapping name for mouse clicks.
|
||||
*/
|
||||
public static final String CLICK = "CLICK";
|
||||
|
||||
/**
|
||||
* Input mapping name for the Escape key.
|
||||
*/
|
||||
private static final String ESC = "ESC";
|
||||
|
||||
/**
|
||||
* Manager for handling dialogs within the application.
|
||||
*/
|
||||
private final DialogManager dialogManager = new DialogManager(this);
|
||||
|
||||
/**
|
||||
* The server connection instance, used for communicating with the game server.
|
||||
*/
|
||||
private final ServerConnection serverConnection;
|
||||
|
||||
/**
|
||||
* Instance of the {@link Draw} class for rendering graphics.
|
||||
*/
|
||||
private Draw draw;
|
||||
|
||||
/**
|
||||
* Text display at the top of the GUI for showing information to the user.
|
||||
*/
|
||||
private BitmapText topText;
|
||||
|
||||
/**
|
||||
* Executor service for handling asynchronous tasks within the application.
|
||||
*/
|
||||
private ExecutorService executor;
|
||||
|
||||
/**
|
||||
* Handler for managing the client's game logic.
|
||||
*/
|
||||
private final ClientGameLogic logic;
|
||||
|
||||
/**
|
||||
* Configuration settings for the Battleship client application.
|
||||
*/
|
||||
private final BattleshipAppConfig config;
|
||||
|
||||
/**
|
||||
* Listener for handling actions triggered by the Escape key.
|
||||
*/
|
||||
private final ActionListener escapeListener = (name, isPressed, tpf) -> escape(isPressed);
|
||||
|
||||
static {
|
||||
// Configure logging
|
||||
LogManager manager = LogManager.getLogManager();
|
||||
try {
|
||||
manager.readConfiguration(new FileInputStream("logging.properties"));
|
||||
LOGGER.log(Level.INFO, "Successfully read logging properties"); //NON-NLS
|
||||
}
|
||||
catch (IOException e) {
|
||||
LOGGER.log(Level.INFO, e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the Battleship application.
|
||||
*
|
||||
* @param args Command-line arguments for launching the application.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
new BattleshipApp().start();
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new {@code BattleshipApp} instance.
|
||||
* Initializes the configuration, server connection, and game logic listeners.
|
||||
*/
|
||||
private BattleshipApp() {
|
||||
config = new BattleshipAppConfig();
|
||||
config.readFromIfExists(CONFIG_FILE);
|
||||
serverConnection = makeServerConnection();
|
||||
logic = new ClientGameLogic(serverConnection);
|
||||
logic.addListener(this);
|
||||
setShowSettings(config.getShowSettings());
|
||||
setSettings(makeSettings());
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates and configures application settings from the client configuration.
|
||||
*
|
||||
* @return A configured {@link AppSettings} object.
|
||||
*/
|
||||
private AppSettings makeSettings() {
|
||||
final AppSettings settings = new AppSettings(true);
|
||||
settings.setTitle(lookup("battleship.name"));
|
||||
settings.setResolution(config.getResolutionWidth(), config.getResolutionHeight());
|
||||
settings.setFullscreen(config.fullScreen());
|
||||
settings.setUseRetinaFrameBuffer(config.useRetinaFrameBuffer());
|
||||
settings.setGammaCorrection(config.useGammaCorrection());
|
||||
return settings;
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory method for creating a server connection based on the current
|
||||
* client configuration.
|
||||
*
|
||||
* @return A {@link ServerConnection} instance, which could be a real or mock server.
|
||||
*/
|
||||
private ServerConnection makeServerConnection() {
|
||||
if (config.isSingleMode())
|
||||
return new ServerConnectionMockup(this);
|
||||
return new NetworkSupport(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the dialog manager responsible for managing in-game dialogs.
|
||||
*
|
||||
* @return The {@link DialogManager} instance.
|
||||
*/
|
||||
DialogManager getDialogManager() {
|
||||
return dialogManager;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the game logic handler for the client.
|
||||
*
|
||||
* @return The {@link ClientGameLogic} instance.
|
||||
*/
|
||||
@Override
|
||||
public ClientGameLogic getGameLogic() {
|
||||
return logic;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current configuration settings for the Battleship client.
|
||||
*
|
||||
* @return The {@link BattleshipClientConfig} instance.
|
||||
*/
|
||||
@Override
|
||||
public BattleshipAppConfig getConfig() {
|
||||
return config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the application.
|
||||
* Sets up input mappings, GUI, game states, and connects to the server.
|
||||
*/
|
||||
@Override
|
||||
public void simpleInitApp() {
|
||||
setPauseOnLostFocus(false);
|
||||
draw = new Draw(assetManager);
|
||||
setupInput();
|
||||
setupStates();
|
||||
setupGui();
|
||||
serverConnection.connect();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the graphical user interface (GUI) for the application.
|
||||
*/
|
||||
private void setupGui() {
|
||||
GuiGlobals.initialize(this);
|
||||
BaseStyles.loadStyleResources(STYLES_SCRIPT);
|
||||
GuiGlobals.getInstance().getStyles().setDefaultStyle("pp"); //NON-NLS
|
||||
final BitmapFont normalFont = assetManager.loadFont(FONT); //NON-NLS
|
||||
topText = new BitmapText(normalFont);
|
||||
final int height = context.getSettings().getHeight();
|
||||
topText.setLocalTranslation(10f, height - 10f, 0f);
|
||||
topText.setColor(config.getTopColor());
|
||||
guiNode.attachChild(topText);
|
||||
}
|
||||
|
||||
/**
|
||||
* Configures input mappings and sets up listeners for user interactions.
|
||||
*/
|
||||
private void setupInput() {
|
||||
inputManager.deleteMapping(INPUT_MAPPING_EXIT);
|
||||
inputManager.setCursorVisible(false);
|
||||
inputManager.addMapping(ESC, new KeyTrigger(KeyInput.KEY_ESCAPE));
|
||||
inputManager.addMapping(CLICK, new MouseButtonTrigger(MouseInput.BUTTON_LEFT));
|
||||
inputManager.addListener(escapeListener, ESC);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes and attaches the necessary application states for the game.
|
||||
*/
|
||||
private void setupStates() {
|
||||
if (config.getShowStatistics()) {
|
||||
final BitmapFont normalFont = assetManager.loadFont(FONT); //NON-NLS
|
||||
final StatsAppState stats = new StatsAppState(guiNode, normalFont);
|
||||
stateManager.attach(stats);
|
||||
}
|
||||
flyCam.setEnabled(false);
|
||||
stateManager.detach(stateManager.getState(StatsAppState.class));
|
||||
stateManager.detach(stateManager.getState(DebugKeysAppState.class));
|
||||
|
||||
attachGameSound();
|
||||
stateManager.attachAll(new EditorAppState(), new BattleAppState(), new SeaAppState());
|
||||
attachBgMusic();
|
||||
}
|
||||
|
||||
/**
|
||||
* Attaches the game sound state and sets its initial enabled state.
|
||||
*/
|
||||
private void attachGameSound() {
|
||||
final GameSound gameSound = new GameSound();
|
||||
logic.addListener(gameSound);
|
||||
gameSound.setEnabled(GameSound.enabledInPreferences());
|
||||
stateManager.attach(gameSound);
|
||||
}
|
||||
private void attachBgMusic() {
|
||||
final BgMusic gameSound = new BgMusic();
|
||||
gameSound.setEnabled(BgMusic.enabledInPreferences());
|
||||
stateManager.attach(gameSound);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the application state every frame.
|
||||
* This method is called once per frame during the game loop.
|
||||
*
|
||||
* @param tpf Time per frame in seconds.
|
||||
*/
|
||||
@Override
|
||||
public void simpleUpdate(float tpf) {
|
||||
super.simpleUpdate(tpf);
|
||||
dialogManager.update(tpf);
|
||||
logic.update(tpf);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the Escape key action to either close the top dialog or show the main menu.
|
||||
*
|
||||
* @param isPressed Indicates whether the Escape key is pressed.
|
||||
*/
|
||||
private void escape(boolean isPressed) {
|
||||
if (!isPressed) return;
|
||||
if (dialogManager.showsDialog())
|
||||
dialogManager.escape();
|
||||
else
|
||||
new Menu(this).open();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the {@link Draw} instance used for rendering graphical elements in the game.
|
||||
*
|
||||
* @return The {@link Draw} instance.
|
||||
*/
|
||||
public Draw getDraw() {
|
||||
return draw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a request to close the application.
|
||||
* If the request is initiated by pressing ESC, this parameter is true.
|
||||
*
|
||||
* @param esc If true, the request is due to the ESC key being pressed.
|
||||
*/
|
||||
@Override
|
||||
public void requestClose(boolean esc) { /* do nothing */ }
|
||||
|
||||
/**
|
||||
* Closes the application, displaying a confirmation dialog if the client is connected to a server.
|
||||
*/
|
||||
public void closeApp() {
|
||||
if (serverConnection.isConnected())
|
||||
confirmDialog(lookup("confirm.leaving"), this::close);
|
||||
else
|
||||
close();
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the application, disconnecting from the server and stopping the application.
|
||||
*/
|
||||
private void close() {
|
||||
serverConnection.disconnect();
|
||||
stop();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the informational text displayed in the GUI.
|
||||
*
|
||||
* @param text The information text to display.
|
||||
*/
|
||||
void setInfoText(String text) {
|
||||
LOGGER.log(Level.DEBUG, "setInfoText {0}", text); //NON-NLS
|
||||
topText.setText(text);
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the informational text in the GUI based on the key received in an {@link InfoTextEvent}.
|
||||
*
|
||||
* @param event The {@link InfoTextEvent} containing the key for the text to display.
|
||||
*/
|
||||
@Override
|
||||
public void receivedEvent(InfoTextEvent event) {
|
||||
LOGGER.log(Level.DEBUG, "received info text {0}", event.key()); //NON-NLS
|
||||
setInfoText(lookup(event.key()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles client state events to update the game states accordingly.
|
||||
*
|
||||
* @param event The {@link ClientStateEvent} representing the state change.
|
||||
*/
|
||||
@Override
|
||||
public void receivedEvent(ClientStateEvent event) {
|
||||
stateManager.getState(EditorAppState.class).setEnabled(logic.showEditor());
|
||||
stateManager.getState(BattleAppState.class).setEnabled(logic.showBattle());
|
||||
stateManager.getState(SeaAppState.class).setEnabled(logic.showBattle());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the executor service used for handling multithreaded tasks.
|
||||
*
|
||||
* @return The {@link ExecutorService} instance.
|
||||
*/
|
||||
public ExecutorService getExecutor() {
|
||||
if (executor == null)
|
||||
executor = Executors.newCachedThreadPool();
|
||||
return executor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stops the application, shutting down the executor service and halting execution.
|
||||
*
|
||||
* @param waitFor If true, waits for the application to stop before returning.
|
||||
*/
|
||||
@Override
|
||||
public void stop(boolean waitFor) {
|
||||
if (executor != null) executor.shutdownNow();
|
||||
super.stop(waitFor);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a confirmation dialog with a specified question and action for the "Yes" button.
|
||||
*
|
||||
* @param question The question to display in the dialog.
|
||||
* @param yesAction The action to perform if "Yes" is selected.
|
||||
*/
|
||||
void confirmDialog(String question, Runnable yesAction) {
|
||||
DialogBuilder.simple(dialogManager)
|
||||
.setTitle(lookup("dialog.question"))
|
||||
.setText(question)
|
||||
.setOkButton(lookup("button.yes"), yesAction)
|
||||
.setNoButton(lookup("button.no"))
|
||||
.build()
|
||||
.open();
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays an error dialog with the specified error message.
|
||||
*
|
||||
* @param errorMessage The error message to display in the dialog.
|
||||
*/
|
||||
void errorDialog(String errorMessage) {
|
||||
DialogBuilder.simple(dialogManager)
|
||||
.setTitle(lookup("dialog.error"))
|
||||
.setText(errorMessage)
|
||||
.setOkButton(lookup("button.ok"))
|
||||
.build()
|
||||
.open();
|
||||
}
|
||||
}
|
||||
@@ -1,196 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import pp.battleship.game.singlemode.BattleshipClientConfig;
|
||||
|
||||
/**
|
||||
* Provides access to the Battleship application configuration.
|
||||
* Extends {@link BattleshipClientConfig} to include additional properties specific to the client,
|
||||
* particularly those related to screen settings and visual customization.
|
||||
* <p>
|
||||
* <b>Note:</b> Attributes of this class should not be marked as {@code final}
|
||||
* to ensure proper functionality when reading from a properties file.
|
||||
* </p>
|
||||
*/
|
||||
public class BattleshipAppConfig extends BattleshipClientConfig {
|
||||
|
||||
/**
|
||||
* Converts a string value found in the properties file into an object of the specified type.
|
||||
* Extends the superclass method to support conversion to {@link ColorRGBA}.
|
||||
*
|
||||
* @param value the string value to be converted
|
||||
* @param targetType the target type into which the value string is converted
|
||||
* @return the converted object of the specified type
|
||||
*/
|
||||
@Override
|
||||
protected Object convertToType(String value, Class<?> targetType) {
|
||||
if (targetType == ColorRGBA.class)
|
||||
return makeColorRGBA(value);
|
||||
return super.convertToType(value, targetType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts the specified string value to a corresponding {@link ColorRGBA} object.
|
||||
*
|
||||
* @param value the color in the format "red, green, blue, alpha" with all values in the range [0..1]
|
||||
* @return a {@link ColorRGBA} object representing the color
|
||||
* @throws IllegalArgumentException if the input string is not in the expected format
|
||||
*/
|
||||
private static ColorRGBA makeColorRGBA(String value) {
|
||||
String[] split = value.split(",", -1);
|
||||
try {
|
||||
if (split.length == 4)
|
||||
return new ColorRGBA(Float.parseFloat(split[0]),
|
||||
Float.parseFloat(split[1]),
|
||||
Float.parseFloat(split[2]),
|
||||
Float.parseFloat(split[3]));
|
||||
}
|
||||
catch (NumberFormatException e) {
|
||||
// deliberately left empty
|
||||
}
|
||||
throw new IllegalArgumentException(value + " should consist of exactly 4 numbers");
|
||||
}
|
||||
|
||||
/**
|
||||
* The width of the game view resolution in pixels.
|
||||
*/
|
||||
@Property("settings.resolution.width") //NON-NLS
|
||||
private int resolutionWidth = 1200;
|
||||
|
||||
/**
|
||||
* The height of the game view resolution in pixels.
|
||||
*/
|
||||
@Property("settings.resolution.height") //NON-NLS
|
||||
private int resolutionHeight = 800;
|
||||
|
||||
/**
|
||||
* Specifies whether the game should start in full-screen mode.
|
||||
*/
|
||||
@Property("settings.full-screen") //NON-NLS
|
||||
private boolean fullScreen = false;
|
||||
|
||||
/**
|
||||
* Specifies whether gamma correction should be enabled.
|
||||
* If enabled, the main framebuffer is configured for sRGB colors,
|
||||
* and sRGB images are linearized.
|
||||
* <p>
|
||||
* Requires a GPU that supports GL_ARB_framebuffer_sRGB; otherwise, this setting will be ignored.
|
||||
* </p>
|
||||
*/
|
||||
@Property("settings.use-gamma-correction") //NON-NLS
|
||||
private boolean useGammaCorrection = true;
|
||||
|
||||
/**
|
||||
* Specifies whether full resolution framebuffers should be used on Retina displays.
|
||||
* This setting is ignored on non-Retina platforms.
|
||||
*/
|
||||
@Property("settings.use-retina-framebuffer") //NON-NLS
|
||||
private boolean useRetinaFrameBuffer = false;
|
||||
|
||||
/**
|
||||
* Specifies whether the settings window should be shown for configuring the game.
|
||||
*/
|
||||
@Property("settings.show") //NON-NLS
|
||||
private boolean showSettings = false;
|
||||
|
||||
/**
|
||||
* Specifies whether the JME statistics window should be shown in the lower left corner of the screen.
|
||||
*/
|
||||
@Property("statistics.show") //NON-NLS
|
||||
private boolean showStatistics = false;
|
||||
|
||||
/**
|
||||
* The color of the top text during gameplay, represented as a {@link ColorRGBA} object.
|
||||
*/
|
||||
@Property("overlay.top.color") //NON-NLS
|
||||
private ColorRGBA topColor = ColorRGBA.White;
|
||||
|
||||
/**
|
||||
* Creates a default {@code BattleshipAppConfig} with predefined values.
|
||||
*/
|
||||
public BattleshipAppConfig() {
|
||||
// Default constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the width of the game view resolution in pixels.
|
||||
*
|
||||
* @return the width of the game view resolution in pixels
|
||||
*/
|
||||
public int getResolutionWidth() {
|
||||
return resolutionWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the height of the game view resolution in pixels.
|
||||
*
|
||||
* @return the height of the game view resolution in pixels
|
||||
*/
|
||||
public int getResolutionHeight() {
|
||||
return resolutionHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the game should start in full-screen mode.
|
||||
*
|
||||
* @return {@code true} if the game should start in full-screen mode; {@code false} otherwise
|
||||
*/
|
||||
public boolean fullScreen() {
|
||||
return fullScreen;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether gamma correction is enabled.
|
||||
* If enabled, the main framebuffer is configured for sRGB colors,
|
||||
* and sRGB images are linearized.
|
||||
*
|
||||
* @return {@code true} if gamma correction is enabled; {@code false} otherwise
|
||||
*/
|
||||
public boolean useGammaCorrection() {
|
||||
return useGammaCorrection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether full resolution framebuffers should be used on Retina displays.
|
||||
* This setting is ignored on non-Retina platforms.
|
||||
*
|
||||
* @return {@code true} if full resolution framebuffers should be used on Retina displays; {@code false} otherwise
|
||||
*/
|
||||
public boolean useRetinaFrameBuffer() {
|
||||
return useRetinaFrameBuffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the settings window should be shown for configuring the game.
|
||||
*
|
||||
* @return {@code true} if the settings window should be shown; {@code false} otherwise
|
||||
*/
|
||||
public boolean getShowSettings() {
|
||||
return showSettings;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the JME statistics window should be shown in the lower left corner of the screen.
|
||||
*
|
||||
* @return {@code true} if the statistics window should be shown; {@code false} otherwise
|
||||
*/
|
||||
public boolean getShowStatistics() {
|
||||
return showStatistics;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the color of the top text during gameplay as a {@link ColorRGBA} object.
|
||||
*
|
||||
* @return the color of the top text during gameplay
|
||||
*/
|
||||
public ColorRGBA getTopColor() {
|
||||
return topColor;
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import com.jme3.app.Application;
|
||||
import com.jme3.app.state.AbstractAppState;
|
||||
import com.jme3.app.state.AppStateManager;
|
||||
import pp.battleship.game.client.ClientGameLogic;
|
||||
|
||||
/**
|
||||
* Abstract class representing a state in the Battleship game.
|
||||
* Extends the AbstractAppState from jMonkeyEngine to manage state behavior.
|
||||
*/
|
||||
public abstract class BattleshipAppState extends AbstractAppState {
|
||||
private BattleshipApp app;
|
||||
|
||||
/**
|
||||
* Creates a new BattleshipAppState that is initially disabled.
|
||||
*
|
||||
* @see #setEnabled(boolean)
|
||||
*/
|
||||
protected BattleshipAppState() {
|
||||
setEnabled(false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the state manager and application.
|
||||
*
|
||||
* @param stateManager The state manager
|
||||
* @param application The application instance
|
||||
*/
|
||||
@Override
|
||||
public void initialize(AppStateManager stateManager, Application application) {
|
||||
super.initialize(stateManager, application);
|
||||
this.app = (BattleshipApp) application;
|
||||
if (isEnabled()) enableState();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the BattleshipApp instance associated with this BattleshipAppState.
|
||||
*
|
||||
* @return The BattleshipApp instance.
|
||||
*/
|
||||
public BattleshipApp getApp() {
|
||||
return app;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the client game logic handler.
|
||||
*
|
||||
* @return the client game logic handler
|
||||
*/
|
||||
public ClientGameLogic getGameLogic() {
|
||||
return app.getGameLogic();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if any dialog is currently displayed.
|
||||
*
|
||||
* @return true if any dialog is currently shown, false otherwise
|
||||
*/
|
||||
public boolean showsDialog() {
|
||||
return app.getDialogManager().showsDialog();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the enabled state of the BattleshipAppState.
|
||||
* If the new state is the same as the current state, the method returns.
|
||||
*
|
||||
* @param enabled The new enabled state.
|
||||
*/
|
||||
@Override
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (isEnabled() == enabled) return;
|
||||
super.setEnabled(enabled);
|
||||
if (app != null) {
|
||||
if (enabled)
|
||||
enableState();
|
||||
else
|
||||
disableState();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is called when the state is enabled.
|
||||
* It is meant to be overridden by subclasses to perform
|
||||
* specific actions when the state is enabled.
|
||||
*/
|
||||
protected abstract void enableState();
|
||||
|
||||
/**
|
||||
* This method is called when the state is disabled.
|
||||
* It is meant to be overridden by subclasses to perform
|
||||
* specific actions when the state is disabled.
|
||||
*/
|
||||
protected abstract void disableState();
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.prefs.Preferences;
|
||||
|
||||
import com.jme3.app.Application;
|
||||
import com.jme3.app.state.AbstractAppState;
|
||||
import com.jme3.app.state.AppStateManager;
|
||||
import com.jme3.asset.AssetLoadException;
|
||||
import com.jme3.asset.AssetNotFoundException;
|
||||
import com.jme3.audio.AudioData;
|
||||
import com.jme3.audio.AudioNode;
|
||||
|
||||
import pp.battleship.notification.GameEventListener;
|
||||
import pp.battleship.notification.SoundEvent;
|
||||
import static pp.util.PreferencesUtils.getPreferences;
|
||||
|
||||
/**
|
||||
* An application state that plays sounds.
|
||||
*/
|
||||
public class GameSound extends AbstractAppState implements GameEventListener {
|
||||
private static final Logger LOGGER = System.getLogger(GameSound.class.getName());
|
||||
private static final Preferences PREFERENCES = getPreferences(GameSound.class);
|
||||
private static final String ENABLED_PREF = "enabled"; //NON-NLS
|
||||
|
||||
private AudioNode splashSound;
|
||||
private AudioNode shipDestroyedSound;
|
||||
private AudioNode explosionSound;
|
||||
|
||||
/**
|
||||
* Checks if sound is enabled in the preferences.
|
||||
*
|
||||
* @return {@code true} if sound is enabled, {@code false} otherwise.
|
||||
*/
|
||||
public static boolean enabledInPreferences() {
|
||||
return PREFERENCES.getBoolean(ENABLED_PREF, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Toggles the game sound on or off.
|
||||
*/
|
||||
public void toggleSound() {
|
||||
setEnabled(!isEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the enabled state of this AppState.
|
||||
* Overrides {@link com.jme3.app.state.AbstractAppState#setEnabled(boolean)}
|
||||
*
|
||||
* @param enabled {@code true} to enable the AppState, {@code false} to disable it.
|
||||
*/
|
||||
@Override
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (isEnabled() == enabled) return;
|
||||
super.setEnabled(enabled);
|
||||
LOGGER.log(Level.INFO, "Sound enabled: {0}", enabled); //NON-NLS
|
||||
PREFERENCES.putBoolean(ENABLED_PREF, enabled);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the sound effects for the game.
|
||||
* Overrides {@link AbstractAppState#initialize(AppStateManager, Application)}
|
||||
*
|
||||
* @param stateManager The state manager
|
||||
* @param app The application
|
||||
*/
|
||||
@Override
|
||||
public void initialize(AppStateManager stateManager, Application app) {
|
||||
super.initialize(stateManager, app);
|
||||
shipDestroyedSound = loadSound(app, "Sound/Effects/sunken.wav"); //NON-NLS
|
||||
splashSound = loadSound(app, "Sound/Effects/splash.wav"); //NON-NLS
|
||||
explosionSound = loadSound(app, "Sound/Effects/explosion.wav"); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a sound from the specified file.
|
||||
*
|
||||
* @param app The application
|
||||
* @param name The name of the sound file.
|
||||
* @return The loaded AudioNode.
|
||||
*/
|
||||
private AudioNode loadSound(Application app, String name) {
|
||||
try {
|
||||
final AudioNode sound = new AudioNode(app.getAssetManager(), name, AudioData.DataType.Buffer);
|
||||
sound.setLooping(false);
|
||||
sound.setPositional(false);
|
||||
return sound;
|
||||
}
|
||||
catch (AssetLoadException | AssetNotFoundException ex) {
|
||||
LOGGER.log(Level.ERROR, ex.getMessage(), ex);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Plays the splash sound effect.
|
||||
*/
|
||||
public void splash() {
|
||||
if (isEnabled() && splashSound != null)
|
||||
splashSound.playInstance();
|
||||
}
|
||||
|
||||
/**
|
||||
* Plays the explosion sound effect.
|
||||
*/
|
||||
public void explosion() {
|
||||
if (isEnabled() && explosionSound != null)
|
||||
explosionSound.playInstance();
|
||||
}
|
||||
|
||||
/**
|
||||
* Plays sound effect when a ship has been destroyed.
|
||||
*/
|
||||
public void shipDestroyed() {
|
||||
if (isEnabled() && shipDestroyedSound != null)
|
||||
shipDestroyedSound.playInstance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void receivedEvent(SoundEvent event) {
|
||||
switch (event.sound()) {
|
||||
case EXPLOSION -> explosion();
|
||||
case SPLASH -> splash();
|
||||
case DESTROYED_SHIP -> shipDestroyed();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,159 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.prefs.Preferences;
|
||||
|
||||
import com.simsilica.lemur.Button;
|
||||
import com.simsilica.lemur.Checkbox;
|
||||
import com.simsilica.lemur.Label;
|
||||
import com.simsilica.lemur.style.ElementId;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import pp.battleship.client.gui.BgMusic;
|
||||
import pp.battleship.client.gui.VolumeSlider;
|
||||
import pp.dialog.Dialog;
|
||||
import pp.dialog.StateCheckboxModel;
|
||||
import pp.dialog.TextInputDialog;
|
||||
import static pp.util.PreferencesUtils.getPreferences;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* The Menu class represents the main menu in the Battleship game application.
|
||||
* It extends the Dialog class and provides functionalities for loading, saving,
|
||||
* returning to the game, and quitting the application.
|
||||
*/
|
||||
class Menu extends Dialog {
|
||||
private static final Preferences PREFERENCES = getPreferences(Menu.class);
|
||||
private static final String LAST_PATH = "last.file.path";
|
||||
private final BattleshipApp app;
|
||||
private final Button loadButton = new Button(lookup("menu.map.load"));
|
||||
private final Button saveButton = new Button(lookup("menu.map.save"));
|
||||
private final VolumeSlider slider;
|
||||
|
||||
/**
|
||||
* Constructs the Menu dialog for the Battleship application.
|
||||
*
|
||||
* @param app the BattleshipApp instance
|
||||
*/
|
||||
public Menu(BattleshipApp app) {
|
||||
super(app.getDialogManager());
|
||||
this.app = app;
|
||||
slider = new VolumeSlider(app.getStateManager().getState(BgMusic.class));
|
||||
addChild(new Label(lookup("battleship.name"), new ElementId("header"))); //NON-NLS
|
||||
// addChild(new Checkbox(lookup("menu.sound-enabled"),
|
||||
// new StateCheckboxModel(app, GameSound.class)));
|
||||
addChild(new Checkbox(lookup("menu.sound-enabled"), new StateCheckboxModel(app, GameSound.class)));
|
||||
|
||||
addChild(new Checkbox(lookup("menu.background-sound-enabled"), new StateCheckboxModel(app, BgMusic.class)));
|
||||
|
||||
addChild(slider);
|
||||
|
||||
addChild(loadButton)
|
||||
.addClickCommands(s -> ifTopDialog(this::loadDialog));
|
||||
addChild(saveButton)
|
||||
.addClickCommands(s -> ifTopDialog(this::saveDialog));
|
||||
addChild(new Button(lookup("menu.return-to-game")))
|
||||
.addClickCommands(s -> ifTopDialog(this::close));
|
||||
addChild(new Button(lookup("menu.quit")))
|
||||
.addClickCommands(s -> ifTopDialog(app::closeApp));
|
||||
update();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the state of the load and save buttons based on the game logic.
|
||||
*/
|
||||
@Override
|
||||
public void update() {
|
||||
loadButton.setEnabled(app.getGameLogic().mayLoadMap());
|
||||
saveButton.setEnabled(app.getGameLogic().maySaveMap());
|
||||
}
|
||||
@Override
|
||||
public void update(float delta) {
|
||||
slider.update();
|
||||
}
|
||||
|
||||
/**
|
||||
* As an escape action, this method closes the menu if it is the top dialog.
|
||||
*/
|
||||
@Override
|
||||
public void escape() {
|
||||
close();
|
||||
}
|
||||
|
||||
/**
|
||||
* Functional interface for file actions.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
private interface FileAction {
|
||||
/**
|
||||
* Executes a file action.
|
||||
*
|
||||
* @param file the file to be processed
|
||||
* @throws IOException if an I/O error occurs
|
||||
*/
|
||||
void run(File file) throws IOException;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the file action for the provided dialog.
|
||||
*
|
||||
* @param fileAction the file action to be executed
|
||||
* @param dialog the dialog providing the file input
|
||||
*/
|
||||
private void handle(FileAction fileAction, TextInputDialog dialog) {
|
||||
try {
|
||||
final String path = dialog.getInput().getText();
|
||||
PREFERENCES.put(LAST_PATH, path);
|
||||
fileAction.run(new File(path));
|
||||
dialog.close();
|
||||
}
|
||||
catch (IOException e) {
|
||||
app.errorDialog(e.getLocalizedMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows a file dialog for loading or saving files.
|
||||
*
|
||||
* @param fileAction the action to perform with the selected file
|
||||
* @param label the label for the dialog
|
||||
*/
|
||||
private void fileDialog(FileAction fileAction, String label) {
|
||||
final TextInputDialog dialog =
|
||||
TextInputDialog.builder(app.getDialogManager())
|
||||
.setLabel(lookup("label.file"))
|
||||
.setFocus(TextInputDialog::getInput)
|
||||
.setTitle(label)
|
||||
.setOkButton(lookup("button.ok"), d -> handle(fileAction, d))
|
||||
.setNoButton(lookup("button.cancel"))
|
||||
.setOkClose(false)
|
||||
.build();
|
||||
final String path = PREFERENCES.get(LAST_PATH, null);
|
||||
if (path != null)
|
||||
dialog.getInput().setText(path.trim());
|
||||
dialog.open();
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the load dialog for loading maps.
|
||||
*/
|
||||
private void loadDialog() {
|
||||
fileDialog(app.getGameLogic()::loadMap, lookup("menu.map.load"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the save dialog for saving maps.
|
||||
*/
|
||||
private void saveDialog() {
|
||||
fileDialog(app.getGameLogic()::saveMap, lookup("menu.map.save"));
|
||||
}
|
||||
}
|
||||
@@ -1,174 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.Future;
|
||||
|
||||
import com.simsilica.lemur.Checkbox;
|
||||
import com.simsilica.lemur.Container;
|
||||
import com.simsilica.lemur.Label;
|
||||
import com.simsilica.lemur.TextField;
|
||||
import com.simsilica.lemur.component.SpringGridLayout;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import pp.battleship.client.server.BattleshipSelfhostServer;
|
||||
import pp.dialog.Dialog;
|
||||
import pp.dialog.DialogBuilder;
|
||||
import pp.dialog.SimpleDialog;
|
||||
|
||||
/**
|
||||
* Represents a dialog for setting up a network connection in the Battleship game.
|
||||
* Allows users to specify the host and port for connecting to a game server.
|
||||
*/
|
||||
class NetworkDialog extends SimpleDialog {
|
||||
private static final Logger LOGGER = System.getLogger(NetworkDialog.class.getName());
|
||||
private static final String LOCALHOST = "localhost"; //NON-NLS
|
||||
private static final String DEFAULT_PORT = "1234"; //NON-NLS
|
||||
private final NetworkSupport network;
|
||||
private final TextField host = new TextField(LOCALHOST);
|
||||
private final TextField port = new TextField(DEFAULT_PORT);
|
||||
private static final Checkbox HOST = new Checkbox(lookup("server.host"));
|
||||
private String hostname;
|
||||
private int portNumber;
|
||||
private Future<Object> connectionFuture;
|
||||
private Dialog progressDialog;
|
||||
|
||||
/**
|
||||
* Constructs a new NetworkDialog.
|
||||
*
|
||||
* @param network The NetworkSupport instance to be used for network operations.
|
||||
*/
|
||||
NetworkDialog(NetworkSupport network) {
|
||||
super(network.getApp().getDialogManager());
|
||||
this.network = network;
|
||||
host.setSingleLine(true);
|
||||
host.setPreferredWidth(400f);
|
||||
port.setSingleLine(true);
|
||||
|
||||
final BattleshipApp app = network.getApp();
|
||||
final Container input = new Container(new SpringGridLayout());
|
||||
input.addChild(new Label(lookup("host.name") + ": "));
|
||||
input.addChild(host, 1);
|
||||
input.addChild(new Label(lookup("port.number") + ": "));
|
||||
input.addChild(port, 1);
|
||||
input.addChild(HOST).addClickCommands(s -> ifTopDialog(this::startClientServer));
|
||||
|
||||
DialogBuilder.simple(app.getDialogManager())
|
||||
.setTitle(lookup("server.dialog"))
|
||||
.setExtension(d -> d.addChild(input))
|
||||
.setOkButton(lookup("button.connect"), d -> connect())
|
||||
.setNoButton(lookup("button.cancel"), app::closeApp)
|
||||
.setOkClose(false)
|
||||
.setNoClose(false)
|
||||
.build(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the action for the connect button in the connection dialog.
|
||||
* Tries to parse the port number and initiate connection to the server.
|
||||
*/
|
||||
private void connect() {
|
||||
LOGGER.log(Level.INFO, "connect to host={0}, port={1}", host, port); //NON-NLS
|
||||
try {
|
||||
hostname = host.getText().trim().isEmpty() ? LOCALHOST : host.getText();
|
||||
portNumber = Integer.parseInt(port.getText());
|
||||
openProgressDialog();
|
||||
connectionFuture = network.getApp().getExecutor().submit(this::initNetwork);
|
||||
}
|
||||
catch (NumberFormatException e) {
|
||||
network.getApp().errorDialog(lookup("port.must.be.integer"));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a dialog indicating that the connection is in progress.
|
||||
*/
|
||||
private void openProgressDialog() {
|
||||
progressDialog = DialogBuilder.simple(network.getApp().getDialogManager())
|
||||
.setText(lookup("label.connecting"))
|
||||
.build();
|
||||
progressDialog.open();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to initialize the network connection.
|
||||
*
|
||||
* @throws RuntimeException If an error occurs when creating the client.
|
||||
*/
|
||||
private Object initNetwork() {
|
||||
try {
|
||||
network.initNetwork(hostname, portNumber);
|
||||
return null;
|
||||
}
|
||||
catch (Exception e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is called by {@linkplain pp.dialog.DialogManager#update(float)} for periodically
|
||||
* updating this dialog. T
|
||||
*/
|
||||
@Override
|
||||
public void update(float delta) {
|
||||
if (connectionFuture != null && connectionFuture.isDone())
|
||||
try {
|
||||
connectionFuture.get();
|
||||
success();
|
||||
}
|
||||
catch (ExecutionException e) {
|
||||
failure(e.getCause());
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
LOGGER.log(Level.WARNING, "Interrupted!", e); //NON-NLS
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a successful connection to the game server.
|
||||
*/
|
||||
private void success() {
|
||||
connectionFuture = null;
|
||||
progressDialog.close();
|
||||
this.close();
|
||||
network.getApp().setInfoText(lookup("wait.for.an.opponent"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a failed connection attempt.
|
||||
*
|
||||
* @param e The cause of the failure.
|
||||
*/
|
||||
private void failure(Throwable e) {
|
||||
connectionFuture = null;
|
||||
progressDialog.close();
|
||||
network.getApp().errorDialog(lookup("server.connection.failed"));
|
||||
network.getApp().setInfoText(e.getLocalizedMessage());
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the server of the client in a new thread and catches connectivity issues.
|
||||
*/
|
||||
private void startClientServer() {
|
||||
HOST.setEnabled(false);
|
||||
Thread serverThread = new Thread(() -> {
|
||||
try {
|
||||
BattleshipSelfhostServer.main(null);
|
||||
} catch (Exception e) {
|
||||
HOST.setEnabled(true);
|
||||
LOGGER.log(Level.ERROR, "Server could not be started", e);
|
||||
network.getApp().errorDialog("Could not start server: " + e.getMessage());
|
||||
}
|
||||
});
|
||||
serverThread.start();
|
||||
}
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import com.jme3.network.Client;
|
||||
import com.jme3.network.ClientStateListener;
|
||||
import com.jme3.network.Message;
|
||||
import com.jme3.network.MessageListener;
|
||||
import com.jme3.network.Network;
|
||||
import pp.battleship.game.client.ServerConnection;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.message.server.ServerMessage;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
|
||||
/**
|
||||
* Manages the network connection for the Battleship application.
|
||||
* Handles connecting to and disconnecting from the server, and sending messages.
|
||||
*/
|
||||
class NetworkSupport implements MessageListener<Client>, ClientStateListener, ServerConnection {
|
||||
private static final Logger LOGGER = System.getLogger(NetworkSupport.class.getName());
|
||||
private final BattleshipApp app;
|
||||
private Client client;
|
||||
|
||||
/**
|
||||
* Constructs a NetworkSupport instance for the given Battleship application.
|
||||
*
|
||||
* @param app The Battleship application instance.
|
||||
*/
|
||||
public NetworkSupport(BattleshipApp app) {
|
||||
this.app = app;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Battleship application instance.
|
||||
*
|
||||
* @return Battleship application instance
|
||||
*/
|
||||
BattleshipApp getApp() {
|
||||
return app;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there is a connection to the game server.
|
||||
*
|
||||
* @return true if there is a connection to the game server, false otherwise.
|
||||
*/
|
||||
@Override
|
||||
public boolean isConnected() {
|
||||
return client != null && client.isConnected();
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to join the game if there is no connection yet.
|
||||
* Opens a dialog for the user to enter the host and port information.
|
||||
*/
|
||||
@Override
|
||||
public void connect() {
|
||||
if (client == null)
|
||||
new NetworkDialog(this).open();
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the client connection.
|
||||
*/
|
||||
@Override
|
||||
public void disconnect() {
|
||||
if (client == null) return;
|
||||
client.close();
|
||||
client = null;
|
||||
LOGGER.log(Level.INFO, "client closed"); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the network connection.
|
||||
*
|
||||
* @param host The server's address.
|
||||
* @param port The server's port.
|
||||
* @throws IOException If an I/O error occurs when creating the client.
|
||||
*/
|
||||
void initNetwork(String host, int port) throws IOException {
|
||||
if (client != null)
|
||||
throw new IllegalStateException("trying to join a game again");
|
||||
client = Network.connectToServer(host, port);
|
||||
client.start();
|
||||
client.addMessageListener(this);
|
||||
client.addClientStateListener(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a message is received from the server.
|
||||
*
|
||||
* @param client The client instance that received the message.
|
||||
* @param message The message received from the server.
|
||||
*/
|
||||
@Override
|
||||
public void messageReceived(Client client, Message message) {
|
||||
LOGGER.log(Level.INFO, "message received from server: {0}", message); //NON-NLS
|
||||
if (message instanceof ServerMessage serverMessage)
|
||||
app.enqueue(() -> serverMessage.accept(app.getGameLogic()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when the client has successfully connected to the server.
|
||||
*
|
||||
* @param client The client that connected to the server.
|
||||
*/
|
||||
@Override
|
||||
public void clientConnected(Client client) {
|
||||
LOGGER.log(Level.INFO, "Client connected: {0}", client); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when the client is disconnected from the server.
|
||||
*
|
||||
* @param client The client that was disconnected.
|
||||
* @param disconnectInfo Information about the disconnection.
|
||||
*/
|
||||
@Override
|
||||
public void clientDisconnected(Client client, DisconnectInfo disconnectInfo) {
|
||||
LOGGER.log(Level.INFO, "Client {0} disconnected: {1}", client, disconnectInfo); //NON-NLS
|
||||
if (this.client != client)
|
||||
throw new IllegalArgumentException("parameter value must be client");
|
||||
LOGGER.log(Level.INFO, "client still connected: {0}", client.isConnected()); //NON-NLS
|
||||
this.client = null;
|
||||
disconnect();
|
||||
app.enqueue(() -> app.setInfoText(lookup("lost.connection.to.server")));
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends the specified message to the server.
|
||||
*
|
||||
* @param message The message to be sent to the server.
|
||||
*/
|
||||
@Override
|
||||
public void send(ClientMessage message) {
|
||||
LOGGER.log(Level.INFO, "sending {0}", message); //NON-NLS
|
||||
if (client == null)
|
||||
app.errorDialog(lookup("lost.connection.to.server"));
|
||||
else
|
||||
client.send(message);
|
||||
}
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.input.controls.ActionListener;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.system.AppSettings;
|
||||
import pp.battleship.client.BattleshipAppState;
|
||||
import pp.battleship.model.IntPoint;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import static pp.battleship.client.BattleshipApp.CLICK;
|
||||
|
||||
/**
|
||||
* Represents the state responsible for managing the battle interface within the Battleship game.
|
||||
* This state handles the display and interaction of the battle map, including the opponent's map.
|
||||
* It manages GUI components, input events, and the layout of the interface when this state is enabled.
|
||||
*/
|
||||
public class BattleAppState extends BattleshipAppState {
|
||||
private static final Logger LOGGER = System.getLogger(BattleAppState.class.getName());
|
||||
private static final float DEPTH = 0f;
|
||||
private static final float GAP = 20f;
|
||||
|
||||
/**
|
||||
* A listener for handling click events in the battle interface.
|
||||
* When a click is detected, it triggers the corresponding actions on the opponent's map.
|
||||
*/
|
||||
private final ActionListener clickListener = (name, isPressed, tpf) -> click(isPressed);
|
||||
|
||||
/**
|
||||
* The root node for all GUI components in the battle state.
|
||||
*/
|
||||
private final Node battleNode = new Node("Battle"); //NON-NLS
|
||||
|
||||
/**
|
||||
* A view representing the opponent's map in the GUI.
|
||||
*/
|
||||
private MapView opponentMapView;
|
||||
|
||||
/**
|
||||
* Enables the battle state by initializing, laying out, and adding GUI components.
|
||||
* Attaches the components to the GUI node and registers input listeners.
|
||||
*/
|
||||
@Override
|
||||
protected void enableState() {
|
||||
battleNode.detachAllChildren();
|
||||
initializeGuiComponents();
|
||||
layoutGuiComponents();
|
||||
addGuiComponents();
|
||||
getApp().getGuiNode().attachChild(battleNode);
|
||||
getApp().getInputManager().addListener(clickListener, CLICK);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the battle state by removing GUI components and unregistering input listeners.
|
||||
* Also handles cleanup of resources, such as the opponent's map view.
|
||||
*/
|
||||
@Override
|
||||
protected void disableState() {
|
||||
getApp().getGuiNode().detachChild(battleNode);
|
||||
getApp().getInputManager().removeListener(clickListener);
|
||||
if (opponentMapView != null) {
|
||||
opponentMapView.unregister();
|
||||
opponentMapView = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the GUI components used in the battle state.
|
||||
* Creates the opponent's map view and adds a grid overlay to it.
|
||||
*/
|
||||
private void initializeGuiComponents() {
|
||||
opponentMapView = new MapView(getGameLogic().getOpponentMap(), getApp());
|
||||
opponentMapView.addGrid();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the initialized GUI components to the battle node.
|
||||
* Currently, it attaches the opponent's map view to the node.
|
||||
*/
|
||||
private void addGuiComponents() {
|
||||
battleNode.attachChild(opponentMapView.getNode());
|
||||
}
|
||||
|
||||
/**
|
||||
* Lays out the GUI components within the window, positioning them appropriately.
|
||||
* The opponent's map view is positioned based on the window's dimensions and a specified gap.
|
||||
*/
|
||||
private void layoutGuiComponents() {
|
||||
final AppSettings s = getApp().getContext().getSettings();
|
||||
final float mapWidth = opponentMapView.getWidth();
|
||||
final float mapHeight = opponentMapView.getHeight();
|
||||
final float windowWidth = s.getWidth();
|
||||
final float windowHeight = s.getHeight();
|
||||
|
||||
opponentMapView.getNode().setLocalTranslation(windowWidth - mapWidth - GAP,
|
||||
windowHeight - mapHeight - GAP,
|
||||
DEPTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles click events in the battle interface. If the event indicates a click (not a release),
|
||||
* it translates the cursor position to the model's coordinate system and triggers the game logic
|
||||
* for interacting with the opponent's map.
|
||||
*
|
||||
* @param isPressed whether the mouse button is currently pressed (true) or released (false)
|
||||
*/
|
||||
private void click(boolean isPressed) {
|
||||
if (!isPressed || showsDialog())
|
||||
return;
|
||||
final IntPoint cursorPos = opponentMapView.mouseToModel(getApp().getInputManager().getCursorPosition());
|
||||
LOGGER.log(Level.DEBUG, "click: {0}", cursorPos); //NON-NLS
|
||||
getGameLogic().clickOpponentMap(cursorPos);
|
||||
}
|
||||
}
|
||||
@@ -1,121 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.prefs.Preferences;
|
||||
|
||||
import com.jme3.app.Application;
|
||||
import com.jme3.app.state.AbstractAppState;
|
||||
import com.jme3.app.state.AppStateManager;
|
||||
import com.jme3.asset.AssetLoadException;
|
||||
import com.jme3.asset.AssetNotFoundException;
|
||||
import com.jme3.audio.AudioData;
|
||||
import com.jme3.audio.AudioNode;
|
||||
|
||||
import static pp.util.PreferencesUtils.getPreferences;
|
||||
|
||||
/**
|
||||
* An application state that plays sounds.
|
||||
*/
|
||||
public class BgMusic extends AbstractAppState{
|
||||
private static final Logger LOGGER = System.getLogger(BgMusic.class.getName());
|
||||
private static final Preferences PREFERENCES = getPreferences(BgMusic.class);
|
||||
private static final String ENABLED_PREF = "enabled"; //NON-NLS
|
||||
private static final String VOLUME_PREF = "volume"; //NON-NLS
|
||||
|
||||
private AudioNode music;
|
||||
|
||||
/**
|
||||
* Checks if sound is enabled in the preferences.
|
||||
*
|
||||
* @return {@code true} if sound is enabled, {@code false} otherwise.
|
||||
*/
|
||||
public static boolean enabledInPreferences() {
|
||||
return PREFERENCES.getBoolean(ENABLED_PREF, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if sound is enabled in the preferences.
|
||||
*
|
||||
* @return //TODO
|
||||
*/
|
||||
public static float volumeInPreferences() {
|
||||
return PREFERENCES.getFloat(VOLUME_PREF, 0.5f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the sound effects for the game.
|
||||
* Overrides {@link AbstractAppState#initialize(AppStateManager, Application)}
|
||||
*
|
||||
* @param stateManager The state manager
|
||||
* @param app The application
|
||||
*/
|
||||
@Override
|
||||
public void initialize(AppStateManager stateManager, Application app) {
|
||||
super.initialize(stateManager, app);
|
||||
music = loadSound(app, "Sound/Music/bgMusic.ogg");
|
||||
setVolume(volumeInPreferences());
|
||||
music.setLooping(true);
|
||||
if (isEnabled() && music != null) {
|
||||
music.play();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a sound from the specified file.
|
||||
*
|
||||
* @param app The application
|
||||
* @param name The name of the sound file.
|
||||
* @return The loaded AudioNode.
|
||||
*/
|
||||
private AudioNode loadSound(Application app, String name) {
|
||||
try {
|
||||
final AudioNode sound = new AudioNode(app.getAssetManager(), name, AudioData.DataType.Buffer);
|
||||
sound.setLooping(false);
|
||||
sound.setPositional(false);
|
||||
return sound;
|
||||
}
|
||||
catch (AssetLoadException | AssetNotFoundException ex) {
|
||||
LOGGER.log(Level.ERROR, ex.getMessage(), ex);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** TODO
|
||||
* Sets the enabled state of this AppState.
|
||||
* Overrides {@link com.jme3.app.state.AbstractAppState#setEnabled(boolean)}
|
||||
*
|
||||
* @param enabled {@code true} to enable the AppState, {@code false} to disable it.
|
||||
*/
|
||||
@Override
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (isEnabled() == enabled) return;
|
||||
else if(!isEnabled() && enabled) {
|
||||
if (music != null) music.play();
|
||||
} else if (isEnabled() && !enabled) {
|
||||
if (music != null) music.stop();
|
||||
}
|
||||
super.setEnabled(enabled);
|
||||
LOGGER.log(Level.INFO, "Sound enabled: {0}", enabled); //NON-NLS
|
||||
PREFERENCES.putBoolean(ENABLED_PREF, enabled);
|
||||
}
|
||||
|
||||
/**
|
||||
* Toggles the game sound on or off.
|
||||
*/
|
||||
public void toggleSound() {
|
||||
setEnabled(!isEnabled());
|
||||
}
|
||||
|
||||
public void setVolume(float vol){
|
||||
music.setVolume(vol);
|
||||
PREFERENCES.putFloat(VOLUME_PREF, vol);
|
||||
}
|
||||
}
|
||||
@@ -1,173 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import com.jme3.input.controls.ActionListener;
|
||||
import com.jme3.math.Vector2f;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.system.AppSettings;
|
||||
import com.simsilica.lemur.Button;
|
||||
import com.simsilica.lemur.Container;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import static pp.battleship.client.BattleshipApp.CLICK;
|
||||
import pp.battleship.client.BattleshipAppState;
|
||||
|
||||
/**
|
||||
* EditorState manages the editor mode in the Battleship game,
|
||||
* allowing players to place and rotate ships.
|
||||
*/
|
||||
public class EditorAppState extends BattleshipAppState {
|
||||
private static final Logger LOGGER = System.getLogger(EditorAppState.class.getName());
|
||||
private static final float DEPTH = 0f;
|
||||
private static final float GAP = 20f;
|
||||
|
||||
private final ActionListener clickListener = (name, isPressed, tpf) -> click(isPressed);
|
||||
private final Node editorNode = new Node("Editor"); //NON-NLS
|
||||
private Container buttonContainer;
|
||||
private Button rotateButton;
|
||||
private Button readyButton;
|
||||
private MapView ownMapView;
|
||||
private MapView harborView;
|
||||
private Vector2f oldCursorPosition;
|
||||
|
||||
/**
|
||||
* Enables the editor state by attaching necessary nodes and listeners.
|
||||
*/
|
||||
@Override
|
||||
protected void enableState() {
|
||||
editorNode.detachAllChildren();
|
||||
initializeGuiComponents();
|
||||
addGuiComponents();
|
||||
layoutGuiComponents();
|
||||
getApp().getGuiNode().attachChild(editorNode);
|
||||
getApp().getInputManager().addListener(clickListener, CLICK);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the editor state by detaching nodes and removing listeners.
|
||||
*/
|
||||
@Override
|
||||
protected void disableState() {
|
||||
getApp().getGuiNode().detachChild(editorNode);
|
||||
getApp().getInputManager().removeListener(clickListener);
|
||||
if (ownMapView != null) {
|
||||
ownMapView.unregister();
|
||||
ownMapView = null;
|
||||
}
|
||||
if (harborView != null) {
|
||||
harborView.unregister();
|
||||
harborView = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the editor state, handling cursor movement and enabling buttons.
|
||||
*
|
||||
* @param tpf Time per frame
|
||||
*/
|
||||
@Override
|
||||
public void update(float tpf) {
|
||||
super.update(tpf);
|
||||
cursorMovement();
|
||||
enableButtons();
|
||||
}
|
||||
|
||||
/**
|
||||
* Enables or disables buttons based on the logic state.
|
||||
*/
|
||||
private void enableButtons() {
|
||||
readyButton.setEnabled(getGameLogic().isMapComplete());
|
||||
rotateButton.setEnabled(getGameLogic().movingShip());
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles cursor movement for previewing ship placement.
|
||||
*/
|
||||
private void cursorMovement() {
|
||||
if (!getGameLogic().movingShip() || ownMapView == null || showsDialog())
|
||||
return;
|
||||
final Vector2f cursorPosition = getApp().getInputManager().getCursorPosition();
|
||||
if (!cursorPosition.equals(oldCursorPosition)) {
|
||||
oldCursorPosition = new Vector2f(cursorPosition);
|
||||
getGameLogic().movePreview(ownMapView.mouseToModel(cursorPosition));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the GUI components for the editor.
|
||||
*/
|
||||
private void initializeGuiComponents() {
|
||||
ownMapView = new MapView(getGameLogic().getOwnMap(), getApp());
|
||||
harborView = new MapView(getGameLogic().getHarbor(), getApp());
|
||||
ownMapView.addGrid();
|
||||
rotateButton = new Button(lookup("button.rotate"));
|
||||
readyButton = new Button(lookup("button.ready"));
|
||||
rotateButton.addClickCommands(e -> {
|
||||
if (!showsDialog())
|
||||
getGameLogic().rotateShip();
|
||||
});
|
||||
readyButton.addClickCommands(e -> {
|
||||
if (!showsDialog())
|
||||
getGameLogic().mapFinished();
|
||||
});
|
||||
buttonContainer = new Container();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the GUI components to the editor node.
|
||||
*/
|
||||
private void addGuiComponents() {
|
||||
buttonContainer.addChild(rotateButton, 0, 0);
|
||||
buttonContainer.addChild(readyButton, 0, 1);
|
||||
editorNode.attachChild(ownMapView.getNode());
|
||||
editorNode.attachChild(harborView.getNode());
|
||||
editorNode.attachChild(buttonContainer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Lays out the GUI components on the screen.
|
||||
*/
|
||||
private void layoutGuiComponents() {
|
||||
final AppSettings s = getApp().getContext().getSettings();
|
||||
final float harborWidth = harborView.getWidth();
|
||||
final float harborHeight = harborView.getHeight();
|
||||
final float ownMapWidth = ownMapView.getWidth();
|
||||
final float ownMapHeight = ownMapView.getHeight();
|
||||
final float windowWidth = s.getWidth();
|
||||
final float windowHeight = s.getHeight();
|
||||
|
||||
ownMapView.getNode()
|
||||
.setLocalTranslation(0.5f * (windowWidth - harborWidth - ownMapWidth - GAP),
|
||||
0.5f * (windowHeight - ownMapHeight),
|
||||
DEPTH);
|
||||
|
||||
harborView.getNode()
|
||||
.setLocalTranslation(0.5f * (windowWidth - harborWidth + ownMapWidth + GAP),
|
||||
0.5f * (windowHeight - harborHeight),
|
||||
DEPTH);
|
||||
|
||||
buttonContainer.setLocalTranslation(0.5f * (windowWidth - harborWidth - ownMapWidth - GAP),
|
||||
0.5f * (windowHeight - ownMapHeight - GAP),
|
||||
DEPTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles click events to place or rotate ships on the maps.
|
||||
*/
|
||||
private void click(boolean isPressed) {
|
||||
if (!isPressed || showsDialog()) return;
|
||||
final Vector2f cursorPos = getApp().getInputManager().getCursorPosition();
|
||||
LOGGER.log(Level.DEBUG, "click: {0}", cursorPos); //NON-NLS
|
||||
getGameLogic().clickHarbor(harborView.mouseToModel(cursorPos));
|
||||
getGameLogic().clickOwnMap(ownMapView.mouseToModel(cursorPos));
|
||||
}
|
||||
}
|
||||
@@ -1,192 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.material.Material;
|
||||
import com.jme3.material.RenderState.BlendMode;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.math.Vector2f;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial.CullHint;
|
||||
import com.jme3.scene.shape.Quad;
|
||||
|
||||
import pp.battleship.client.BattleshipApp;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.util.FloatPoint;
|
||||
import pp.util.Position;
|
||||
|
||||
/**
|
||||
* Represents the visual view of a {@link ShipMap}, used to display the map structure such as the player's map, harbor,
|
||||
* and opponent's map. This class handles the graphical representation of the map, including background setup, grid lines,
|
||||
* and interaction between the model and the view.
|
||||
*/
|
||||
class MapView {
|
||||
public static final float FIELD_SIZE = 40f;
|
||||
private static final float GRID_LINE_WIDTH = 2f;
|
||||
private static final float BACKGROUND_DEPTH = -4f;
|
||||
private static final float GRID_DEPTH = -1f;
|
||||
private static final ColorRGBA BACKGROUND_COLOR = new ColorRGBA(0, 0.05f, 0.05f, 0.5f);
|
||||
private static final ColorRGBA GRID_COLOR = ColorRGBA.Green;
|
||||
|
||||
// Reference to the main application and the ship map being visualized
|
||||
private final BattleshipApp app;
|
||||
private final Node mapNode = new Node("map"); // NON-NLS
|
||||
private final ShipMap map;
|
||||
private final MapViewSynchronizer synchronizer;
|
||||
|
||||
/**
|
||||
* Constructs a new MapView for a given {@link ShipMap} and {@link BattleshipApp}.
|
||||
* Initializes the view by setting up the background and registering a synchronizer to listen to changes in the map.
|
||||
*
|
||||
* @param map the ship map to visualize
|
||||
* @param app the main application instance
|
||||
*/
|
||||
MapView(ShipMap map, BattleshipApp app) {
|
||||
this.map = map;
|
||||
this.app = app;
|
||||
this.synchronizer = new MapViewSynchronizer(this);
|
||||
setupBackground();
|
||||
app.getGameLogic().addListener(synchronizer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregisters the {@link MapViewSynchronizer} from the listener list of the ClientGameLogic,
|
||||
* stopping the view from receiving updates when the underlying {@link ShipMap} changes.
|
||||
* After calling this method, this MapView instance should no longer be used.
|
||||
*/
|
||||
void unregister() {
|
||||
app.getGameLogic().removeListener(synchronizer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the {@link ShipMap} associated with this view.
|
||||
*
|
||||
* @return the ship map
|
||||
*/
|
||||
public ShipMap getMap() {
|
||||
return map;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the {@link BattleshipApp} instance associated with this view.
|
||||
*
|
||||
* @return the main application instance
|
||||
*/
|
||||
public BattleshipApp getApp() {
|
||||
return app;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the background of the map view using a quad geometry.
|
||||
* The background is configured with a semi-transparent color and placed at a specific depth.
|
||||
*/
|
||||
private void setupBackground() {
|
||||
final Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md"); // NON-NLS
|
||||
mat.setColor("Color", BACKGROUND_COLOR); // NON-NLS
|
||||
mat.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
|
||||
final Position corner = modelToView(map.getWidth(), map.getHeight());
|
||||
final Geometry background = new Geometry("MapBackground", new Quad(corner.getX(), corner.getY()));
|
||||
background.setMaterial(mat);
|
||||
background.setLocalTranslation(0f, 0f, BACKGROUND_DEPTH);
|
||||
background.setCullHint(CullHint.Never);
|
||||
mapNode.attachChild(background);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds grid lines to the map view to visually separate the fields within the map.
|
||||
* The grid lines are drawn based on the dimensions of the ship map.
|
||||
*/
|
||||
public void addGrid() {
|
||||
for (int x = 0; x <= map.getWidth(); x++) {
|
||||
final Position f = modelToView(x, 0);
|
||||
final Position t = modelToView(x, map.getHeight());
|
||||
mapNode.attachChild(gridLine(f, t));
|
||||
}
|
||||
for (int y = 0; y <= map.getHeight(); y++) {
|
||||
final Position f = modelToView(0, y);
|
||||
final Position t = modelToView(map.getWidth(), y);
|
||||
mapNode.attachChild(gridLine(f, t));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the root node containing all visual elements in this map view.
|
||||
*
|
||||
* @return the root node for the map view
|
||||
*/
|
||||
public Node getNode() {
|
||||
return mapNode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the total width of the map in view coordinates.
|
||||
*
|
||||
* @return the width of the map in view coordinates
|
||||
*/
|
||||
public float getWidth() {
|
||||
return FIELD_SIZE * map.getWidth();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the total height of the map in view coordinates.
|
||||
*
|
||||
* @return the height of the map in view coordinates
|
||||
*/
|
||||
public float getHeight() {
|
||||
return FIELD_SIZE * map.getHeight();
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts coordinates from view coordinates to model coordinates.
|
||||
*
|
||||
* @param x the x-coordinate in view space
|
||||
* @param y the y-coordinate in view space
|
||||
* @return the corresponding model coordinates as an {@link IntPoint}
|
||||
*/
|
||||
public IntPoint viewToModel(float x, float y) {
|
||||
return new IntPoint((int) Math.floor(x / FIELD_SIZE), (int) Math.floor(y / FIELD_SIZE));
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts coordinates from model coordinates to view coordinates.
|
||||
*
|
||||
* @param x the x-coordinate in model space
|
||||
* @param y the y-coordinate in model space
|
||||
* @return the corresponding view coordinates as a {@link Position}
|
||||
*/
|
||||
public Position modelToView(float x, float y) {
|
||||
return new FloatPoint(x * FIELD_SIZE, y * FIELD_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts the mouse position to model coordinates.
|
||||
* This method takes into account the map's transformation in the 3D scene.
|
||||
*
|
||||
* @param pos the 2D vector representing the mouse position in the view
|
||||
* @return the corresponding model coordinates as an {@link IntPoint}
|
||||
*/
|
||||
public IntPoint mouseToModel(Vector2f pos) {
|
||||
final Vector3f world = new Vector3f(pos.getX(), pos.getY(), 0f);
|
||||
final Vector3f view = mapNode.getWorldTransform().transformInverseVector(world, null);
|
||||
return viewToModel(view.getX(), view.getY());
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a visual representation of a grid line between two positions.
|
||||
*
|
||||
* @param p1 the start position of the grid line
|
||||
* @param p2 the end position of the grid line
|
||||
* @return a {@link Geometry} representing the grid line
|
||||
*/
|
||||
private Geometry gridLine(Position p1, Position p2) {
|
||||
return app.getDraw().makeFatLine(p1, p2, GRID_DEPTH, GRID_COLOR, GRID_LINE_WIDTH);
|
||||
}
|
||||
}
|
||||
@@ -1,154 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.material.Material;
|
||||
import static com.jme3.material.Materials.UNSHADED;
|
||||
import com.jme3.material.RenderState;
|
||||
import com.jme3.material.RenderState.BlendMode;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.scene.shape.Sphere;
|
||||
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Shell;
|
||||
import pp.battleship.model.Shot;
|
||||
import pp.util.Position;
|
||||
|
||||
/**
|
||||
* Synchronizes the visual representation of the ship map with the game model.
|
||||
* It handles the rendering of ships and shots on the map view, updating the view
|
||||
* whenever changes occur in the model.
|
||||
*/
|
||||
class MapViewSynchronizer extends ShipMapSynchronizer {
|
||||
// Constants for rendering properties
|
||||
private static final float SHIP_LINE_WIDTH = 6f;
|
||||
private static final float SHOT_DEPTH = -2f;
|
||||
private static final float SHIP_DEPTH = 0f;
|
||||
private static final float INDENT = 4f;
|
||||
|
||||
// Colors used for different visual elements
|
||||
private static final ColorRGBA HIT_COLOR = ColorRGBA.Red;
|
||||
private static final ColorRGBA MISS_COLOR = ColorRGBA.Blue;
|
||||
private static final ColorRGBA SHIP_BORDER_COLOR = ColorRGBA.White;
|
||||
private static final ColorRGBA PREVIEW_COLOR = ColorRGBA.Gray;
|
||||
private static final ColorRGBA ERROR_COLOR = ColorRGBA.Red;
|
||||
|
||||
// The MapView associated with this synchronizer
|
||||
private final MapView view;
|
||||
|
||||
/**
|
||||
* Constructs a new MapViewSynchronizer for the given MapView.
|
||||
* Initializes the synchronizer and adds existing elements from the model to the view.
|
||||
*
|
||||
* @param view the MapView to synchronize with the game model
|
||||
*/
|
||||
public MapViewSynchronizer(MapView view) {
|
||||
super(view.getMap(), view.getNode());
|
||||
this.view = view;
|
||||
addExisting();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a visual representation of a shot on the map.
|
||||
* A hit shot is represented in red, while a miss is represented in blue.
|
||||
*
|
||||
* @param shot the Shot object representing the shot in the model
|
||||
* @return a Spatial representing the shot on the map
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Shot shot) {
|
||||
// Convert the shot's model coordinates to view coordinates
|
||||
final Position p1 = view.modelToView(shot.getX(), shot.getY());
|
||||
final Position p2 = view.modelToView(shot.getX() + 1, shot.getY() + 1);
|
||||
final ColorRGBA color = shot.isHit() ? HIT_COLOR : MISS_COLOR;
|
||||
|
||||
// Create and return a rectangle representing the shot
|
||||
return view.getApp().getDraw().makeRectangle(p1.getX(), p1.getY(),
|
||||
SHOT_DEPTH,
|
||||
p2.getX() - p1.getX(), p2.getY() - p1.getY(),
|
||||
color);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a visual representation of a battleship on the map.
|
||||
* The ship's border color depends on its status: normal, valid preview, or invalid preview.
|
||||
*
|
||||
* @param ship the Battleship object representing the ship in the model
|
||||
* @return a Spatial representing the ship on the map
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Battleship ship) {
|
||||
// Create a node to represent the ship
|
||||
final Node shipNode = new Node("ship"); //NON-NLS
|
||||
|
||||
// Convert the ship's model coordinates to view coordinates
|
||||
final Position p1 = view.modelToView(ship.getMinX(), ship.getMinY());
|
||||
final Position p2 = view.modelToView(ship.getMaxX() + 1, ship.getMaxY() + 1);
|
||||
|
||||
// Calculate the coordinates for the ship's bounding box
|
||||
final float x1 = p1.getX() + INDENT;
|
||||
final float y1 = p1.getY() + INDENT;
|
||||
final float x2 = p2.getX() - INDENT;
|
||||
final float y2 = p2.getY() - INDENT;
|
||||
|
||||
// Determine the color based on the ship's status
|
||||
final ColorRGBA color = switch (ship.getStatus()) {
|
||||
case NORMAL -> SHIP_BORDER_COLOR;
|
||||
case VALID_PREVIEW -> PREVIEW_COLOR;
|
||||
case INVALID_PREVIEW -> ERROR_COLOR;
|
||||
};
|
||||
|
||||
// Add the ship's borders to the node
|
||||
shipNode.attachChild(shipLine(x1, y1, x2, y1, color));
|
||||
shipNode.attachChild(shipLine(x1, y2, x2, y2, color));
|
||||
shipNode.attachChild(shipLine(x1, y1, x1, y2, color));
|
||||
shipNode.attachChild(shipLine(x2, y1, x2, y2, color));
|
||||
|
||||
// Return the complete ship representation
|
||||
return shipNode;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Creates a line geometry representing part of the ship's border.
|
||||
*
|
||||
* @param x1 the starting x-coordinate of the line
|
||||
* @param y1 the starting y-coordinate of the line
|
||||
* @param x2 the ending x-coordinate of the line
|
||||
* @param y2 the ending y-coordinate of the line
|
||||
* @param color the color of the line
|
||||
* @return a Geometry representing the line
|
||||
*/
|
||||
private Geometry shipLine(float x1, float y1, float x2, float y2, ColorRGBA color) {
|
||||
return view.getApp().getDraw().makeFatLine(x1, y1, x2, y2, SHIP_DEPTH, color, SHIP_LINE_WIDTH);
|
||||
}
|
||||
/**
|
||||
* Creates and returns a Spatial representation of the given {@code Shell} object
|
||||
* for 2D visualization in the game. The shell is represented as a circle.
|
||||
*
|
||||
* @param shell The {@code Shell} object to be visualized.
|
||||
* @return A {@code Spatial} object representing the shell on the map.
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Shell shell) {
|
||||
final ColorRGBA color = ColorRGBA.Black;
|
||||
Geometry ellipse = new Geometry("ellipse", new Sphere(50, 50, MapView.FIELD_SIZE / 2 * 0.8f));
|
||||
Material mat = new Material(view.getApp().getAssetManager(), UNSHADED); //NON-NLS
|
||||
mat.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
|
||||
mat.getAdditionalRenderState().setFaceCullMode(RenderState.FaceCullMode.Off);
|
||||
mat.setColor("Color", color);
|
||||
ellipse.setMaterial(mat);
|
||||
ellipse.addControl(new Shell2DControl(view, shell));
|
||||
return ellipse;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,283 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.effect.ParticleEmitter;
|
||||
import com.jme3.effect.ParticleMesh.Type;
|
||||
import com.jme3.effect.shapes.EmitterSphereShape;
|
||||
import com.jme3.material.Material;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Vector3f;
|
||||
|
||||
import pp.battleship.client.BattleshipApp;
|
||||
|
||||
/**
|
||||
* Factory class responsible for creating particle effects used in the game.
|
||||
* This centralizes the creation of various types of particle emitters.
|
||||
*/
|
||||
public class ParticleEffectFactory {
|
||||
private static final int COUNT_FACTOR = 1;
|
||||
private static final float COUNT_FACTOR_F = 1f;
|
||||
private static final boolean POINT_SPRITE = true;
|
||||
private static final Type EMITTER_TYPE = POINT_SPRITE ? Type.Point : Type.Triangle;
|
||||
|
||||
private final BattleshipApp app;
|
||||
|
||||
ParticleEffectFactory(BattleshipApp app) {
|
||||
this.app = app;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a flame particle emitter.
|
||||
*
|
||||
* @return a configured flame particle emitter
|
||||
*/
|
||||
ParticleEmitter createFlame() {
|
||||
ParticleEmitter flame = new ParticleEmitter("Flame", EMITTER_TYPE, 32 * COUNT_FACTOR);
|
||||
flame.setSelectRandomImage(true);
|
||||
flame.setStartColor(new ColorRGBA(1f, 0.4f, 0.05f, (1f / COUNT_FACTOR_F)));
|
||||
flame.setEndColor(new ColorRGBA(.4f, .22f, .12f, 0f));
|
||||
flame.setStartSize(0.1f);
|
||||
flame.setEndSize(0.5f);
|
||||
flame.setShape(new EmitterSphereShape(Vector3f.ZERO, 1f));
|
||||
flame.setParticlesPerSec(0);
|
||||
flame.setGravity(0, -5, 0);
|
||||
flame.setLowLife(.4f);
|
||||
flame.setHighLife(.5f);
|
||||
flame.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 7, 0));
|
||||
flame.getParticleInfluencer().setVelocityVariation(1f);
|
||||
flame.setImagesX(2);
|
||||
flame.setImagesY(2);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/flame.png"));
|
||||
mat.setBoolean("PointSprite", POINT_SPRITE);
|
||||
flame.setMaterial(mat);
|
||||
|
||||
return flame;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a flash particle emitter.
|
||||
*
|
||||
* @return a configured flash particle emitter
|
||||
*/
|
||||
ParticleEmitter createFlash() {
|
||||
ParticleEmitter flash = new ParticleEmitter("Flash", EMITTER_TYPE, 24 * COUNT_FACTOR);
|
||||
flash.setSelectRandomImage(true);
|
||||
flash.setStartColor(new ColorRGBA(1f, 0.8f, 0.36f, 1f / COUNT_FACTOR_F));
|
||||
flash.setEndColor(new ColorRGBA(1f, 0.8f, 0.36f, 0f));
|
||||
flash.setStartSize(.1f);
|
||||
flash.setEndSize(0.5f);
|
||||
flash.setShape(new EmitterSphereShape(Vector3f.ZERO, .05f));
|
||||
flash.setParticlesPerSec(0);
|
||||
flash.setGravity(0, 0, 0);
|
||||
flash.setLowLife(.2f);
|
||||
flash.setHighLife(.2f);
|
||||
flash.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 5f, 0));
|
||||
flash.getParticleInfluencer().setVelocityVariation(1);
|
||||
flash.setImagesX(2);
|
||||
flash.setImagesY(2);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/flash.png"));
|
||||
mat.setBoolean("PointSprite", POINT_SPRITE);
|
||||
flash.setMaterial(mat);
|
||||
|
||||
return flash;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a round spark particle emitter.
|
||||
*
|
||||
* @return a configured round spark particle emitter
|
||||
*/
|
||||
ParticleEmitter createRoundSpark() {
|
||||
ParticleEmitter roundSpark = new ParticleEmitter("RoundSpark", EMITTER_TYPE, 20 * COUNT_FACTOR);
|
||||
roundSpark.setStartColor(new ColorRGBA(1f, 0.29f, 0.34f, (float) (1.0 / COUNT_FACTOR_F)));
|
||||
roundSpark.setEndColor(new ColorRGBA(0, 0, 0, 0.5f / COUNT_FACTOR_F));
|
||||
roundSpark.setStartSize(0.2f);
|
||||
roundSpark.setEndSize(0.8f);
|
||||
roundSpark.setShape(new EmitterSphereShape(Vector3f.ZERO, 1f));
|
||||
roundSpark.setParticlesPerSec(0);
|
||||
roundSpark.setGravity(0, -.5f, 0);
|
||||
roundSpark.setLowLife(1.8f);
|
||||
roundSpark.setHighLife(2f);
|
||||
roundSpark.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 3, 0));
|
||||
roundSpark.getParticleInfluencer().setVelocityVariation(.5f);
|
||||
roundSpark.setImagesX(1);
|
||||
roundSpark.setImagesY(1);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/roundspark.png"));
|
||||
mat.setBoolean("PointSprite", POINT_SPRITE);
|
||||
roundSpark.setMaterial(mat);
|
||||
|
||||
return roundSpark;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a spark particle emitter.
|
||||
*
|
||||
* @return a configured spark particle emitter
|
||||
*/
|
||||
ParticleEmitter createSpark() {
|
||||
ParticleEmitter spark = new ParticleEmitter("Spark", Type.Triangle, 30 * COUNT_FACTOR);
|
||||
spark.setStartColor(new ColorRGBA(1f, 0.8f, 0.36f, 1.0f / COUNT_FACTOR_F));
|
||||
spark.setEndColor(new ColorRGBA(1f, 0.8f, 0.36f, 0f));
|
||||
spark.setStartSize(.5f);
|
||||
spark.setEndSize(.5f);
|
||||
spark.setFacingVelocity(true);
|
||||
spark.setParticlesPerSec(0);
|
||||
spark.setGravity(0, 5, 0);
|
||||
spark.setLowLife(1.1f);
|
||||
spark.setHighLife(1.5f);
|
||||
spark.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 20, 0));
|
||||
spark.getParticleInfluencer().setVelocityVariation(1);
|
||||
spark.setImagesX(1);
|
||||
spark.setImagesY(1);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/spark.png"));
|
||||
spark.setMaterial(mat);
|
||||
|
||||
return spark;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a smoke trail particle emitter.
|
||||
*
|
||||
* @return a configured smoke trail particle emitter
|
||||
*/
|
||||
ParticleEmitter createSmokeTrail() {
|
||||
ParticleEmitter smokeTrail = new ParticleEmitter("SmokeTrail", Type.Triangle, 22 * COUNT_FACTOR);
|
||||
smokeTrail.setStartColor(new ColorRGBA(1f, 0.8f, 0.36f, 1.0f / COUNT_FACTOR_F));
|
||||
smokeTrail.setEndColor(new ColorRGBA(1f, 0.8f, 0.36f, 0f));
|
||||
smokeTrail.setStartSize(.2f);
|
||||
smokeTrail.setEndSize(1f);
|
||||
smokeTrail.setFacingVelocity(true);
|
||||
smokeTrail.setParticlesPerSec(0);
|
||||
smokeTrail.setGravity(0, 1, 0);
|
||||
smokeTrail.setLowLife(.4f);
|
||||
smokeTrail.setHighLife(.5f);
|
||||
smokeTrail.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 12, 0));
|
||||
smokeTrail.getParticleInfluencer().setVelocityVariation(1);
|
||||
smokeTrail.setImagesX(1);
|
||||
smokeTrail.setImagesY(3);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/smoketrail.png"));
|
||||
smokeTrail.setMaterial(mat);
|
||||
|
||||
return smokeTrail;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a debris particle emitter.
|
||||
*
|
||||
* @return a configured debris particle emitter
|
||||
*/
|
||||
ParticleEmitter createDebris() {
|
||||
ParticleEmitter debris = new ParticleEmitter("Debris", Type.Triangle, 15 * COUNT_FACTOR);
|
||||
debris.setSelectRandomImage(true);
|
||||
debris.setRandomAngle(true);
|
||||
debris.setRotateSpeed(FastMath.TWO_PI * 4);
|
||||
debris.setStartColor(new ColorRGBA(1f, 0.59f, 0.28f, 1.0f / COUNT_FACTOR_F));
|
||||
debris.setEndColor(new ColorRGBA(.5f, 0.5f, 0.5f, 0f));
|
||||
debris.setStartSize(.10f);
|
||||
debris.setEndSize(.15f);
|
||||
debris.setParticlesPerSec(0);
|
||||
debris.setGravity(0, 12f, 0);
|
||||
debris.setLowLife(1.4f);
|
||||
debris.setHighLife(1.5f);
|
||||
debris.setLocalTranslation(0, 2f, 0);
|
||||
debris.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 15, 0));
|
||||
debris.getParticleInfluencer().setVelocityVariation(.60f);
|
||||
debris.setImagesX(3);
|
||||
debris.setImagesY(3);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/Debris.png"));
|
||||
debris.setMaterial(mat);
|
||||
|
||||
return debris;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a shockwave particle emitter.
|
||||
*
|
||||
* @return a configured shockwave particle emitter
|
||||
*/
|
||||
ParticleEmitter createShockwave() {
|
||||
ParticleEmitter shockwave = new ParticleEmitter("Shockwave", Type.Triangle, 1 * COUNT_FACTOR);
|
||||
shockwave.setFaceNormal(Vector3f.UNIT_Y);
|
||||
shockwave.setStartColor(new ColorRGBA(.48f, 0.17f, 0.01f, .8f / COUNT_FACTOR_F));
|
||||
shockwave.setEndColor(new ColorRGBA(.48f, 0.17f, 0.01f, 0f));
|
||||
shockwave.setStartSize(0f);
|
||||
shockwave.setEndSize(3f);
|
||||
shockwave.setParticlesPerSec(0);
|
||||
shockwave.setGravity(0, 0, 0);
|
||||
shockwave.setLowLife(0.5f);
|
||||
shockwave.setHighLife(0.5f);
|
||||
shockwave.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 0, 0));
|
||||
shockwave.getParticleInfluencer().setVelocityVariation(0f);
|
||||
shockwave.setImagesX(1);
|
||||
shockwave.setImagesY(1);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Explosion/shockwave.png"));
|
||||
shockwave.setMaterial(mat);
|
||||
|
||||
return shockwave;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a moving smoke emitter.
|
||||
*
|
||||
* @return a configured smoke emitter
|
||||
*/
|
||||
ParticleEmitter createMovingSmokeEmitter() {
|
||||
ParticleEmitter smokeEmitter = new ParticleEmitter("SmokeEmitter", Type.Triangle, 300);
|
||||
smokeEmitter.setGravity(0, 0, 0);
|
||||
smokeEmitter.getParticleInfluencer().setVelocityVariation(1);
|
||||
smokeEmitter.setLocalTranslation(0, 2f, 0); //___________________
|
||||
smokeEmitter.setLowLife(1);
|
||||
smokeEmitter.setHighLife(1);
|
||||
smokeEmitter.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 0, 0));
|
||||
smokeEmitter.setImagesX(15);
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Smoke/Smoke.png"));
|
||||
smokeEmitter.setMaterial(mat);
|
||||
|
||||
return smokeEmitter;
|
||||
}
|
||||
public ParticleEmitter createWaterSplash() { //wird durch explosions animation ersetzt
|
||||
// Create a new particle emitter for the splash effect
|
||||
ParticleEmitter waterSplash = new ParticleEmitter("WaterSplash", Type.Triangle, 30);
|
||||
|
||||
// Set the shape of the emitter, making particles emit from a point or small area
|
||||
waterSplash.setShape(new EmitterSphereShape(Vector3f.ZERO, 0.2f));
|
||||
|
||||
// Start and end colors for water (blue, fading out)
|
||||
waterSplash.setStartColor(new ColorRGBA(0.4f, 0.4f, 1f, 1f)); // Light blue at start
|
||||
waterSplash.setEndColor(new ColorRGBA(0.4f, 0.4f, 1f, 0f)); // Transparent at the end
|
||||
|
||||
// Particle size: small at start, larger before fading out
|
||||
waterSplash.setStartSize(0.1f);
|
||||
waterSplash.setEndSize(0.3f);
|
||||
|
||||
// Particle lifespan (how long particles live)
|
||||
waterSplash.setLowLife(0.5f);
|
||||
waterSplash.setHighLife(1f);
|
||||
|
||||
// Gravity: Pull the water particles downwards
|
||||
waterSplash.setGravity(0, -9.81f, 0); // Earth's gravity simulation
|
||||
|
||||
// Velocity: Give particles an initial burst upward (simulates splash)
|
||||
waterSplash.getParticleInfluencer().setInitialVelocity(new Vector3f(0, 3, 0));
|
||||
waterSplash.getParticleInfluencer().setVelocityVariation(0.6f); // Add randomness to splash
|
||||
|
||||
// Set how many particles are emitted per second (0 to emit all particles at once)
|
||||
waterSplash.setParticlesPerSec(0);
|
||||
|
||||
// Load a texture for the water splash (assuming a texture exists at this path)
|
||||
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Particle.j3md");
|
||||
mat.setTexture("Texture", app.getAssetManager().loadTexture("Effects/Splash/splash.png"));
|
||||
waterSplash.setMaterial(mat);
|
||||
|
||||
return waterSplash;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,203 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.app.Application;
|
||||
import com.jme3.app.state.AppStateManager;
|
||||
import com.jme3.asset.AssetManager;
|
||||
import com.jme3.light.AmbientLight;
|
||||
import com.jme3.light.DirectionalLight;
|
||||
import com.jme3.material.Material;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.math.Vector2f;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.Camera;
|
||||
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.scene.shape.Box;
|
||||
import com.jme3.shadow.DirectionalLightShadowRenderer;
|
||||
import com.jme3.shadow.EdgeFilteringMode;
|
||||
import com.jme3.texture.Texture;
|
||||
import com.jme3.util.SkyFactory;
|
||||
import com.jme3.util.TangentBinormalGenerator;
|
||||
import pp.battleship.client.BattleshipAppState;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.util.FloatMath;
|
||||
|
||||
import static pp.util.FloatMath.TWO_PI;
|
||||
import static pp.util.FloatMath.cos;
|
||||
import static pp.util.FloatMath.sin;
|
||||
import static pp.util.FloatMath.sqrt;
|
||||
|
||||
/**
|
||||
* Manages the rendering and visual aspects of the sea and sky in the Battleship game.
|
||||
* This state is responsible for setting up and updating the sea, sky, and lighting
|
||||
* conditions, and controls the camera to create a dynamic view of the game environment.
|
||||
*/
|
||||
public class SeaAppState extends BattleshipAppState {
|
||||
/**
|
||||
* The path to the sea texture material.
|
||||
*/
|
||||
private static final String SEA_TEXTURE = "Textures/Terrain/Water/Water.j3m"; //NON-NLS
|
||||
private static final float ABOVE_SEA_LEVEL = 4f;
|
||||
private static final float INCLINATION = 2.5f;
|
||||
|
||||
/**
|
||||
* The root node for all visual elements in this state.
|
||||
*/
|
||||
private final Node viewNode = new Node("view"); //NON-NLS
|
||||
|
||||
/**
|
||||
* The node containing the scene elements, such as the sea surface.
|
||||
*/
|
||||
private final Node sceneNode = new Node("scene"); //NON-NLS
|
||||
|
||||
/**
|
||||
* Synchronizes the sea's visual representation with the game logic.
|
||||
*/
|
||||
private SeaSynchronizer synchronizer;
|
||||
|
||||
/**
|
||||
* The current angle of the camera around the center of the map.
|
||||
*/
|
||||
private float cameraAngle;
|
||||
|
||||
/**
|
||||
* Initializes the state by setting up the sky, lights, and other visual components.
|
||||
* This method is called when the state is first attached to the state manager.
|
||||
*
|
||||
* @param stateManager the state manager
|
||||
* @param application the application
|
||||
*/
|
||||
@Override
|
||||
public void initialize(AppStateManager stateManager, Application application) {
|
||||
super.initialize(stateManager, application);
|
||||
viewNode.attachChild(sceneNode);
|
||||
setupLights();
|
||||
setupSky();
|
||||
}
|
||||
|
||||
/**
|
||||
* Enables the sea and sky state, setting up the scene and registering any necessary listeners.
|
||||
* This method is called when the state is set to active.
|
||||
*/
|
||||
@Override
|
||||
protected void enableState() {
|
||||
sceneNode.detachAllChildren();
|
||||
setupScene();
|
||||
if (synchronizer == null) {
|
||||
synchronizer = new SeaSynchronizer(getApp(), sceneNode, getGameLogic().getOwnMap());
|
||||
getGameLogic().addListener(synchronizer);
|
||||
}
|
||||
getApp().getRootNode().attachChild(viewNode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables the sea and sky state, removing visual elements from the scene and unregistering listeners.
|
||||
* This method is called when the state is set to inactive.
|
||||
*/
|
||||
@Override
|
||||
protected void disableState() {
|
||||
getApp().getRootNode().detachChild(viewNode);
|
||||
if (synchronizer != null) {
|
||||
getGameLogic().removeListener(synchronizer);
|
||||
synchronizer = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the state each frame, moving the camera to simulate it circling around the map.
|
||||
*
|
||||
* @param tpf the time per frame (seconds)
|
||||
*/
|
||||
@Override
|
||||
public void update(float tpf) {
|
||||
super.update(tpf);
|
||||
cameraAngle += TWO_PI * 0.05f * tpf;
|
||||
adjustCamera();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the lighting for the scene, including directional and ambient lights.
|
||||
* Also configures shadows to enhance the visual depth of the scene.
|
||||
*/
|
||||
private void setupLights() {
|
||||
final AssetManager assetManager = getApp().getAssetManager();
|
||||
final DirectionalLightShadowRenderer shRend = new DirectionalLightShadowRenderer(assetManager, 2048, 3);
|
||||
shRend.setLambda(0.55f);
|
||||
shRend.setShadowIntensity(0.6f);
|
||||
shRend.setEdgeFilteringMode(EdgeFilteringMode.Bilinear);
|
||||
getApp().getViewPort().addProcessor(shRend);
|
||||
|
||||
final DirectionalLight sun = new DirectionalLight();
|
||||
sun.setDirection(new Vector3f(-1f, -0.7f, -1f).normalizeLocal());
|
||||
viewNode.addLight(sun);
|
||||
shRend.setLight(sun);
|
||||
|
||||
final AmbientLight ambientLight = new AmbientLight(new ColorRGBA(0.3f, 0.3f, 0.3f, 0f));
|
||||
viewNode.addLight(ambientLight);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the sky in the scene using a skybox with textures for all six directions.
|
||||
* This creates a realistic and immersive environment for the sea.
|
||||
*/
|
||||
private void setupSky() {
|
||||
final AssetManager assetManager = getApp().getAssetManager();
|
||||
final Texture west = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_west.jpg"); //NON-NLS
|
||||
final Texture east = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_east.jpg"); //NON-NLS
|
||||
final Texture north = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_north.jpg"); //NON-NLS
|
||||
final Texture south = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_south.jpg"); //NON-NLS
|
||||
final Texture up = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_up.jpg"); //NON-NLS
|
||||
final Texture down = assetManager.loadTexture("Textures/Sky/Lagoon/lagoon_down.jpg"); //NON-NLS
|
||||
final Spatial sky = SkyFactory.createSky(assetManager, west, east, north, south, up, down);
|
||||
sky.rotate(0f, FloatMath.PI, 0f);
|
||||
viewNode.attachChild(sky);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the sea surface in the scene. This includes creating the sea mesh,
|
||||
* applying textures, and enabling shadows.
|
||||
*/
|
||||
private void setupScene() {
|
||||
final ShipMap ownMap = getGameLogic().getOwnMap();
|
||||
final float x = 0.5f * ownMap.getWidth();
|
||||
final float y = 0.5f * ownMap.getHeight();
|
||||
final Box seaMesh = new Box(y + 0.5f, 0.1f, x + 0.5f);
|
||||
final Geometry seaGeo = new Geometry("sea", seaMesh); //NON-NLS
|
||||
seaGeo.setLocalTranslation(new Vector3f(y, -0.1f, x));
|
||||
seaMesh.scaleTextureCoordinates(new Vector2f(4f, 4f));
|
||||
final Material seaMat = getApp().getAssetManager().loadMaterial(SEA_TEXTURE);
|
||||
seaGeo.setMaterial(seaMat);
|
||||
seaGeo.setShadowMode(ShadowMode.CastAndReceive);
|
||||
TangentBinormalGenerator.generate(seaGeo);
|
||||
sceneNode.attachChild(seaGeo);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjusts the camera position and orientation to create a circular motion around
|
||||
* the center of the map. This provides a dynamic view of the sea and surrounding environment.
|
||||
*/
|
||||
private void adjustCamera() {
|
||||
final ShipMap ownMap = getGameLogic().getOwnMap();
|
||||
final float mx = 0.5f * ownMap.getWidth();
|
||||
final float my = 0.5f * ownMap.getHeight();
|
||||
final float radius = 2f * sqrt(mx * mx + my + my);
|
||||
final float cos = radius * cos(cameraAngle);
|
||||
final float sin = radius * sin(cameraAngle);
|
||||
final float x = mx - cos;
|
||||
final float y = my - sin;
|
||||
final Camera camera = getApp().getCamera();
|
||||
camera.setLocation(new Vector3f(y, ABOVE_SEA_LEVEL, x));
|
||||
camera.getRotation().lookAt(new Vector3f(sin, -INCLINATION, cos),
|
||||
Vector3f.UNIT_Y);
|
||||
camera.update();
|
||||
}
|
||||
}
|
||||
@@ -1,410 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
|
||||
import static java.util.Objects.requireNonNull;
|
||||
|
||||
import com.jme3.effect.ParticleEmitter;
|
||||
import com.jme3.material.Material;
|
||||
import com.jme3.material.RenderState.BlendMode;
|
||||
import com.jme3.math.ColorRGBA;
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
|
||||
import com.jme3.scene.Geometry;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.scene.shape.Box;
|
||||
import com.jme3.scene.shape.Cylinder;
|
||||
|
||||
import pp.battleship.client.BattleshipApp;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Rotation;
|
||||
import pp.battleship.model.Shell;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.model.Shot;
|
||||
import static pp.util.FloatMath.HALF_PI;
|
||||
import static pp.util.FloatMath.PI;
|
||||
|
||||
/**
|
||||
* The {@code SeaSynchronizer} class is responsible for synchronizing the graphical
|
||||
* representation of the ships and shots on the sea map with the underlying data model.
|
||||
* It extends the {@link ShipMapSynchronizer} to provide specific synchronization
|
||||
* logic for the sea map.
|
||||
*/
|
||||
class SeaSynchronizer extends ShipMapSynchronizer {
|
||||
private static final String UNSHADED = "Common/MatDefs/Misc/Unshaded.j3md"; //NON-NLS
|
||||
private static final String KING_GEORGE_V_MODEL = "Models/Transporter/cr90.j3o"; //NON-NLS
|
||||
private static final String TIE_FIGHTER = "Models/TieFighter/TieFighter.j3o"; //NON-NLS
|
||||
private static final String TRANSPORTER = "Models/KingGeorgeV/KingGeorge.j3o"; //NON-NLS
|
||||
//private static final String VENATOR = "Models/Venator/Venator.j3o"; //NON-NLS
|
||||
private static final String WING = "Models/Wing/Wing.j3o"; //NON-NLS
|
||||
|
||||
private static final String COLOR = "Color"; //NON-NLS
|
||||
private static final String SHIP = "ship"; //NON-NLS
|
||||
private static final String SHOT = "shot"; //NON-NLS
|
||||
private static final ColorRGBA BOX_COLOR = ColorRGBA.Gray;
|
||||
private static final ColorRGBA SPLASH_COLOR = new ColorRGBA(0f, 0f, 1f, 0.4f);
|
||||
private static final ColorRGBA HIT_COLOR = new ColorRGBA(1f, 0f, 0f, 0.4f);
|
||||
private static final String LIGHTING = "Common/MatDefs/Light/Lighting.j3md";
|
||||
|
||||
private final ShipMap map;
|
||||
private final BattleshipApp app;
|
||||
private final ParticleEffectFactory particleFactory;
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a {@code SeaSynchronizer} object with the specified application, root node, and ship map.
|
||||
*
|
||||
* @param app the Battleship application
|
||||
* @param root the root node to which graphical elements will be attached
|
||||
* @param map the ship map containing the ships and shots
|
||||
*/
|
||||
public SeaSynchronizer(BattleshipApp app, Node root, ShipMap map) {
|
||||
super(app.getGameLogic().getOwnMap(), root);
|
||||
this.app = app;
|
||||
this.map = map;
|
||||
this.particleFactory = new ParticleEffectFactory(app);
|
||||
addExisting();
|
||||
}
|
||||
|
||||
/**
|
||||
* Visits a {@link Shot} and creates a graphical representation of it.
|
||||
* If the shot is a hit, it attaches the representation to the ship node.
|
||||
*
|
||||
* @param shot the shot to be represented
|
||||
* @return the graphical representation of the shot, or null if the shot is a hit
|
||||
* and the representation has been attached to the ship node
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Shot shot) {
|
||||
return shot.isHit() ? handleHit(shot) : handleMiss(shot);
|
||||
}
|
||||
private Spatial handleMiss(Shot shot) {
|
||||
Node shotNode = new Node("ShotNode");
|
||||
Geometry shotCylinder = createCylinder(shot);
|
||||
shotNode.attachChild(shotCylinder);
|
||||
ParticleEmitter waterSplash = particleFactory.createWaterSplash();
|
||||
waterSplash.setLocalTranslation(shot.getY() + 0.5f, 0f, shot.getX() + 0.5f);
|
||||
shotNode.attachChild(waterSplash);
|
||||
waterSplash.emitAllParticles();
|
||||
|
||||
return shotNode;
|
||||
}
|
||||
private void sinkAndRemoveShip(Battleship ship) {
|
||||
Battleship wilkeningklaunichtmeinencode = ship;
|
||||
final Node shipNode = (Node) getSpatial(wilkeningklaunichtmeinencode);
|
||||
if (shipNode == null) return;
|
||||
|
||||
// Add sinking control to animate the sinking
|
||||
shipNode.addControl(new SinkingControl(shipNode));
|
||||
|
||||
// Add particle effects
|
||||
ParticleEmitter bubbles = particleFactory.createWaterSplash();
|
||||
bubbles.setLocalTranslation(shipNode.getLocalTranslation());
|
||||
shipNode.attachChild(bubbles);
|
||||
bubbles.emitAllParticles();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Handles a hit by attaching its representation to the node that
|
||||
* contains the ship model as a child so that it moves with the ship.
|
||||
*
|
||||
* @param shot a hit
|
||||
* @return always null to prevent the representation from being attached
|
||||
* to the items node as well
|
||||
*/
|
||||
private Spatial handleHit(Shot shot) {
|
||||
final Battleship ship = requireNonNull(map.findShipAt(shot), "Missing ship");
|
||||
final Node shipNode = requireNonNull((Node) getSpatial(ship), "Missing ship node");
|
||||
|
||||
Node hitEffectNode = new Node("HitEffectNode");
|
||||
|
||||
// Create particle effects
|
||||
ParticleEmitter flame = particleFactory.createFlame();
|
||||
ParticleEmitter flash = particleFactory.createFlash();
|
||||
ParticleEmitter spark = particleFactory.createSpark();
|
||||
ParticleEmitter roundSpark = particleFactory.createRoundSpark();
|
||||
ParticleEmitter smokeTrail = particleFactory.createSmokeTrail();
|
||||
ParticleEmitter debris = particleFactory.createDebris();
|
||||
ParticleEmitter shockwave = particleFactory.createShockwave();
|
||||
ParticleEmitter movingSmoke = particleFactory.createMovingSmokeEmitter();
|
||||
|
||||
// Attach all effects to the hitEffectNode
|
||||
hitEffectNode.attachChild(flame);
|
||||
hitEffectNode.attachChild(flash);
|
||||
hitEffectNode.attachChild(spark);
|
||||
hitEffectNode.attachChild(roundSpark);
|
||||
hitEffectNode.attachChild(smokeTrail);
|
||||
hitEffectNode.attachChild(debris);
|
||||
hitEffectNode.attachChild(shockwave);
|
||||
hitEffectNode.attachChild(movingSmoke);
|
||||
|
||||
// Set the local translation for the hit effect to the point of impact
|
||||
hitEffectNode.setLocalTranslation(shot.getY() + 0.5f - shipNode.getLocalTranslation().x,
|
||||
0.5f, // Adjust as needed for height above the ship
|
||||
shot.getX() + 0.5f - shipNode.getLocalTranslation().z);
|
||||
|
||||
// Attach the hitEffectNode to the shipNode so it moves with the ship
|
||||
shipNode.attachChild(hitEffectNode);
|
||||
|
||||
// Emit particles when the hit happens
|
||||
flash.emitAllParticles();
|
||||
spark.emitAllParticles();
|
||||
smokeTrail.emitAllParticles();
|
||||
debris.emitAllParticles();
|
||||
shockwave.emitAllParticles();
|
||||
flame.emitAllParticles();
|
||||
roundSpark.emitAllParticles();
|
||||
|
||||
if (ship.isDestroyed()) {
|
||||
sinkAndRemoveShip(ship);
|
||||
}
|
||||
|
||||
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a cylinder geometry representing the specified shot.
|
||||
* The appearance of the cylinder depends on whether the shot is a hit or a miss.
|
||||
*
|
||||
* @param shot the shot to be represented
|
||||
* @return the geometry representing the shot
|
||||
*/
|
||||
private Geometry createCylinder(Shot shot) {
|
||||
final ColorRGBA color = shot.isHit() ? HIT_COLOR : SPLASH_COLOR;
|
||||
final float height = shot.isHit() ? 1.2f : 0.1f;
|
||||
|
||||
final Cylinder cylinder = new Cylinder(2, 20, 0.45f, height, true);
|
||||
final Geometry geometry = new Geometry(SHOT, cylinder);
|
||||
|
||||
geometry.setMaterial(createColoredMaterial(color));
|
||||
geometry.rotate(HALF_PI, 0f, 0f);
|
||||
|
||||
// compute the center of the shot in world coordinates, with an additional 2f height
|
||||
geometry.setLocalTranslation(shot.getY() + 0.5f, 2f + height / 2, shot.getX() + 0.5f);
|
||||
|
||||
return geometry;
|
||||
}
|
||||
|
||||
/**
|
||||
* Visits a {@link Battleship} and creates a graphical representation of it.
|
||||
* The representation is either a 3D model or a simple box depending on the
|
||||
* type of battleship.
|
||||
*
|
||||
* @param ship the battleship to be represented
|
||||
* @return the node containing the graphical representation of the battleship
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Battleship ship) {
|
||||
final Node node = new Node(SHIP);
|
||||
node.attachChild(createShip(ship));
|
||||
// compute the center of the ship in world coordinates
|
||||
final float x = 0.5f * (ship.getMinY() + ship.getMaxY() + 1f);
|
||||
final float z = 0.5f * (ship.getMinX() + ship.getMaxX() + 1f);
|
||||
node.setLocalTranslation(x, 0f, z);
|
||||
node.addControl(new ShipControl(ship));
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the appropriate graphical representation of the specified battleship.
|
||||
* The representation is either a detailed model or a simple box based on the length of the ship.
|
||||
*
|
||||
* @param ship the battleship to be represented
|
||||
* @return the spatial representing the battleship
|
||||
*/
|
||||
private Spatial createShip(Battleship ship) {
|
||||
if (ship.getLength() == 1) {
|
||||
return createTie_Fighter(ship);
|
||||
} else if (ship.getLength() == 2) {
|
||||
return createWing(ship);
|
||||
} else if (ship.getLength() == 3) {
|
||||
return createTransporter(ship);
|
||||
} else if (ship.getLength() == 4) {
|
||||
return createBattleship(ship);
|
||||
} else {
|
||||
return createBox(ship);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Creates a simple box to represent a battleship that is not of the "King George V" type.
|
||||
*
|
||||
* @param ship the battleship to be represented
|
||||
* @return the geometry representing the battleship as a box
|
||||
*/
|
||||
private Spatial createBox(Battleship ship) {
|
||||
final Box box = new Box(0.5f * (ship.getMaxY() - ship.getMinY()) + 0.3f,
|
||||
0.3f,
|
||||
0.5f * (ship.getMaxX() - ship.getMinX()) + 0.3f);
|
||||
final Geometry geometry = new Geometry(SHIP, box);
|
||||
geometry.setMaterial(createColoredMaterial(BOX_COLOR));
|
||||
geometry.setShadowMode(ShadowMode.CastAndReceive);
|
||||
|
||||
return geometry;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new {@link Material} with the specified color.
|
||||
* If the color includes transparency (i.e., alpha value less than 1),
|
||||
* the material's render state is set to use alpha blending, allowing for
|
||||
* semi-transparent rendering.
|
||||
*
|
||||
* @param color the {@link ColorRGBA} to be applied to the material. If the alpha value
|
||||
* of the color is less than 1, the material will support transparency.
|
||||
* @return a {@link Material} instance configured with the specified color and,
|
||||
* if necessary, alpha blending enabled.
|
||||
*/
|
||||
private Material createColoredMaterial(ColorRGBA color) {
|
||||
final Material material = new Material(app.getAssetManager(), UNSHADED);
|
||||
if (color.getAlpha() < 1f)
|
||||
material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
|
||||
material.setColor(COLOR, color);
|
||||
return material;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a detailed 3D model to represent all battleships.
|
||||
*
|
||||
* @param ship the battleship to be represented
|
||||
* @return the spatial representing the "King George V" battleship
|
||||
*/
|
||||
private Spatial createBattleship(Battleship ship) {
|
||||
final Spatial model = app.getAssetManager().loadModel(KING_GEORGE_V_MODEL);
|
||||
|
||||
|
||||
// Berechne den Rotationswinkel
|
||||
float rotationAngle = calculateRotationAngle(ship.getRot())+HALF_PI;
|
||||
model.setLocalTranslation(new Vector3f(model.getLocalTranslation().x, 2f, model.getLocalTranslation().z));
|
||||
model.rotate(0f, rotationAngle, -HALF_PI);
|
||||
model.scale(1.2f);
|
||||
model.setShadowMode(ShadowMode.CastAndReceive);
|
||||
|
||||
// Bestimme die Verschiebung basierend auf der Rotation
|
||||
Vector3f translation = model.getLocalTranslation();
|
||||
|
||||
// Bei 0 oder 180 Grad wird auf der Z-Achse verschoben, bei 90 oder 270 Grad auf der X-Achse
|
||||
if (rotationAngle == 0 || rotationAngle == FastMath.PI) {
|
||||
// Verschiebe auf der Z-Achse und um 2f nach oben
|
||||
translation = translation.subtract(0,0,1); // Nach hinten auf der Z-Achse, und um 2f nach oben
|
||||
} else if (rotationAngle == FastMath.HALF_PI || rotationAngle == 3 * FastMath.HALF_PI) {
|
||||
// Verschiebe auf der X-Achse und um 2f nach oben
|
||||
translation = translation.subtract(1,0,0); // Nach hinten auf der X-Achse, und um 2f nach oben
|
||||
}
|
||||
|
||||
model.setLocalTranslation(translation);
|
||||
|
||||
return model;
|
||||
}
|
||||
private Spatial createTransporter(Battleship ship) {
|
||||
final Spatial model = app.getAssetManager().loadModel(TRANSPORTER);
|
||||
float rotationAngle = calculateRotationAngle(ship.getRot())+HALF_PI;
|
||||
|
||||
|
||||
model.rotate(-HALF_PI, calculateRotationAngle(ship.getRot())+ PI, 0f);
|
||||
model.scale(0.008f);
|
||||
model.setShadowMode(ShadowMode.CastAndReceive);
|
||||
model.setLocalTranslation(new Vector3f(model.getLocalTranslation().x, 2f, model.getLocalTranslation().z));
|
||||
Vector3f translation = model.getLocalTranslation();
|
||||
// Bei 0 oder 180 Grad wird auf der Z-Achse verschoben, bei 90 oder 270 Grad auf der X-Achse
|
||||
if (rotationAngle == 0 || rotationAngle == FastMath.PI) {
|
||||
// Verschiebe auf der Z-Achse und um 2f nach oben
|
||||
translation = translation.subtract(0,0,1);
|
||||
} else if (rotationAngle == FastMath.HALF_PI || rotationAngle == 3 * FastMath.HALF_PI) {
|
||||
// Verschiebe auf der X-Achse und um 2f nach oben
|
||||
translation = translation.add(1,0,0);
|
||||
}
|
||||
|
||||
model.setLocalTranslation(translation);
|
||||
|
||||
|
||||
return model;
|
||||
}
|
||||
private Spatial createWing(Battleship ship) {
|
||||
final Spatial model = app.getAssetManager().loadModel(WING);
|
||||
model.setLocalTranslation(new Vector3f(model.getLocalTranslation().x, 2f, model.getLocalTranslation().z));
|
||||
|
||||
// Berechne den Rotationswinkel
|
||||
float rotationAngle = calculateRotationAngle(ship.getRot())+HALF_PI;
|
||||
model.rotate(0f, rotationAngle, 0f);
|
||||
model.scale(0.0008f);
|
||||
model.setShadowMode(ShadowMode.CastAndReceive);
|
||||
|
||||
// Bestimme die Verschiebung basierend auf der Rotation
|
||||
Vector3f translation = model.getLocalTranslation();
|
||||
|
||||
// Bei 0 oder 180 Grad wird auf der Z-Achse verschoben, bei 90 oder 270 Grad auf der X-Achse
|
||||
if (rotationAngle == 0 || rotationAngle == FastMath.PI) {
|
||||
// Verschiebe auf der Z-Achse und um 2f nach oben
|
||||
translation = translation.add(0,0,0); // Nach hinten auf der Z-Achse, und um 2f nach oben
|
||||
} else if (rotationAngle == FastMath.HALF_PI || rotationAngle == 3 * FastMath.HALF_PI) {
|
||||
// Verschiebe auf der X-Achse und um 2f nach oben
|
||||
translation = translation.add(0,0,0); // Nach hinten auf der X-Achse, und um 2f nach oben
|
||||
}
|
||||
|
||||
model.setLocalTranslation(translation);
|
||||
|
||||
return model;
|
||||
|
||||
}
|
||||
private Spatial createTie_Fighter(Battleship ship) {
|
||||
final Spatial model = app.getAssetManager().loadModel(TIE_FIGHTER);
|
||||
|
||||
model.rotate(-0f, calculateRotationAngle(ship.getRot()), 0f);
|
||||
model.scale(0.07f);
|
||||
model.setShadowMode(ShadowMode.CastAndReceive);
|
||||
model.setLocalTranslation(new Vector3f(model.getLocalTranslation().x, 2f, model.getLocalTranslation().z));
|
||||
|
||||
return model;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the rotation angle for the specified rotation.
|
||||
*
|
||||
* @param rot the rotation of the battleship
|
||||
* @return the rotation angle in radians
|
||||
*/
|
||||
private static float calculateRotationAngle(Rotation rot) {
|
||||
return switch (rot) {
|
||||
case RIGHT -> HALF_PI;
|
||||
case DOWN -> 0f;
|
||||
case LEFT -> -HALF_PI;
|
||||
case UP -> PI;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Creates and returns a 3D model representation of the given {@code Shell} object
|
||||
* for visualization in the game.
|
||||
*
|
||||
* @param shell The {@code Shell} object to be visualized.
|
||||
* @return A {@code Spatial} object representing the 3D model of the shell.
|
||||
*/
|
||||
@Override
|
||||
public Spatial visit(Shell shell) {
|
||||
final Spatial model = app.getAssetManager().loadModel("Models/Shell/shell.j3o");
|
||||
model.setLocalScale(.05f);
|
||||
model.setShadowMode(ShadowMode.CastAndReceive);
|
||||
Material mat = new Material(app.getAssetManager(), LIGHTING);
|
||||
mat.setTexture("DiffuseMap", app.getAssetManager().loadTexture("Models/Shell/shell_color.png"));
|
||||
mat.setReceivesShadows(true);
|
||||
model.setMaterial(mat);
|
||||
|
||||
model.addControl(new ShellControl(shell));
|
||||
return model;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.RenderManager;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.control.AbstractControl;
|
||||
import pp.battleship.model.Shell;
|
||||
import pp.util.Position;
|
||||
|
||||
/**
|
||||
* Controls the 2D representation of a {@code Shell} in the game, updating its position
|
||||
* based on the shell's current state in the game model. The {@code Shell2DControl} class
|
||||
* is responsible for translating the shell's 3D position to a 2D view position within
|
||||
* the game's map view.
|
||||
*/
|
||||
public class Shell2DControl extends AbstractControl {
|
||||
private final Shell shell;
|
||||
private final MapView view;
|
||||
|
||||
/**
|
||||
* Constructs a new {@code Shell2DControl} to manage the 2D visualization of the given {@code Shell}.
|
||||
*
|
||||
* @param view The {@code MapView} used to get information about the map to display.
|
||||
* @param shell The {@code Shell} being visualized.
|
||||
*/
|
||||
public Shell2DControl(MapView view, Shell shell){
|
||||
this.shell = shell;
|
||||
this.view = view;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the position of the shell's 2D representation based on the shell's current
|
||||
* 3D position in the game model. The position is mapped from model space to view space
|
||||
* coordinates and translated to the appropriate location within the {@code MapView}.
|
||||
*
|
||||
* @param tpf Time per frame, representing the time elapsed since the last frame.
|
||||
*/
|
||||
@Override
|
||||
protected void controlUpdate(float tpf) {
|
||||
Vector3f shellPos = shell.getPosition();
|
||||
Position viewPos = view.modelToView(shellPos.x, shellPos.z);
|
||||
spatial.setLocalTranslation(viewPos.getX() + MapView.FIELD_SIZE / 2, viewPos.getY() + MapView.FIELD_SIZE / 2, 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void controlRender(RenderManager rm, ViewPort vp) {
|
||||
// No rendering-specific behavior required for this control
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.RenderManager;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.control.AbstractControl;
|
||||
|
||||
import pp.battleship.model.Shell;
|
||||
import static pp.util.FloatMath.PI;
|
||||
|
||||
/**
|
||||
* Controls the 3D representation of a {@code Shell} in the game, updating its position
|
||||
* and rotation based on the shell's current state in the game model. The {@code ShellControl}
|
||||
* class ensures that the spatial associated with the shell is positioned and oriented correctly
|
||||
* within the world.
|
||||
*/
|
||||
public class ShellControl extends AbstractControl {
|
||||
private final Shell shell;
|
||||
|
||||
/**
|
||||
* Constructs a new {@code ShellControl} to manage the 3D visualization of the given {@code Shell}.
|
||||
*
|
||||
* @param shell The {@code Shell} being visualized and controlled.
|
||||
*/
|
||||
public ShellControl(Shell shell){
|
||||
super();
|
||||
this.shell = shell;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the 3D position and rotation of the shell based on its current state.
|
||||
* Converts map coordinates to world coordinates and applies the shell's orientation.
|
||||
*
|
||||
* @param tpf Time per frame, representing the elapsed time since the last update.
|
||||
*/
|
||||
@Override
|
||||
protected void controlUpdate(float tpf) {
|
||||
Vector3f pos = shell.getPosition();
|
||||
Vector3f fixed = new Vector3f(pos.z + 0.5f, pos.y + 2f, pos.x + 0.5f);
|
||||
fixed.setY(pos.y);
|
||||
spatial.setLocalTranslation(fixed);
|
||||
spatial.setLocalRotation(shell.getRotation());
|
||||
spatial.rotate(PI/2,0,0);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void controlRender(RenderManager rm, ViewPort vp) {
|
||||
// No rendering-specific behavior required for this control
|
||||
}
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.math.Quaternion;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.RenderManager;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.control.AbstractControl;
|
||||
import pp.battleship.model.Battleship;
|
||||
|
||||
import static pp.util.FloatMath.DEG_TO_RAD;
|
||||
import static pp.util.FloatMath.TWO_PI;
|
||||
import static pp.util.FloatMath.sin;
|
||||
|
||||
/**
|
||||
* Controls the oscillating pitch motion of a battleship model in the game.
|
||||
* The ship oscillates to simulate a realistic movement on water, based on its orientation and length.
|
||||
*/
|
||||
class ShipControl extends AbstractControl {
|
||||
/**
|
||||
* The axis of rotation for the ship's pitch (tilting forward and backward).
|
||||
*/
|
||||
private final Vector3f axis;
|
||||
|
||||
/**
|
||||
* The duration of one complete oscillation cycle in seconds.
|
||||
*/
|
||||
private final float cycle;
|
||||
|
||||
/**
|
||||
* The amplitude of the pitch oscillation in radians, determining how much the ship tilts.
|
||||
*/
|
||||
private final float amplitude;
|
||||
|
||||
/**
|
||||
* A quaternion representing the ship's current pitch rotation.
|
||||
*/
|
||||
private final Quaternion pitch = new Quaternion();
|
||||
|
||||
/**
|
||||
* The current time within the oscillation cycle, used to calculate the ship's pitch angle.
|
||||
*/
|
||||
private float time;
|
||||
|
||||
/**
|
||||
* Constructs a new ShipControl instance for the specified Battleship.
|
||||
* The ship's orientation determines the axis of rotation, while its length influences
|
||||
* the cycle duration and amplitude of the oscillation.
|
||||
*
|
||||
* @param ship the Battleship object to control
|
||||
*/
|
||||
public ShipControl(Battleship ship) {
|
||||
// Determine the axis of rotation based on the ship's orientation
|
||||
axis = switch (ship.getRot()) {
|
||||
case LEFT, RIGHT -> Vector3f.UNIT_X;
|
||||
case UP, DOWN -> Vector3f.UNIT_Z;
|
||||
};
|
||||
|
||||
// Set the cycle duration and amplitude based on the ship's length
|
||||
cycle = ship.getLength() * 2f;
|
||||
amplitude = 5f * DEG_TO_RAD / ship.getLength();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the ship's pitch oscillation each frame. The ship's pitch is adjusted
|
||||
* to create a continuous tilting motion, simulating the effect of waves.
|
||||
*
|
||||
* @param tpf time per frame (in seconds), used to calculate the new pitch angle
|
||||
*/
|
||||
@Override
|
||||
protected void controlUpdate(float tpf) {
|
||||
// If spatial is null, do nothing
|
||||
if (spatial == null) return;
|
||||
|
||||
// Update the time within the oscillation cycle
|
||||
time = (time + tpf) % cycle;
|
||||
|
||||
// Calculate the current angle of the oscillation
|
||||
final float angle = amplitude * sin(time * TWO_PI / cycle);
|
||||
|
||||
// Update the pitch Quaternion with the new angle
|
||||
pitch.fromAngleAxis(angle, axis);
|
||||
|
||||
// Apply the pitch rotation to the spatial
|
||||
spatial.setLocalRotation(pitch);
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is called during the rendering phase, but it does not perform any
|
||||
* operations in this implementation as the control only influences the spatial's
|
||||
* transformation, not its rendering process.
|
||||
*
|
||||
* @param rm the RenderManager rendering the controlled Spatial (not null)
|
||||
* @param vp the ViewPort being rendered (not null)
|
||||
*/
|
||||
@Override
|
||||
protected void controlRender(RenderManager rm, ViewPort vp) {
|
||||
// No rendering logic is needed for this control
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import pp.battleship.model.Item;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.model.Visitor;
|
||||
import pp.battleship.notification.GameEventListener;
|
||||
import pp.battleship.notification.ItemAddedEvent;
|
||||
import pp.battleship.notification.ItemRemovedEvent;
|
||||
import pp.view.ModelViewSynchronizer;
|
||||
|
||||
/**
|
||||
* Abstract base class for synchronizing the visual representation of a {@link ShipMap} with its model state.
|
||||
* This class handles the addition and removal of items from the ship map, ensuring that changes in the model
|
||||
* are accurately reflected in the view.
|
||||
* <p>
|
||||
* Subclasses are responsible for providing the specific implementation of how each item in the map
|
||||
* is represented visually by implementing the {@link Visitor} interface.
|
||||
* </p>
|
||||
*/
|
||||
abstract class ShipMapSynchronizer extends ModelViewSynchronizer<Item> implements Visitor<Spatial>, GameEventListener {
|
||||
// The ship map that this synchronizer is responsible for
|
||||
private final ShipMap shipMap;
|
||||
|
||||
/**
|
||||
* Constructs a new ShipMapSynchronizer.
|
||||
* Initializes the synchronizer with the provided ship map and the root node for attaching view representations.
|
||||
*
|
||||
* @param map the ship map to be synchronized
|
||||
* @param root the root node to which the view representations of the ship map items are attached
|
||||
*/
|
||||
protected ShipMapSynchronizer(ShipMap map, Node root) {
|
||||
super(root);
|
||||
this.shipMap = map;
|
||||
}
|
||||
|
||||
/**
|
||||
* Translates a model item into its corresponding visual representation.
|
||||
* The specific visual representation is determined by the concrete implementation of the {@link Visitor} interface.
|
||||
*
|
||||
* @param item the item from the model to be translated
|
||||
* @return the visual representation of the item as a {@link Spatial}
|
||||
*/
|
||||
@Override
|
||||
protected Spatial translate(Item item) {
|
||||
return item.accept(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the existing items from the ship map to the view.
|
||||
* This method should be called during initialization to ensure that all current items in the ship map
|
||||
* are visually represented.
|
||||
*/
|
||||
protected void addExisting() {
|
||||
shipMap.getItems().forEach(this::add);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the event when an item is removed from the ship map.
|
||||
* Removes the visual representation of the item from the view if it belongs to the synchronized ship map.
|
||||
*
|
||||
* @param event the event indicating that an item has been removed from the ship map
|
||||
*/
|
||||
@Override
|
||||
public void receivedEvent(ItemRemovedEvent event) {
|
||||
if (shipMap == event.map())
|
||||
delete(event.item());
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the event when an item is added to the ship map.
|
||||
* Adds the visual representation of the new item to the view if it belongs to the synchronized ship map.
|
||||
*
|
||||
* @param event the event indicating that an item has been added to the ship map
|
||||
*/
|
||||
@Override
|
||||
public void receivedEvent(ItemAddedEvent event) {
|
||||
if (shipMap == event.map())
|
||||
add(event.item());
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Quaternion;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.RenderManager;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.control.AbstractControl;
|
||||
|
||||
/**
|
||||
* Control that handles the sinking effect for destroyed ships.
|
||||
* It will gradually move the ship downwards and then remove it from the scene.
|
||||
*/
|
||||
class SinkingControl extends AbstractControl {
|
||||
private static final float SINK_DURATION = 2f; // Duration of the sinking animation
|
||||
private static final float SINK_SPEED = 0.6f; // Speed at which the ship sinks
|
||||
private float elapsedTime = 0;
|
||||
|
||||
private final Node shipNode;
|
||||
|
||||
/**
|
||||
* Constructs a {@code SinkingControl} object with the shipNode to be to be sunk
|
||||
* @param shipNode the node to handeld
|
||||
*/
|
||||
public SinkingControl(Node shipNode) {
|
||||
this.shipNode = shipNode;
|
||||
}
|
||||
float tiltAngle= 0;
|
||||
/**
|
||||
* Updated the Map to sink the ship
|
||||
*
|
||||
* @param tpf time per frame
|
||||
*/
|
||||
@Override
|
||||
protected void controlUpdate(float tpf) {
|
||||
// Update the sinking effect
|
||||
elapsedTime += tpf;
|
||||
|
||||
// Move the ship down over time
|
||||
Vector3f currentPos = shipNode.getLocalTranslation();
|
||||
shipNode.setLocalTranslation(currentPos.x+SINK_SPEED*tpf, currentPos.y - SINK_SPEED * tpf*2, currentPos.z+SINK_SPEED*tpf*2);
|
||||
|
||||
// Check if sinking duration has passed
|
||||
if (elapsedTime >= SINK_DURATION) {
|
||||
// Remove the ship from the scene
|
||||
shipNode.removeFromParent();
|
||||
}
|
||||
// Apply the tilt angle and rotation during sinking
|
||||
float sinkingTiltAngle = FastMath.DEG_TO_RAD * tiltAngle * tpf;
|
||||
float sinkingRotationAngle = FastMath.DEG_TO_RAD * 45f * tpf; // Additional rotation during sinking
|
||||
Quaternion tiltRotation = new Quaternion().fromAngles(-sinkingTiltAngle, sinkingRotationAngle, 0);
|
||||
spatial.setLocalRotation(tiltRotation);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void controlRender(RenderManager rm, ViewPort vp) {
|
||||
// No rendering-related code needed
|
||||
}
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.jme3.math.FastMath;
|
||||
import com.jme3.math.Quaternion;
|
||||
import com.jme3.math.Vector3f;
|
||||
import com.jme3.renderer.RenderManager;
|
||||
import com.jme3.renderer.ViewPort;
|
||||
import com.jme3.scene.Node;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.scene.control.AbstractControl;
|
||||
|
||||
/**
|
||||
* Controls the burning, tilting, and sinking behavior of a battleship.
|
||||
* The ship will burn and tilt for a specified duration, then sink below the water surface.
|
||||
*/
|
||||
public class SinkingShip extends AbstractControl {
|
||||
|
||||
private float elapsedTime = 0.2f;
|
||||
private final float burnTiltDuration;
|
||||
private final float sinkDuration;
|
||||
private final float sinkDepth;
|
||||
private final float tiltAngle;
|
||||
private final Vector3f initialPosition;
|
||||
private boolean sinkingStarted = false;
|
||||
|
||||
/**
|
||||
* Constructs a new ShipSinkingControl instance.
|
||||
*
|
||||
* @param burnTiltDuration Time in seconds for the ship to burn and tilt on the surface
|
||||
* @param sinkDuration Time in seconds for the ship to fully sink
|
||||
* @param sinkDepth Depth below the water to sink the ship
|
||||
* @param tiltAngle Final tilt angle in degrees
|
||||
*/
|
||||
public SinkingShip(float burnTiltDuration, float sinkDuration, float sinkDepth, float tiltAngle) {
|
||||
this.burnTiltDuration = burnTiltDuration;
|
||||
this.sinkDuration = sinkDuration;
|
||||
this.sinkDepth = sinkDepth;
|
||||
this.tiltAngle = tiltAngle;
|
||||
this.initialPosition = new Vector3f(); // Placeholder; will be set in controlUpdate
|
||||
}
|
||||
|
||||
/**
|
||||
* Overrides controlUpdate in AbstractControl
|
||||
* regulates the burn and tilt timeframe
|
||||
* @param tpf time per frame (in seconds)
|
||||
*/
|
||||
|
||||
@Override
|
||||
protected void controlUpdate(float tpf) {
|
||||
if (spatial == null) return;
|
||||
|
||||
elapsedTime += tpf;
|
||||
|
||||
if (elapsedTime < burnTiltDuration) {
|
||||
float progress = elapsedTime / burnTiltDuration;
|
||||
|
||||
float angleInRadians = FastMath.DEG_TO_RAD * FastMath.interpolateLinear(progress, 0f, -tiltAngle);
|
||||
Quaternion tiltRotation = new Quaternion().fromAngles(angleInRadians, 0, 0);
|
||||
spatial.setLocalRotation(tiltRotation);
|
||||
return;
|
||||
}
|
||||
|
||||
// Start sinking if it hasn't started yet
|
||||
if (!sinkingStarted) {
|
||||
sinkingStarted = true;
|
||||
// Save the initial position when sinking starts
|
||||
initialPosition.set(spatial.getLocalTranslation());
|
||||
|
||||
// Remove the hitEffectNode
|
||||
Node parentNode = (Node) spatial;
|
||||
Spatial hitEffects = parentNode.getChild("HitEffectNode");
|
||||
if (hitEffects != null) {
|
||||
parentNode.detachChild(hitEffects);
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate the progress of the sinking (0 to 1)
|
||||
float progress = Math.min((elapsedTime - burnTiltDuration) / sinkDuration, 1f);
|
||||
|
||||
// Apply the tilt angle (remains constant during sinking)
|
||||
float sinkingTiltAngle = FastMath.DEG_TO_RAD * tiltAngle * progress;
|
||||
float sinkingRotationAngle = FastMath.DEG_TO_RAD * 45f * progress; // Additional rotation during sinking (test)
|
||||
Quaternion tiltRotation = new Quaternion().fromAngles(-sinkingTiltAngle, sinkingRotationAngle, sinkingRotationAngle);
|
||||
spatial.setLocalRotation(tiltRotation);
|
||||
|
||||
// Sink the ship by interpolating the Y position
|
||||
float currentY = FastMath.interpolateLinear(progress, initialPosition.y, sinkDepth);
|
||||
spatial.setLocalTranslation(initialPosition.x, currentY, initialPosition.z);
|
||||
|
||||
if (currentY <= sinkDepth) {
|
||||
Node parentNode = (Node) spatial.getParent();
|
||||
if (parentNode != null) {
|
||||
parentNode.detachChild(spatial);
|
||||
}
|
||||
spatial.removeControl(this);
|
||||
}
|
||||
// public void checkAndTriggerExplosion() {
|
||||
// // Prüfen, ob das sinkende Schiff den Boden erreicht hat
|
||||
// if (spatial != null && spatial.getLocalTranslation().y <= sinkDepth) {
|
||||
// // Explosion ausführen, wenn der Boden erreicht ist
|
||||
// triggerExplosionAnimation();
|
||||
//
|
||||
// // Entfernen des Schiffs aus dem Elternknoten
|
||||
// Node parentNode = (Node) spatial.getParent();
|
||||
// if (parentNode != null) {
|
||||
// parentNode.detachChild(spatial);
|
||||
// }
|
||||
//
|
||||
// // Entfernen der Kontrolle vom Spatial
|
||||
// spatial.removeControl(this);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private void triggerExplosionAnimation() {
|
||||
// // Code für die Explosion-Animation (alibi Methode)
|
||||
// System.out.println("Explosion wird ausgeführt: Das Schiff hat den Boden erreicht!");
|
||||
// // Hier könnte eine echte Animation eingefügt werden, z.B. Partikeleffekte
|
||||
// }
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is called during the rendering phase, but it does not perform any
|
||||
* operations in this implementation as the control only influences the spatial's
|
||||
* transformation, not its rendering process.
|
||||
*
|
||||
* @param rm the RenderManager rendering the controlled Spatial (not null)
|
||||
* @param vp the ViewPort being rendered (not null)
|
||||
*/
|
||||
@Override
|
||||
protected void controlRender(RenderManager rm, ViewPort vp) {
|
||||
// No rendering logic is needed for this control
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the sinking process for the ship.
|
||||
*/
|
||||
public void startSinking() {
|
||||
// --> sinkingControl
|
||||
}
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package pp.battleship.client.gui;
|
||||
|
||||
import com.simsilica.lemur.Slider;
|
||||
|
||||
public class VolumeSlider extends Slider {
|
||||
|
||||
private final BgMusic music;
|
||||
|
||||
private double vol;
|
||||
|
||||
public VolumeSlider(BgMusic music) {
|
||||
super();
|
||||
this.music = music;
|
||||
vol = BgMusic.volumeInPreferences();
|
||||
getModel().setPercent(vol);
|
||||
}
|
||||
|
||||
public void update() {
|
||||
if (vol != getModel().getPercent()) {
|
||||
vol = getModel().getPercent();
|
||||
music.setVolume( (float) vol);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,183 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.server;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.concurrent.BlockingQueue;
|
||||
import java.util.concurrent.LinkedBlockingQueue;
|
||||
import java.util.logging.LogManager;
|
||||
|
||||
import com.jme3.network.ConnectionListener;
|
||||
import com.jme3.network.HostedConnection;
|
||||
import com.jme3.network.Message;
|
||||
import com.jme3.network.MessageListener;
|
||||
import com.jme3.network.Network;
|
||||
import com.jme3.network.Server;
|
||||
import com.jme3.network.serializing.Serializer;
|
||||
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.game.server.Player;
|
||||
import pp.battleship.game.server.ServerGameLogic;
|
||||
import pp.battleship.game.server.ServerSender;
|
||||
import pp.battleship.message.client.AnimationFinishedMessage;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.ServerMessage;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Shot;
|
||||
|
||||
/**
|
||||
* Server implementing the visitor pattern as MessageReceiver for ClientMessages
|
||||
*/
|
||||
public class BattleshipSelfhostServer implements MessageListener<HostedConnection>, ConnectionListener, ServerSender {
|
||||
private static final Logger LOGGER = System.getLogger(BattleshipSelfhostServer.class.getName());
|
||||
private static final File CONFIG_FILE = new File("server.properties");
|
||||
|
||||
private final BattleshipConfig config = new BattleshipConfig();
|
||||
private Server myServer;
|
||||
private final ServerGameLogic logic;
|
||||
private final BlockingQueue<ReceivedMessageSelfhost> pendingMessages = new LinkedBlockingQueue<>();
|
||||
|
||||
static {
|
||||
// Configure logging
|
||||
LogManager manager = LogManager.getLogManager();
|
||||
try {
|
||||
manager.readConfiguration(new FileInputStream("logging.properties"));
|
||||
LOGGER.log(Level.INFO, "Successfully read logging properties"); //NON-NLS
|
||||
}
|
||||
catch (IOException e) {
|
||||
LOGGER.log(Level.INFO, e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the Battleships server.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
new BattleshipSelfhostServer().run();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the server.
|
||||
*/
|
||||
BattleshipSelfhostServer() {
|
||||
config.readFromIfExists(CONFIG_FILE);
|
||||
LOGGER.log(Level.INFO, "Configuration: {0}", config); //NON-NLS
|
||||
logic = new ServerGameLogic(this, config);
|
||||
}
|
||||
|
||||
public void run() {
|
||||
startServer();
|
||||
while (true)
|
||||
processNextMessage();
|
||||
}
|
||||
|
||||
private void startServer() {
|
||||
try {
|
||||
LOGGER.log(Level.INFO, "Starting server..."); //NON-NLS
|
||||
myServer = Network.createServer(config.getPort());
|
||||
initializeSerializables();
|
||||
myServer.start();
|
||||
registerListeners();
|
||||
LOGGER.log(Level.INFO, "Server started: {0}", myServer.isRunning()); //NON-NLS
|
||||
}
|
||||
catch (IOException e) {
|
||||
LOGGER.log(Level.ERROR, "Couldn't start server: {0}", e.getMessage()); //NON-NLS
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
private void processNextMessage() {
|
||||
try {
|
||||
pendingMessages.take().process(logic);
|
||||
}
|
||||
catch (InterruptedException ex) {
|
||||
LOGGER.log(Level.INFO, "Interrupted while waiting for messages"); //NON-NLS
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
}
|
||||
|
||||
private void initializeSerializables() {
|
||||
Serializer.registerClass(GameDetails.class);
|
||||
Serializer.registerClass(StartBattleMessage.class);
|
||||
Serializer.registerClass(MapMessage.class);
|
||||
Serializer.registerClass(ShootMessage.class);
|
||||
Serializer.registerClass(EffectMessage.class);
|
||||
Serializer.registerClass(Battleship.class);
|
||||
Serializer.registerClass(IntPoint.class);
|
||||
Serializer.registerClass(Shot.class);
|
||||
Serializer.registerClass(AnimationFinishedMessage.class);
|
||||
}
|
||||
|
||||
private void registerListeners() {
|
||||
myServer.addMessageListener(this, MapMessage.class);
|
||||
myServer.addMessageListener(this, ShootMessage.class);
|
||||
myServer.addConnectionListener(this);
|
||||
myServer.addMessageListener(this, AnimationFinishedMessage.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void messageReceived(HostedConnection source, Message message) {
|
||||
LOGGER.log(Level.INFO, "message received from {0}: {1}", source.getId(), message); //NON-NLS
|
||||
if (message instanceof ClientMessage clientMessage)
|
||||
pendingMessages.add(new ReceivedMessageSelfhost(clientMessage, source.getId()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void connectionAdded(Server server, HostedConnection hostedConnection) {
|
||||
LOGGER.log(Level.INFO, "new connection {0}", hostedConnection); //NON-NLS
|
||||
logic.addPlayer(hostedConnection.getId());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void connectionRemoved(Server server, HostedConnection hostedConnection) {
|
||||
LOGGER.log(Level.INFO, "connection closed: {0}", hostedConnection); //NON-NLS
|
||||
final Player player = logic.getPlayerById(hostedConnection.getId());
|
||||
if (player == null)
|
||||
LOGGER.log(Level.INFO, "closed connection does not belong to an active player"); //NON-NLS
|
||||
else { //NON-NLS
|
||||
LOGGER.log(Level.INFO, "closed connection belongs to {0}", player); //NON-NLS
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
private void exit(int exitValue) { //NON-NLS
|
||||
LOGGER.log(Level.INFO, "close request"); //NON-NLS
|
||||
if (myServer != null)
|
||||
for (HostedConnection client : myServer.getConnections()) //NON-NLS
|
||||
if (client != null) client.close("Game over"); //NON-NLS
|
||||
System.exit(exitValue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the specified message to the specified connection.
|
||||
*
|
||||
* @param id the connection id
|
||||
* @param message the message
|
||||
*/
|
||||
public void send(int id, ServerMessage message) {
|
||||
if (myServer == null || !myServer.isRunning()) {
|
||||
LOGGER.log(Level.ERROR, "no server running when trying to send {0}", message); //NON-NLS
|
||||
return;
|
||||
}
|
||||
final HostedConnection connection = myServer.getConnection(id);
|
||||
if (connection != null)
|
||||
connection.send(message);
|
||||
else
|
||||
LOGGER.log(Level.ERROR, "there is no connection with id={0}", id); //NON-NLS
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.client.server;
|
||||
|
||||
import pp.battleship.message.client.ClientInterpreter;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
|
||||
record ReceivedMessageSelfhost(ClientMessage message, int from) {
|
||||
void process(ClientInterpreter interpreter) {
|
||||
message.accept(interpreter, from);
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 46 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 63 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.8 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 28 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 43 KiB |
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 354 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 164 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 220 KiB |
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,4 +0,0 @@
|
||||
based on:
|
||||
water 002
|
||||
by Katsukagi on 29/11/2018
|
||||
https://3dtextures.me/2018/11/29/water-002/
|
||||
@@ -1,14 +0,0 @@
|
||||
Material Water : Common/MatDefs/Light/Lighting.j3md {
|
||||
MaterialParameters {
|
||||
Shininess : 6
|
||||
DiffuseMap : Repeat Textures/Terrain/Water/Water_002_COLOR.jpg
|
||||
NormalMap : Repeat Textures/Terrain/Water/Water_002_NORM.jpg
|
||||
SpecularMap : Repeat Textures/Terrain/Water/Water_002_ROUGH.jpg
|
||||
ParallaxMap : Repeat Textures/Terrain/Water/Water_002_DISP.png
|
||||
// PackedNormalParallax : true
|
||||
// UseMaterialColors : true
|
||||
Ambient : 0.5 0.5 0.5 1.0
|
||||
Diffuse : 1.0 1.0 1.0 1.0
|
||||
Specular : 1.0 1.0 1.0 1.0
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 207 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 88 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 31 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 70 KiB |
@@ -1,2 +0,0 @@
|
||||
[LocalizedFileNames]
|
||||
Water_002_NORM.jpg=@Water_002_NORM,0
|
||||
@@ -1,16 +0,0 @@
|
||||
plugins {
|
||||
id 'buildlogic.jme-application-conventions'
|
||||
}
|
||||
|
||||
description = 'Battleship converter for resources'
|
||||
|
||||
dependencies {
|
||||
implementation libs.jme3.core
|
||||
|
||||
runtimeOnly libs.jme3.desktop
|
||||
runtimeOnly libs.jme3.plugins
|
||||
}
|
||||
|
||||
application {
|
||||
mainClass = 'pp.battleship.exporter.ModelExporter'
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package pp.battleship.exporter;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import com.jme3.app.SimpleApplication;
|
||||
import com.jme3.export.JmeExporter;
|
||||
import com.jme3.export.binary.BinaryExporter;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.jme3.system.JmeContext;
|
||||
import com.jme3.util.TangentBinormalGenerator;
|
||||
|
||||
/**
|
||||
* This class transforms models into j3o format.
|
||||
*/
|
||||
public class ModelExporter extends SimpleApplication {
|
||||
private static final Logger LOGGER = System.getLogger(ModelExporter.class.getName());
|
||||
|
||||
/**
|
||||
* The main method of the converter
|
||||
*
|
||||
* @param args input args
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
ModelExporter application = new ModelExporter();
|
||||
application.start(JmeContext.Type.Headless);
|
||||
}
|
||||
|
||||
/**
|
||||
* Overrides {@link com.jme3.app.SimpleApplication#simpleInitApp()}.
|
||||
* It initializes a simple app by exporting robots and rocks.
|
||||
*/
|
||||
@Override
|
||||
public void simpleInitApp() {
|
||||
export("Models/45.obj", "45.j3o");//NON-NLS passt
|
||||
//export("Models/.j3o");
|
||||
// export("Models/Transporter/Transporter.obj", "Transporter.j3o"); //NON-NLS passt
|
||||
// export("Models/TieFighter.obj", "TieFighter.j3o"); //NON-NLS
|
||||
// export("Models/Venator/Venator.obj", "Venator.j3o"); //NON-NLS kickt
|
||||
|
||||
|
||||
|
||||
stop();
|
||||
}
|
||||
|
||||
/**
|
||||
* Exports spatial into a file
|
||||
*
|
||||
* @param fileName the file name of the model
|
||||
* @param exportFileName the name of the file where the .j3o file is going to be stored
|
||||
*/
|
||||
private void export(String fileName, String exportFileName) {
|
||||
final File file = new File(exportFileName);
|
||||
JmeExporter exporter = BinaryExporter.getInstance();
|
||||
try {
|
||||
final Spatial model = getAssetManager().loadModel(fileName);
|
||||
TangentBinormalGenerator.generate(model);
|
||||
exporter.save(model, file);
|
||||
}
|
||||
catch (IOException exception) {
|
||||
LOGGER.log(Level.ERROR, "write to {0} failed", file); //NON-NLS
|
||||
throw new RuntimeException(exception);
|
||||
}
|
||||
LOGGER.log(Level.INFO, "wrote file {0}", file); //NON-NLS
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,72 +0,0 @@
|
||||
# Blender MTL File: 'SpaceShipDetailed.blend'
|
||||
# Material Count: 7
|
||||
|
||||
newmtl Material.001
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.002
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.003
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.004
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.005
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.006
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
|
||||
newmtl Material.007
|
||||
Ns 96.078431
|
||||
Ka 1.000000 1.000000 1.000000
|
||||
Kd 0.640000 0.640000 0.640000
|
||||
Ks 0.500000 0.500000 0.500000
|
||||
Ke 0.000000 0.000000 0.000000
|
||||
Ni 1.000000
|
||||
d 1.000000
|
||||
illum 2
|
||||
File diff suppressed because it is too large
Load Diff
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@@ -1,48 +0,0 @@
|
||||
# WaveFront *.mtl file (generated by CINEMA 4D)
|
||||
|
||||
newmtl small parts
|
||||
Kd 0.50599998235703 0.53606665134430 0.55000001192093
|
||||
Ks 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
Ns 100
|
||||
illum 7
|
||||
|
||||
newmtl body . blue
|
||||
Kd 0.08579999953508 0.18754999339581 0.33000001311302
|
||||
Ks 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
Ns 100
|
||||
illum 7
|
||||
|
||||
newmtl Mat
|
||||
Ka 1.44000005722046 1.11624002456665 0.41760000586510
|
||||
Kd 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
d 0
|
||||
Tf 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
illum 7
|
||||
|
||||
newmtl Body
|
||||
Kd 0.62400001287460 0.64219999313354 0.64999997615814
|
||||
Ks 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
Ns 100
|
||||
illum 7
|
||||
|
||||
newmtl body . Red .1
|
||||
Kd 0.70999997854233 0.16329999268055 0.16329999268055
|
||||
Ks 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
Ns 100
|
||||
illum 7
|
||||
|
||||
newmtl Mat.1
|
||||
Kd 0.00000000000000 0.00000000000000 0.00000000000000
|
||||
Ks 0.72000002861023 0.72000002861023 0.72000002861023
|
||||
Ns 100
|
||||
d 0
|
||||
Tf 0.60000002384186 0.60000002384186 0.60000002384186
|
||||
Ni 1.517
|
||||
illum 7
|
||||
|
||||
newmtl Body 2 Dark
|
||||
Kd 0.20460000634193 0.21537999808788 0.21999999880791
|
||||
Ks 1.00000000000000 1.00000000000000 1.00000000000000
|
||||
Ns 100
|
||||
illum 7
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,12 +0,0 @@
|
||||
plugins {
|
||||
id 'buildlogic.java-library-conventions'
|
||||
}
|
||||
|
||||
description = 'Battleship common model'
|
||||
|
||||
dependencies {
|
||||
api project(":common")
|
||||
api libs.jme3.networking
|
||||
implementation libs.gson
|
||||
testImplementation libs.mockito.core
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship;
|
||||
|
||||
import pp.util.config.Config;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import static java.lang.Math.max;
|
||||
|
||||
/**
|
||||
* Provides access to the configuration settings for the Battleship game.
|
||||
* <p>
|
||||
* This class allows for loading configuration settings from a properties file,
|
||||
* including the server port, map dimensions, and the number of ships of various lengths.
|
||||
* </p>
|
||||
* <p>
|
||||
* <b>Note:</b> Attributes of this class are not marked as {@code final} to allow
|
||||
* for proper initialization when reading from a properties file.
|
||||
* </p>
|
||||
*/
|
||||
public class BattleshipConfig extends Config {
|
||||
|
||||
/**
|
||||
* The default port number for the Battleship server.
|
||||
*/
|
||||
@Property("port")
|
||||
private int port = 1234;
|
||||
|
||||
/**
|
||||
* The width of the game map in terms of grid units.
|
||||
*/
|
||||
@Property("map.width")
|
||||
private int mapWidth = 10;
|
||||
|
||||
/**
|
||||
* The height of the game map in terms of grid units.
|
||||
*/
|
||||
@Property("map.height")
|
||||
private int mapHeight = 10;
|
||||
|
||||
/**
|
||||
* An array representing the number of ships available for each length.
|
||||
* The index corresponds to the ship length minus one, and the value at each index
|
||||
* is the number of ships of that length.
|
||||
*/
|
||||
@Property("ship.nums")
|
||||
private int[] shipNums = {4, 3, 2, 1};
|
||||
|
||||
/**
|
||||
* Creates an instance of {@code BattleshipConfig} with default settings.
|
||||
*/
|
||||
public BattleshipConfig() {
|
||||
// Default constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the port number configured for the Battleship server.
|
||||
*
|
||||
* @return the port number
|
||||
*/
|
||||
public int getPort() {
|
||||
return port;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the width of the game map. The width is guaranteed to be at least 2 units.
|
||||
*
|
||||
* @return the width of the game map
|
||||
*/
|
||||
public int getMapWidth() {
|
||||
return max(mapWidth, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the height of the game map. The height is guaranteed to be at least 2 units.
|
||||
*
|
||||
* @return the height of the game map
|
||||
*/
|
||||
public int getMapHeight() {
|
||||
return max(mapHeight, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a map representing the number of ships for each length.
|
||||
* The keys are ship lengths, and the values are the corresponding number of ships.
|
||||
*
|
||||
* @return a map of ship lengths to the number of ships
|
||||
*/
|
||||
public Map<Integer, Integer> getShipNums() {
|
||||
final TreeMap<Integer, Integer> ships = new TreeMap<>();
|
||||
for (int i = 0; i < shipNums.length; i++)
|
||||
if (shipNums[i] > 0)
|
||||
ships.put(i + 1, shipNums[i]);
|
||||
return ships;
|
||||
}
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship;
|
||||
|
||||
import java.util.ResourceBundle;
|
||||
|
||||
/**
|
||||
* Provides access to the resource bundle of the game.
|
||||
*
|
||||
* @see #BUNDLE
|
||||
*/
|
||||
public class Resources {
|
||||
/**
|
||||
* The resource bundle for the Battleship game.
|
||||
*/
|
||||
public static final ResourceBundle BUNDLE = ResourceBundle.getBundle("battleship"); //NON-NLS
|
||||
|
||||
/**
|
||||
* Gets a string for the given key from the resource bundle in {@linkplain #BUNDLE}.
|
||||
*
|
||||
* @param key the key for the desired string
|
||||
* @return the string for the given key
|
||||
* @throws NullPointerException if {@code key} is {@code null}
|
||||
* @throws java.util.MissingResourceException if no object for the given key can be found
|
||||
* @throws ClassCastException if the object found for the given key is not a string
|
||||
*/
|
||||
public static String lookup(String key) {
|
||||
return BUNDLE.getString(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Private constructor to prevent instantiation.
|
||||
*/
|
||||
private Resources() { /* do not instantiate */ }
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.Shell;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.notification.Sound;
|
||||
|
||||
/**
|
||||
* Represents the state of the client where players take turns to attack each other's ships.
|
||||
*/
|
||||
class BattleState extends ClientState {
|
||||
private boolean myTurn;
|
||||
|
||||
/**
|
||||
* Constructs a new instance of {@link BattleState}.
|
||||
*
|
||||
* @param logic the game logic
|
||||
* @param myTurn true if it is my turn
|
||||
*/
|
||||
public BattleState(ClientGameLogic logic, boolean myTurn) {
|
||||
super(logic);
|
||||
this.myTurn = myTurn;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean showBattle() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clickOpponentMap(IntPoint pos) {
|
||||
if (!myTurn)
|
||||
logic.setInfoText("wait.its.not.your.turn");
|
||||
else if (logic.getOpponentMap().isValid(pos))
|
||||
logic.send(new ShootMessage(pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports the effect of a shot based on the server message.
|
||||
*
|
||||
* @param msg the message containing the effect of the shot
|
||||
*/
|
||||
@Override
|
||||
public void receivedEffect(EffectMessage msg) {
|
||||
ClientGameLogic.LOGGER.log(Level.INFO, "report effect: {0}", msg); //NON-NLS
|
||||
myTurn = msg.isMyTurn();
|
||||
logic.setInfoText(msg.getInfoTextKey());
|
||||
Shell shell = new Shell(msg.getShot());
|
||||
affectedMap(msg).add(shell);
|
||||
logic.playSound(Sound.SHELL_FLYING);
|
||||
logic.setState(new ShootingState(logic, shell, myTurn, msg));
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which map (own or opponent's) should be affected by the shot based on the message.
|
||||
*
|
||||
* @param msg the effect message received from the server
|
||||
* @return the map (either the opponent's or player's own map) that is affected by the shot
|
||||
*/
|
||||
private ShipMap affectedMap(EffectMessage msg) {
|
||||
return msg.isOwnShot() ? logic.getOpponentMap() : logic.getOwnMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the opponent's ship was destroyed by the player's shot.
|
||||
*
|
||||
* @param msg the effect message received from the server
|
||||
* @return true if the shot destroyed an opponent's ship, false otherwise
|
||||
*/
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.game.singlemode.BattleshipClientConfig;
|
||||
|
||||
/**
|
||||
* Interface representing a Battleship client.
|
||||
* Provides methods to access game logic, configuration, and to enqueue tasks.
|
||||
*/
|
||||
public interface BattleshipClient {
|
||||
|
||||
/**
|
||||
* Returns the game logic associated with this client.
|
||||
*
|
||||
* @return the ClientGameLogic instance
|
||||
*/
|
||||
ClientGameLogic getGameLogic();
|
||||
|
||||
/**
|
||||
* Returns the configuration associated with this client.
|
||||
*
|
||||
* @return the BattleshipConfig instance
|
||||
*/
|
||||
BattleshipClientConfig getConfig();
|
||||
|
||||
/**
|
||||
* Enqueues a task to be executed by the client.
|
||||
*
|
||||
* @param runnable the task to be executed
|
||||
*/
|
||||
void enqueue(Runnable runnable);
|
||||
}
|
||||
@@ -1,355 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.ServerInterpreter;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.model.dto.ShipMapDTO;
|
||||
import pp.battleship.notification.ClientStateEvent;
|
||||
import pp.battleship.notification.GameEvent;
|
||||
import pp.battleship.notification.GameEventBroker;
|
||||
import pp.battleship.notification.GameEventListener;
|
||||
import pp.battleship.notification.InfoTextEvent;
|
||||
import pp.battleship.notification.Sound;
|
||||
import pp.battleship.notification.SoundEvent;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static java.lang.Math.max;
|
||||
|
||||
/**
|
||||
* Controls the client-side game logic for Battleship.
|
||||
* Manages the player's ship placement, interactions with the map, and response to server messages.
|
||||
*/
|
||||
public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
|
||||
static final Logger LOGGER = System.getLogger(ClientGameLogic.class.getName());
|
||||
private final ClientSender clientSender;
|
||||
private final List<GameEventListener> listeners = new ArrayList<>();
|
||||
private GameDetails details;
|
||||
private ShipMap ownMap;
|
||||
private ShipMap harbor;
|
||||
private ShipMap opponentMap;
|
||||
private ClientState state = new InitialState(this);
|
||||
|
||||
/**
|
||||
* Constructs a ClientGameLogic with the specified sender object.
|
||||
*
|
||||
* @param clientSender the object used to send messages to the server
|
||||
*/
|
||||
public ClientGameLogic(ClientSender clientSender) {
|
||||
this.clientSender = clientSender;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current state of the game logic.
|
||||
*/
|
||||
ClientState getState() {
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the current state of the game logic.
|
||||
*
|
||||
* @param newState the new state to be set
|
||||
*/
|
||||
void setState(ClientState newState) {
|
||||
LOGGER.log(Level.DEBUG, "state transition {0} --> {1}", state.getName(), newState.getName()); //NON-NLS
|
||||
state = newState;
|
||||
notifyListeners(new ClientStateEvent());
|
||||
state.entry();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the game details.
|
||||
*
|
||||
* @return the game details
|
||||
*/
|
||||
GameDetails getDetails() {
|
||||
return details;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the player's own map.
|
||||
*
|
||||
* @return the player's own map
|
||||
*/
|
||||
public ShipMap getOwnMap() {
|
||||
return ownMap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the opponent's map.
|
||||
*
|
||||
* @return the opponent's map
|
||||
*/
|
||||
public ShipMap getOpponentMap() {
|
||||
return opponentMap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the harbor map.
|
||||
*
|
||||
* @return the harbor map
|
||||
*/
|
||||
public ShipMap getHarbor() {
|
||||
return harbor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the editor should be shown.
|
||||
*
|
||||
* @return true if the editor should be shown, false otherwise
|
||||
*/
|
||||
public boolean showEditor() {
|
||||
return state.showEditor();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the battle state should be shown.
|
||||
*
|
||||
* @return true if the battle state should be shown, false otherwise
|
||||
*/
|
||||
public boolean showBattle() {
|
||||
return state.showBattle();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the game details provided by the server.
|
||||
*
|
||||
* @param details the game details including map size and ships
|
||||
*/
|
||||
@Override
|
||||
public void received(GameDetails details) {
|
||||
state.receivedGameDetails(details);
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves the preview ship to the specified position.
|
||||
*
|
||||
* @param pos the new position for the preview ship
|
||||
*/
|
||||
public void movePreview(IntPoint pos) {
|
||||
state.movePreview(pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the player's own map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
public void clickOwnMap(IntPoint pos) {
|
||||
state.clickOwnMap(pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the harbor map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
public void clickHarbor(IntPoint pos) {
|
||||
state.clickHarbor(pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the opponent's map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
public void clickOpponentMap(IntPoint pos) {
|
||||
state.clickOpponentMap(pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotates the preview ship.
|
||||
*/
|
||||
public void rotateShip() {
|
||||
state.rotateShip();
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks the player's map as finished.
|
||||
*/
|
||||
public void mapFinished() {
|
||||
state.mapFinished();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's map is complete (i.e., all ships are placed).
|
||||
*
|
||||
* @return true if all ships are placed, false otherwise
|
||||
*/
|
||||
public boolean isMapComplete() {
|
||||
return state.isMapComplete();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there is currently a preview ship.
|
||||
*
|
||||
* @return true if there is currently a preview ship, false otherwise
|
||||
*/
|
||||
public boolean movingShip() {
|
||||
return state.movingShip();
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the battle based on the server message.
|
||||
*
|
||||
* @param msg the message indicating whose turn it is to shoot
|
||||
*/
|
||||
@Override
|
||||
public void received(StartBattleMessage msg) {
|
||||
state.receivedStartBattle(msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports the effect of a shot based on the server message.
|
||||
*
|
||||
* @param msg the message containing the effect of the shot
|
||||
*/
|
||||
@Override
|
||||
public void received(EffectMessage msg) {
|
||||
state.receivedEffect(msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the player's own map, opponent's map, and harbor based on the game details.
|
||||
*
|
||||
* @param details the game details including map size and ships
|
||||
*/
|
||||
void initializeMaps(GameDetails details) {
|
||||
this.details = details;
|
||||
final int numShips = details.getShipNums().values().stream().mapToInt(Integer::intValue).sum();
|
||||
final int maxLength = details.getShipNums().keySet().stream().mapToInt(Integer::intValue).max().orElse(2);
|
||||
ownMap = new ShipMap(details.getWidth(), details.getHeight(), this);
|
||||
opponentMap = new ShipMap(details.getWidth(), details.getHeight(), this);
|
||||
harbor = new ShipMap(max(maxLength, 2), max(numShips, details.getHeight()), this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the informational text to be displayed to the player.
|
||||
*
|
||||
* @param key the key for the info text
|
||||
*/
|
||||
void setInfoText(String key) {
|
||||
notifyListeners(new InfoTextEvent(key));
|
||||
}
|
||||
|
||||
/**
|
||||
* Emits an event to play the specified sound.
|
||||
*
|
||||
* @param sound the sound to be played.
|
||||
*/
|
||||
public void playSound(Sound sound) {
|
||||
notifyListeners(new SoundEvent(sound));
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a map from the specified file.
|
||||
*
|
||||
* @param file the file to load the map from
|
||||
* @throws IOException if an I/O error occurs
|
||||
*/
|
||||
public void loadMap(File file) throws IOException {
|
||||
state.loadMap(file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's own map may be loaded from a file.
|
||||
*
|
||||
* @return true if the own map may be loaded from file, false otherwise
|
||||
*/
|
||||
public boolean mayLoadMap() {
|
||||
return state.mayLoadMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's own map may be saved to a file.
|
||||
*
|
||||
* @return true if the own map may be saved to file, false otherwise
|
||||
*/
|
||||
public boolean maySaveMap() {
|
||||
return state.maySaveMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves the player's own map to the specified file.
|
||||
*
|
||||
* @param file the file to save the map to
|
||||
* @throws IOException if the map cannot be saved in the current state
|
||||
*/
|
||||
public void saveMap(File file) throws IOException {
|
||||
if (ownMap != null && maySaveMap())
|
||||
new ShipMapDTO(ownMap).saveTo(file);
|
||||
else
|
||||
throw new IOException("You are not allowed to save the map in this state of the game");
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a message to the server.
|
||||
*
|
||||
* @param msg the message to be sent
|
||||
*/
|
||||
void send(ClientMessage msg) {
|
||||
if (clientSender == null)
|
||||
LOGGER.log(Level.ERROR, "trying to send {0} with sender==null", msg); //NON-NLS
|
||||
else
|
||||
clientSender.send(msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a listener to receive game events.
|
||||
*
|
||||
* @param listener the listener to add
|
||||
*/
|
||||
public synchronized void addListener(GameEventListener listener) {
|
||||
listeners.add(listener);
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a listener from receiving game events.
|
||||
*
|
||||
* @param listener the listener to remove
|
||||
*/
|
||||
public synchronized void removeListener(GameEventListener listener) {
|
||||
listeners.remove(listener);
|
||||
}
|
||||
|
||||
/**
|
||||
* Notifies all listeners of a game event.
|
||||
*
|
||||
* @param event the game event to notify listeners of
|
||||
*/
|
||||
@Override
|
||||
public void notifyListeners(GameEvent event) {
|
||||
final List<GameEventListener> copy;
|
||||
synchronized (this) {
|
||||
copy = new ArrayList<>(listeners);
|
||||
}
|
||||
for (GameEventListener listener : copy)
|
||||
event.notifyListener(listener);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called once per frame by the update loop.
|
||||
*
|
||||
* @param delta time in seconds since the last update call
|
||||
*/
|
||||
public void update(float delta) {
|
||||
state.update(delta);
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
|
||||
/**
|
||||
* Interface for sending messages to the server.
|
||||
*/
|
||||
public interface ClientSender {
|
||||
/**
|
||||
* Send the specified message to the server.
|
||||
*
|
||||
* @param message the message
|
||||
*/
|
||||
void send(ClientMessage message);
|
||||
}
|
||||
@@ -1,202 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.IntPoint;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
/**
|
||||
* Defines the behavior and state transitions for the client-side game logic.
|
||||
* Different states of the game logic implement this interface to handle various game events and actions.
|
||||
*/
|
||||
abstract class ClientState {
|
||||
/**
|
||||
* The game logic object.
|
||||
*/
|
||||
final ClientGameLogic logic;
|
||||
|
||||
/**
|
||||
* Constructs a client state of the specified game logic.
|
||||
*
|
||||
* @param logic the game logic
|
||||
*/
|
||||
ClientState(ClientGameLogic logic) {
|
||||
this.logic = logic;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to be overridden by subclasses for post-transition initialization.
|
||||
* By default, it does nothing, but it can be overridden in derived states.
|
||||
*/
|
||||
void entry() {
|
||||
// Default implementation does nothing
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the name of the current state.
|
||||
*
|
||||
* @return the name of the current state
|
||||
*/
|
||||
String getName() {
|
||||
return getClass().getSimpleName();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the editor should be shown.
|
||||
*
|
||||
* @return true if the editor should be shown, false otherwise
|
||||
*/
|
||||
boolean showEditor() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the battle state should be shown.
|
||||
*
|
||||
* @return true if the battle state should be shown, false otherwise
|
||||
*/
|
||||
boolean showBattle() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's map is complete (i.e., all ships are placed).
|
||||
*
|
||||
* @return true if all ships are placed, false otherwise
|
||||
*/
|
||||
boolean isMapComplete() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there is currently a preview ship.
|
||||
*
|
||||
* @return true if there is currently a preview ship, false otherwise
|
||||
*/
|
||||
boolean movingShip() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the player's own map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
void clickOwnMap(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "clickOwnMap has no effect in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the harbor map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
void clickHarbor(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "clickHarbor has no effect in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the opponent's map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
void clickOpponentMap(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "clickOpponentMap has no effect in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves the preview ship to the specified position.
|
||||
*
|
||||
* @param pos the new position for the preview ship
|
||||
*/
|
||||
void movePreview(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "movePreview has no effect in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotates the preview ship.
|
||||
*/
|
||||
void rotateShip() {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "rotateShip has no effect in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* The user has marked the map as finished.
|
||||
*/
|
||||
void mapFinished() {
|
||||
ClientGameLogic.LOGGER.log(Level.ERROR, "mapFinished not allowed in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the game details provided by the server.
|
||||
*
|
||||
* @param details the game details including map size and ships
|
||||
*/
|
||||
void receivedGameDetails(GameDetails details) {
|
||||
ClientGameLogic.LOGGER.log(Level.ERROR, "receivedGameDetails not allowed in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the battle based on the server message.
|
||||
*
|
||||
* @param msg the message indicating whose turn it is to shoot
|
||||
*/
|
||||
void receivedStartBattle(StartBattleMessage msg) {
|
||||
ClientGameLogic.LOGGER.log(Level.ERROR, "receivedStartBattle not allowed in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports the effect of a shot based on the server message.
|
||||
*
|
||||
* @param msg the message containing the effect of the shot
|
||||
*/
|
||||
void receivedEffect(EffectMessage msg) {
|
||||
ClientGameLogic.LOGGER.log(Level.ERROR, "receivedEffect not allowed in {0}", getName()); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a map from the specified file.
|
||||
*
|
||||
* @param file the file to load the map from
|
||||
* @throws IOException if the map cannot be loaded in the current state
|
||||
*/
|
||||
void loadMap(File file) throws IOException {
|
||||
throw new IOException("You are not allowed to load a map in this state of the game");
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the own map may be loaded from file.
|
||||
*
|
||||
* @return true if the own map may be loaded from file, false otherwise
|
||||
*/
|
||||
boolean mayLoadMap() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the own map may be saved to file.
|
||||
*
|
||||
* @return true if the own map may be saved to file, false otherwise
|
||||
*/
|
||||
boolean maySaveMap() {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called once per frame by the update loop if this state is active.
|
||||
*
|
||||
* @param delta time in seconds since the last update call
|
||||
*/
|
||||
void update(float delta) { /* do nothing by default */ }
|
||||
}
|
||||
@@ -1,267 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.IntPoint;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.model.dto.ShipMapDTO;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import static pp.battleship.model.Battleship.Status.INVALID_PREVIEW;
|
||||
import static pp.battleship.model.Battleship.Status.NORMAL;
|
||||
import static pp.battleship.model.Battleship.Status.VALID_PREVIEW;
|
||||
import static pp.battleship.model.Rotation.RIGHT;
|
||||
|
||||
/**
|
||||
* Represents the state of the client setting up the ship map.
|
||||
*/
|
||||
class EditorState extends ClientState {
|
||||
private Battleship preview;
|
||||
private Battleship selectedInHarbor;
|
||||
|
||||
/**
|
||||
* Constructs a new EditorState with the specified ClientGameLogic.
|
||||
*
|
||||
* @param logic the ClientGameLogic associated with this state
|
||||
*/
|
||||
public EditorState(ClientGameLogic logic) {
|
||||
super(logic);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true to indicate that the editor should be shown.
|
||||
*
|
||||
* @return true if the editor should be shown
|
||||
*/
|
||||
@Override
|
||||
public boolean showEditor() {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves the preview ship to the specified position.
|
||||
*
|
||||
* @param pos the new position for the preview ship
|
||||
*/
|
||||
@Override
|
||||
public void movePreview(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "move preview to {0}", pos); //NON-NLS
|
||||
if (preview == null || !ownMap().isValid(pos)) return;
|
||||
preview.moveTo(pos);
|
||||
setPreviewStatus(preview);
|
||||
ownMap().remove(preview);
|
||||
ownMap().add(preview);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the player's own map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
@Override
|
||||
public void clickOwnMap(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "click at {0} in own map", pos); //NON-NLS
|
||||
if (!ownMap().isValid(pos)) return;
|
||||
if (preview == null)
|
||||
modifyShip(pos);
|
||||
else
|
||||
placeShip(pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies a ship on the map at the specified position.
|
||||
*
|
||||
* @param cursor the position of the ship to modify
|
||||
*/
|
||||
private void modifyShip(IntPoint cursor) {
|
||||
preview = ownMap().findShipAt(cursor);
|
||||
if (preview == null)
|
||||
return;
|
||||
preview.moveTo(cursor);
|
||||
setPreviewStatus(preview);
|
||||
ownMap().remove(preview);
|
||||
ownMap().add(preview);
|
||||
selectedInHarbor = new Battleship(preview.getLength(), 0, freeY(), RIGHT);
|
||||
selectedInHarbor.setStatus(VALID_PREVIEW);
|
||||
harbor().add(selectedInHarbor);
|
||||
}
|
||||
|
||||
/**
|
||||
* Places the preview ship at the specified position.
|
||||
*
|
||||
* @param cursor the position to place the ship
|
||||
*/
|
||||
private void placeShip(IntPoint cursor) {
|
||||
ownMap().remove(preview);
|
||||
preview.moveTo(cursor);
|
||||
if (ownMap().isValid(preview)) {
|
||||
preview.setStatus(NORMAL);
|
||||
ownMap().add(preview);
|
||||
harbor().remove(selectedInHarbor);
|
||||
preview = null;
|
||||
selectedInHarbor = null;
|
||||
}
|
||||
else {
|
||||
preview.setStatus(INVALID_PREVIEW);
|
||||
ownMap().add(preview);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a click on the harbor map.
|
||||
*
|
||||
* @param pos the position where the click occurred
|
||||
*/
|
||||
@Override
|
||||
public void clickHarbor(IntPoint pos) {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "click at {0} in harbor", pos); //NON-NLS
|
||||
if (!harbor().isValid(pos)) return;
|
||||
final Battleship shipAtCursor = harbor().findShipAt(pos);
|
||||
if (preview != null) {
|
||||
ownMap().remove(preview);
|
||||
selectedInHarbor.setStatus(NORMAL);
|
||||
harbor().remove(selectedInHarbor);
|
||||
harbor().add(selectedInHarbor);
|
||||
preview = null;
|
||||
selectedInHarbor = null;
|
||||
}
|
||||
else if (shipAtCursor != null) {
|
||||
selectedInHarbor = shipAtCursor;
|
||||
selectedInHarbor.setStatus(VALID_PREVIEW);
|
||||
harbor().remove(selectedInHarbor);
|
||||
harbor().add(selectedInHarbor);
|
||||
preview = new Battleship(selectedInHarbor.getLength(), 0, 0, RIGHT);
|
||||
setPreviewStatus(preview);
|
||||
ownMap().add(preview);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotates the preview ship.
|
||||
*/
|
||||
@Override
|
||||
public void rotateShip() {
|
||||
ClientGameLogic.LOGGER.log(Level.DEBUG, "pushed rotate"); //NON-NLS
|
||||
if (preview == null) return;
|
||||
preview.rotated();
|
||||
ownMap().remove(preview);
|
||||
ownMap().add(preview);
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds a free position in the harbor to place a ship.
|
||||
*
|
||||
* @return the y coordinate of a free position in the harbor
|
||||
*/
|
||||
private int freeY() {
|
||||
for (int i = 0; i < harbor().getHeight(); i++)
|
||||
if (harbor().findShipAt(0, i) == null)
|
||||
return i;
|
||||
throw new RuntimeException("Cannot find a free slot in harbor");
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the status of the specified ship based on its validity.
|
||||
*/
|
||||
private void setPreviewStatus(Battleship ship) {
|
||||
ship.setStatus(ownMap().isValid(ship) ? VALID_PREVIEW : INVALID_PREVIEW);
|
||||
}
|
||||
|
||||
/**
|
||||
* The user has marked the map as finished.
|
||||
*/
|
||||
@Override
|
||||
public void mapFinished() {
|
||||
if (!harbor().getItems().isEmpty()) return;
|
||||
logic.send(new MapMessage(ownMap().getRemainingShips()));
|
||||
logic.setInfoText("wait.for.opponent");
|
||||
logic.setState(new WaitState(logic));
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's map is complete (i.e., all ships are placed).
|
||||
*
|
||||
* @return true if all ships are placed, false otherwise
|
||||
*/
|
||||
@Override
|
||||
public boolean isMapComplete() {
|
||||
return harbor().getItems().isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if there is currently a preview ship.
|
||||
*
|
||||
* @return true if there is currently a preview ship, false otherwise
|
||||
*/
|
||||
@Override
|
||||
public boolean movingShip() {
|
||||
return preview != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the player's own map.
|
||||
*
|
||||
* @return the player's own map
|
||||
*/
|
||||
private ShipMap ownMap() {
|
||||
return logic.getOwnMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the harbor map.
|
||||
*
|
||||
* @return the harbor map
|
||||
*/
|
||||
private ShipMap harbor() {
|
||||
return logic.getHarbor();
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a map from the specified file.
|
||||
*
|
||||
* @param file the file to load the map from
|
||||
* @throws IOException if the map cannot be loaded
|
||||
*/
|
||||
@Override
|
||||
public void loadMap(File file) throws IOException {
|
||||
final ShipMapDTO dto = ShipMapDTO.loadFrom(file);
|
||||
if (!dto.fits(logic.getDetails()))
|
||||
throw new IOException(lookup("map.doesnt.fit"));
|
||||
ownMap().clear();
|
||||
dto.getShips().forEach(ownMap()::add);
|
||||
harbor().clear();
|
||||
preview = null;
|
||||
selectedInHarbor = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's own map may be loaded from a file.
|
||||
*
|
||||
* @return true if the own map may be loaded from file, false otherwise
|
||||
*/
|
||||
@Override
|
||||
public boolean mayLoadMap() {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the player's own map may be saved to a file.
|
||||
*
|
||||
* @return true if the own map may be saved to file, false otherwise
|
||||
*/
|
||||
@Override
|
||||
public boolean maySaveMap() {
|
||||
return harbor().getItems().isEmpty();
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
/**
|
||||
* Represents the state of the client when the game is over.
|
||||
*/
|
||||
class GameOverState extends ClientState {
|
||||
/**
|
||||
* Constructs a new instance of GameOverState.
|
||||
*
|
||||
* @param logic the client game logic
|
||||
*/
|
||||
GameOverState(ClientGameLogic logic) {
|
||||
super(logic);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true to indicate that the battle state should be shown.
|
||||
*
|
||||
* @return true if the battle state should be shown
|
||||
*/
|
||||
@Override
|
||||
public boolean showBattle() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Rotation;
|
||||
|
||||
import java.util.Map.Entry;
|
||||
|
||||
/**
|
||||
* Represents the state of the client waiting for the
|
||||
* {@linkplain pp.battleship.message.server.GameDetails}
|
||||
* from the server.
|
||||
*/
|
||||
class InitialState extends ClientState {
|
||||
/**
|
||||
* Creates a new initial state.
|
||||
*
|
||||
* @param logic the game logic
|
||||
*/
|
||||
public InitialState(ClientGameLogic logic) {
|
||||
super(logic);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the game details provided by the server.
|
||||
*
|
||||
* @param details the game details including map size and ships
|
||||
*/
|
||||
@Override
|
||||
public void receivedGameDetails(GameDetails details) {
|
||||
logic.initializeMaps(details);
|
||||
fillHarbor(details);
|
||||
logic.setInfoText(details.getInfoTextKey());
|
||||
logic.setState(new EditorState(logic));
|
||||
}
|
||||
|
||||
/**
|
||||
* Fills the harbor with ships as specified by the game details.
|
||||
*
|
||||
* @param details the game details including map size and ships
|
||||
*/
|
||||
private void fillHarbor(GameDetails details) {
|
||||
int y = 0;
|
||||
for (Entry<Integer, Integer> entry : details.getShipNums().entrySet()) {
|
||||
final int len = entry.getKey();
|
||||
final int num = entry.getValue();
|
||||
for (int i = 0; i < num; i++) {
|
||||
final Battleship ship = new Battleship(len, 0, y++, Rotation.RIGHT);
|
||||
logic.getHarbor().add(ship);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean maySaveMap() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
/**
|
||||
* Interface representing a connection to the server.
|
||||
* Extends ClientSender to allow sending messages to the server.
|
||||
*/
|
||||
public interface ServerConnection extends ClientSender {
|
||||
|
||||
/**
|
||||
* Checks if the client is currently connected to the server.
|
||||
*
|
||||
* @return true if connected, false otherwise.
|
||||
*/
|
||||
boolean isConnected();
|
||||
|
||||
/**
|
||||
* Establishes a connection to the server.
|
||||
*/
|
||||
void connect();
|
||||
|
||||
/**
|
||||
* Disconnects from the server.
|
||||
*/
|
||||
void disconnect();
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.client.AnimationFinishedMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.Shell;
|
||||
import pp.battleship.model.ShipMap;
|
||||
import pp.battleship.notification.Sound;
|
||||
|
||||
/**
|
||||
* Represents the shooting state of the game where a shell is fired at the opponent.
|
||||
*/
|
||||
public class ShootingState extends ClientState {
|
||||
private float shootValue;
|
||||
private final static float SHELL_SPEED = 0.3f;
|
||||
private final Shell shell;
|
||||
private final boolean myTurn;
|
||||
private final EffectMessage msg;
|
||||
|
||||
/**
|
||||
* Constructs a shooting state with the specified game logic.
|
||||
*
|
||||
* @param logic the game logic
|
||||
* @param shell the shell being shot
|
||||
* @param myTurn indicates if it is the player's turn
|
||||
* @param msg the effect message associated with the shooting action
|
||||
*/
|
||||
public ShootingState(ClientGameLogic logic, Shell shell, boolean myTurn, EffectMessage msg) {
|
||||
super(logic);
|
||||
this.msg = msg;
|
||||
this.myTurn = myTurn;
|
||||
this.shell = shell;
|
||||
this.shootValue = 0;
|
||||
shell.move(shootValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean showBattle() {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the shooting state by moving the shell based on the elapsed time.
|
||||
*
|
||||
* @param delta the time in seconds since the last update
|
||||
*/
|
||||
@Override
|
||||
void update(float delta) {
|
||||
super.update(delta);
|
||||
if (shootValue > 1) {
|
||||
endState();
|
||||
}
|
||||
else {
|
||||
shootValue += delta * SHELL_SPEED;
|
||||
shell.move(shootValue);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ends the shooting state and processes the effects of the shot.
|
||||
*/
|
||||
private void endState() {
|
||||
playSound(msg);
|
||||
affectedMap(msg).add(msg.getShot());
|
||||
affectedMap(msg).remove(shell);
|
||||
|
||||
if (destroyedOpponentShip(msg))
|
||||
logic.getOpponentMap().add(msg.getDestroyedShip());
|
||||
if (msg.isGameOver()) {
|
||||
for (Battleship ship : msg.getRemainingOpponentShips()) {
|
||||
logic.getOpponentMap().add(ship);
|
||||
}
|
||||
logic.setState(new GameOverState(logic));
|
||||
return;
|
||||
}
|
||||
logic.send(new AnimationFinishedMessage());
|
||||
logic.setState(new BattleState(logic, myTurn));
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if an opponent's ship was destroyed by the shot.
|
||||
*
|
||||
* @param msg the effect message containing the shot details
|
||||
* @return true if an opponent's ship was destroyed, false otherwise
|
||||
*/
|
||||
private boolean destroyedOpponentShip(EffectMessage msg) {
|
||||
return msg.getDestroyedShip() != null && msg.isOwnShot();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the affected map based on whether the shot was owned by the player or the opponent.
|
||||
*
|
||||
* @param msg the effect message containing shot details
|
||||
* @return the ShipMap that was affected by the shot
|
||||
*/
|
||||
private ShipMap affectedMap(EffectMessage msg) {
|
||||
return msg.isOwnShot() ? logic.getOpponentMap() : logic.getOwnMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Plays a sound based on the outcome of the shot. Different sounds are played for a miss, hit,
|
||||
* or destruction of a ship.
|
||||
*
|
||||
* @param msg the effect message containing the result of the shot
|
||||
*/
|
||||
private void playSound(EffectMessage msg) {
|
||||
if (!msg.getShot().isHit())
|
||||
logic.playSound(Sound.SPLASH);
|
||||
else if (msg.getDestroyedShip() == null)
|
||||
logic.playSound(Sound.EXPLOSION);
|
||||
else
|
||||
logic.playSound(Sound.DESTROYED_SHIP);
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.client;
|
||||
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
|
||||
import java.lang.System.Logger.Level;
|
||||
|
||||
class WaitState extends ClientState {
|
||||
|
||||
/**
|
||||
* Creates a new instance of {@link WaitState}.
|
||||
*
|
||||
* @param logic the game logic
|
||||
*/
|
||||
public WaitState(ClientGameLogic logic) {
|
||||
super(logic);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean showEditor() {
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the battle based on the server message.
|
||||
*
|
||||
* @param msg the message indicating whose turn it is to shoot
|
||||
*/
|
||||
@Override
|
||||
public void receivedStartBattle(StartBattleMessage msg) {
|
||||
ClientGameLogic.LOGGER.log(Level.INFO, "start battle, {0} turn", msg.isMyTurn() ? "my" : "other's"); //NON-NLS
|
||||
logic.setInfoText(msg.getInfoTextKey());
|
||||
logic.setState(new BattleState(logic, msg.isMyTurn()));
|
||||
}
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.model.ShipMap;
|
||||
|
||||
/**
|
||||
* Class representing a player
|
||||
*/
|
||||
public class Player {
|
||||
private final ShipMap map;
|
||||
private final String name;
|
||||
private final int id;
|
||||
|
||||
/**
|
||||
* Creates new Player
|
||||
*
|
||||
* @param id the id of the connection to the client represented by this player
|
||||
* @param name the human-readable name of this player
|
||||
* @param config model holding the player
|
||||
*/
|
||||
Player(int id, String name, BattleshipConfig config) {
|
||||
this.id = id;
|
||||
this.name = name;
|
||||
map = new ShipMap(config.getMapWidth(), config.getMapHeight(), null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the id of the connection to the client represented by this player.
|
||||
*
|
||||
* @return the id
|
||||
*/
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("Player(%s,%s)", name, id); //NON-NLS
|
||||
}
|
||||
|
||||
/**
|
||||
* @return map containing own ships and shots
|
||||
*/
|
||||
public ShipMap getMap() {
|
||||
return map;
|
||||
}
|
||||
}
|
||||
@@ -1,276 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.message.client.AnimationFinishedMessage;
|
||||
import pp.battleship.message.client.ClientInterpreter;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.message.server.EffectMessage;
|
||||
import pp.battleship.message.server.GameDetails;
|
||||
import pp.battleship.message.server.ServerMessage;
|
||||
import pp.battleship.message.server.StartBattleMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
import pp.battleship.model.IntPoint;
|
||||
|
||||
|
||||
/**
|
||||
* Controls the server-side game logic for Battleship.
|
||||
* Manages game states, player interactions, and message handling.
|
||||
*/
|
||||
public class ServerGameLogic implements ClientInterpreter {
|
||||
private static final Logger LOGGER = System.getLogger(ServerGameLogic.class.getName());
|
||||
|
||||
private final BattleshipConfig config;
|
||||
private final List<Player> players = new ArrayList<>(2);
|
||||
private final Set<Player> readyPlayers = new HashSet<>();
|
||||
private final ServerSender serverSender;
|
||||
private Player activePlayer;
|
||||
private ServerState state = ServerState.WAIT;
|
||||
private Set<Player> waitPlayers = new HashSet<>();
|
||||
|
||||
/**
|
||||
* Constructs a ServerGameLogic with the specified sender and configuration.
|
||||
*
|
||||
* @param serverSender the sender used to send messages to clients
|
||||
* @param config the game configuration
|
||||
*/
|
||||
public ServerGameLogic(ServerSender serverSender, BattleshipConfig config) {
|
||||
this.serverSender = serverSender;
|
||||
this.config = config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the state of the game.
|
||||
*/
|
||||
ServerState getState() {
|
||||
return state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the new state of the game and logs the state transition.
|
||||
*
|
||||
* @param newState the new state to set
|
||||
*/
|
||||
void setState(ServerState newState) {
|
||||
LOGGER.log(Level.DEBUG, "state transition {0} --> {1}", state, newState); //NON-NLS
|
||||
state = newState;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the opponent of the specified player.
|
||||
*
|
||||
* @param p the player
|
||||
* @return the opponent of the player
|
||||
*/
|
||||
Player getOpponent(Player p) {
|
||||
if (players.size() != 2)
|
||||
throw new RuntimeException("trying to find opponent without having 2 players");
|
||||
final int index = players.indexOf(p);
|
||||
if (index < 0)
|
||||
throw new RuntimeException("Nonexistent player " + p);
|
||||
return players.get(1 - index);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the player representing the client with the specified connection ID.
|
||||
*
|
||||
* @param id the ID of the client
|
||||
* @return the player associated with the client ID, or null if not found
|
||||
*/
|
||||
public Player getPlayerById(int id) {
|
||||
for (Player player : players)
|
||||
if (player.getId() == id)
|
||||
return player;
|
||||
LOGGER.log(Level.ERROR, "no player found with connection {0}", id); //NON-NLS
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a message to the specified player.
|
||||
*
|
||||
* @param player the player to send the message to
|
||||
* @param msg the message to send
|
||||
*/
|
||||
void send(Player player, ServerMessage msg) {
|
||||
LOGGER.log(Level.INFO, "sending to {0}: {1}", player, msg); //NON-NLS
|
||||
serverSender.send(player.getId(), msg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a new player to the game if there are less than two players.
|
||||
* Transitions the state to SET_UP if two players are present.
|
||||
*
|
||||
* @param id the connection ID of the new player
|
||||
* @return the player added to the game, or null if the game is not in the right state
|
||||
*/
|
||||
public Player addPlayer(int id) {
|
||||
if (state != ServerState.WAIT) {
|
||||
LOGGER.log(Level.ERROR, "addPlayer not allowed in {0}", state); //NON-NLS
|
||||
return null;
|
||||
}
|
||||
final int n = players.size() + 1;
|
||||
final Player player = new Player(id, "player " + n, config); //NON-NLS
|
||||
LOGGER.log(Level.INFO, "adding {0}", player); //NON-NLS
|
||||
players.add(player);
|
||||
if (players.size() == 2) {
|
||||
activePlayer = players.get(0);
|
||||
for (Player p : players)
|
||||
send(p, new GameDetails(config));
|
||||
setState(ServerState.SET_UP);
|
||||
}
|
||||
return player;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the reception of a MapMessage.
|
||||
* Also tests valid ship placement on the Map.
|
||||
*
|
||||
* @param msg the received MapMessage
|
||||
* @param from the ID of the sender client
|
||||
*/
|
||||
@Override
|
||||
public void received(MapMessage msg, int from) {
|
||||
if (state != ServerState.SET_UP)
|
||||
LOGGER.log(Level.ERROR, "playerReady not allowed in {0}", state); //NON-NLS
|
||||
|
||||
|
||||
List<Battleship> ships = msg.getShips();
|
||||
|
||||
if (! mapTest(ships)){
|
||||
LOGGER.log(Level.ERROR, "Geladene Karte von Spieler {0} enthält unzulässige Schiffe", from);
|
||||
send(getPlayerById(from),null);
|
||||
return;
|
||||
}
|
||||
|
||||
playerReady(getPlayerById(from), msg.getShips());
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the reception of a ShootMessage.
|
||||
*
|
||||
* @param msg the received ShootMessage
|
||||
* @param from the ID of the sender client
|
||||
*/
|
||||
@Override
|
||||
public void received(ShootMessage msg, int from) {
|
||||
if (state != ServerState.BATTLE)
|
||||
LOGGER.log(Level.ERROR, "shoot not allowed in {0}", state); //NON-NLS
|
||||
else
|
||||
shoot(getPlayerById(from), msg.getPosition());
|
||||
}
|
||||
|
||||
/**
|
||||
* Marks the player as ready and sets their ships.
|
||||
* Transitions the state to PLAY if both players are ready.
|
||||
*
|
||||
* @param player the player who is ready
|
||||
* @param ships the list of ships placed by the player
|
||||
*/
|
||||
void playerReady(Player player, List<Battleship> ships) {
|
||||
if (!readyPlayers.add(player)) {
|
||||
LOGGER.log(Level.ERROR, "{0} was already ready", player); //NON-NLS
|
||||
return;
|
||||
}
|
||||
ships.forEach(player.getMap()::add);
|
||||
if (readyPlayers.size() == 2) {
|
||||
for (Player p : players)
|
||||
send(p, new StartBattleMessage(p == activePlayer));
|
||||
setState(ServerState.BATTLE);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the shooting action by the player.
|
||||
*
|
||||
* @param p the player who shot
|
||||
* @param pos the position of the shot
|
||||
*/
|
||||
void shoot(Player p, IntPoint pos) {
|
||||
if (p != activePlayer) return;
|
||||
final Player otherPlayer = getOpponent(activePlayer);
|
||||
final Battleship selectedShip = otherPlayer.getMap().findShipAt(pos);
|
||||
if (selectedShip == null) {
|
||||
// shot missed
|
||||
send(activePlayer, EffectMessage.miss(true, pos));
|
||||
send(otherPlayer, EffectMessage.miss(false, pos));
|
||||
activePlayer = otherPlayer;
|
||||
}
|
||||
else {
|
||||
// shot hit a ship
|
||||
selectedShip.hit(pos);
|
||||
if (otherPlayer.getMap().getRemainingShips().isEmpty()) {
|
||||
// game is over
|
||||
send(activePlayer, EffectMessage.won(pos, selectedShip));
|
||||
send(otherPlayer, EffectMessage.lost(pos, selectedShip, activePlayer.getMap().getRemainingShips()));
|
||||
setState(ServerState.GAME_OVER);
|
||||
}
|
||||
else if (selectedShip.isDestroyed()) {
|
||||
// ship has been destroyed, but game is not yet over
|
||||
send(activePlayer, EffectMessage.shipDestroyed(true, pos, selectedShip));
|
||||
send(otherPlayer, EffectMessage.shipDestroyed(false, pos, selectedShip));
|
||||
}
|
||||
else {
|
||||
// ship has been hit, but it hasn't been destroyed
|
||||
send(activePlayer, EffectMessage.hit(true, pos));
|
||||
send(otherPlayer, EffectMessage.hit(false, pos));
|
||||
}
|
||||
}
|
||||
}
|
||||
//Aufgabe 8
|
||||
|
||||
private boolean isInBounds(Battleship ship){
|
||||
return ship.getMinX() >= 0 && ship.getMaxX() < config.getMapWidth() &&
|
||||
ship.getMinY() >= 0 && ship.getMaxY() < config.getMapHeight();
|
||||
}
|
||||
|
||||
|
||||
|
||||
private boolean mapTest(List<Battleship> ships) {
|
||||
Set<IntPoint> belegt = new HashSet<>();
|
||||
return ships.stream().allMatch(ship -> isInBounds(ship) &&
|
||||
ship.getPositions().stream().allMatch(belegt::add));
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the reception of a AnimationFinishedMessage.
|
||||
*
|
||||
* @param msg the received MapMessage
|
||||
* @param from the ID of the sender client
|
||||
*/
|
||||
@Override
|
||||
public void received(AnimationFinishedMessage msg, int from) {
|
||||
if (state != ServerState.ANIMATION) {
|
||||
LOGGER.log(Level.ERROR, "animation finished not allowed in {0}", state);
|
||||
}
|
||||
else {
|
||||
LOGGER.log(Level.DEBUG, "anim received from {0}", getPlayerById(from));
|
||||
Player player = getPlayerById(from);
|
||||
if (!waitPlayers.add(player)) {
|
||||
LOGGER.log(Level.ERROR, "{0} already sent animation finished", player); //NON-NLS
|
||||
return;
|
||||
}
|
||||
if (waitPlayers.size() == 2) {
|
||||
waitPlayers = new HashSet<>();
|
||||
setState(ServerState.BATTLE);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
import pp.battleship.message.server.ServerMessage;
|
||||
|
||||
/**
|
||||
* Interface for sending messages to a client.
|
||||
*/
|
||||
public interface ServerSender {
|
||||
/**
|
||||
* Send the specified message to the client.
|
||||
*
|
||||
* @param id the id of the client that shall receive the message
|
||||
* @param message the message
|
||||
*/
|
||||
void send(int id, ServerMessage message);
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.server;
|
||||
|
||||
/**
|
||||
* Represents the different states of the Battleship server during the game lifecycle.
|
||||
*/
|
||||
enum ServerState {
|
||||
/**
|
||||
* The server is waiting for clients to connect.
|
||||
*/
|
||||
WAIT,
|
||||
|
||||
/**
|
||||
* The server is waiting for clients to set up their maps.
|
||||
*/
|
||||
SET_UP,
|
||||
|
||||
/**
|
||||
* The battle of the game where players take turns to attack each other's ships.
|
||||
*/
|
||||
BATTLE,
|
||||
|
||||
/**
|
||||
* The game has ended because all the ships of one player have been destroyed.
|
||||
*/
|
||||
GAME_OVER,
|
||||
|
||||
/**
|
||||
* The server is waiting for all clients to finish the shoot animation.
|
||||
*/
|
||||
ANIMATION
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.singlemode;
|
||||
|
||||
import pp.battleship.BattleshipConfig;
|
||||
import pp.battleship.model.IntPoint;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Class providing access to the Battleship client configuration.
|
||||
* Extends {@link BattleshipConfig} to include additional properties specific to the client.
|
||||
* This class manages configuration settings related to the RobotClient's behavior
|
||||
* and the game maps used in single mode.
|
||||
* <p>
|
||||
* <b>Note:</b> Attributes of this class should not be marked as {@code final}
|
||||
* to ensure proper functionality when reading from a properties file.
|
||||
* </p>
|
||||
*/
|
||||
public class BattleshipClientConfig extends BattleshipConfig {
|
||||
|
||||
/**
|
||||
* Array representing the predefined shooting locations for the RobotClient.
|
||||
* The array stores coordinates in pairs, where even indices represent x-coordinates
|
||||
* and odd indices represent y-coordinates.
|
||||
*/
|
||||
@Property("robot.targets")
|
||||
private int[] robotTargets = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
|
||||
/**
|
||||
* The delay (in milliseconds) between shots fired by the RobotClient.
|
||||
*/
|
||||
@Property("robot.delay")
|
||||
private int delay = 750;
|
||||
|
||||
/**
|
||||
* Path to the file representing the opponent's map.
|
||||
*/
|
||||
@Property("map.opponent")
|
||||
private String opponentMap;
|
||||
|
||||
/**
|
||||
* Path to the file representing the player's own map.
|
||||
*/
|
||||
@Property("map.own")
|
||||
private String ownMap;
|
||||
|
||||
/**
|
||||
* Creates a default {@code BattleshipClientConfig} with predefined values.
|
||||
*/
|
||||
public BattleshipClientConfig() {
|
||||
// Default constructor
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an iterator of {@link IntPoint} objects representing the predefined
|
||||
* shooting locations for the RobotClient.
|
||||
*
|
||||
* @return an iterator of {@code IntPoint} representing the shooting locations.
|
||||
*/
|
||||
public Iterator<IntPoint> getRobotTargets() {
|
||||
List<IntPoint> targets = new ArrayList<>();
|
||||
for (int i = 0; i < robotTargets.length; i += 2) {
|
||||
int x = robotTargets[i];
|
||||
int y = robotTargets[i + 1];
|
||||
targets.add(new IntPoint(x, y));
|
||||
}
|
||||
return targets.iterator();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the delay (in milliseconds) between shots by the RobotClient.
|
||||
*
|
||||
* @return the delay in milliseconds.
|
||||
*/
|
||||
public int getDelay() {
|
||||
return delay;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the file representing the opponent's map.
|
||||
*
|
||||
* @return the opponent's map file, or {@code null} if not set.
|
||||
*/
|
||||
public File getOpponentMap() {
|
||||
return opponentMap == null ? null : new File(opponentMap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the file representing the player's own map.
|
||||
*
|
||||
* @return the player's own map file, or {@code null} if not set.
|
||||
*/
|
||||
public File getOwnMap() {
|
||||
return ownMap == null ? null : new File(ownMap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the game is in single mode based on the presence of an opponent map.
|
||||
*
|
||||
* @return {@code true} if the opponent map is set, indicating single mode; {@code false} otherwise.
|
||||
*/
|
||||
public boolean isSingleMode() {
|
||||
return opponentMap != null;
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
////////////////////////////////////////
|
||||
// Programming project code
|
||||
// UniBw M, 2022, 2023, 2024
|
||||
// www.unibw.de/inf2
|
||||
// (c) Mark Minas (mark.minas@unibw.de)
|
||||
////////////////////////////////////////
|
||||
|
||||
package pp.battleship.game.singlemode;
|
||||
|
||||
import pp.battleship.message.client.AnimationFinishedMessage;
|
||||
import pp.battleship.message.client.ClientInterpreter;
|
||||
import pp.battleship.message.client.ClientMessage;
|
||||
import pp.battleship.message.client.MapMessage;
|
||||
import pp.battleship.message.client.ShootMessage;
|
||||
import pp.battleship.model.Battleship;
|
||||
|
||||
/**
|
||||
* The {@code Copycat} class is a utility that creates a copy of a {@link ClientMessage}.
|
||||
* It implements the {@link ClientInterpreter} interface to interpret and process
|
||||
* different types of messages.
|
||||
*/
|
||||
class Copycat implements ClientInterpreter {
|
||||
private ClientMessage copiedMessage;
|
||||
|
||||
/**
|
||||
* Creates a copy of the provided {@link ClientMessage}.
|
||||
*
|
||||
* @param msg the message to be copied
|
||||
* @return a copy of the provided message
|
||||
*/
|
||||
static ClientMessage copy(ClientMessage msg) {
|
||||
final Copycat copycat = new Copycat();
|
||||
msg.accept(copycat, 0);
|
||||
return copycat.copiedMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Private constructor to prevent direct instantiation of {@code Copycat}.
|
||||
*/
|
||||
private Copycat() { /* do nothing */ }
|
||||
|
||||
/**
|
||||
* Handles the reception of a {@link ShootMessage}.
|
||||
* Since a {@code ShootMessage} does not need to be copied, it is directly assigned.
|
||||
*
|
||||
* @param msg the received {@code ShootMessage}
|
||||
* @param from the identifier of the sender
|
||||
*/
|
||||
@Override
|
||||
public void received(ShootMessage msg, int from) {
|
||||
// copying is not necessary
|
||||
copiedMessage = msg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the reception of a {@link MapMessage}.
|
||||
* Creates a deep copy of the {@code MapMessage} by copying each {@link Battleship} in the message.
|
||||
*
|
||||
* @param msg the received {@code MapMessage}
|
||||
* @param from the identifier of the sender
|
||||
*/
|
||||
@Override
|
||||
public void received(MapMessage msg, int from) {
|
||||
copiedMessage = new MapMessage(msg.getShips().stream().map(Copycat::copy).toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a copy of the provided {@link Battleship}.
|
||||
*
|
||||
* @param ship the battleship to be copied
|
||||
* @return a copy of the provided battleship
|
||||
*/
|
||||
private static Battleship copy(Battleship ship) {
|
||||
return new Battleship(ship.getLength(), ship.getX(), ship.getY(), ship.getRot());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void received(AnimationFinishedMessage msg, int from) {
|
||||
copiedMessage = msg;
|
||||
}
|
||||
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user