Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/josef-friedrich/litiengine-boilerplate
Try out the litiengine
https://github.com/josef-friedrich/litiengine-boilerplate
Last synced: about 1 month ago
JSON representation
Try out the litiengine
- Host: GitHub
- URL: https://github.com/josef-friedrich/litiengine-boilerplate
- Owner: Josef-Friedrich
- Created: 2023-11-01T10:04:17.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2024-05-29T14:33:19.000Z (8 months ago)
- Last Synced: 2024-05-30T04:35:00.199Z (8 months ago)
- Language: Java
- Size: 364 KB
- Stars: 0
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# litiengine-boilerplate
Litiengine verwendet ab der Version 0.6.0 Java 21. Auf Ubuntu kann
Java 21 folgendermaßen installiert und als Standard festgelegt werden.
```
sudo apt install openjdk-21-jdk
sudo update-alternatives --config java
```
## gradle
./gradlew build -Dorg.gradle.java.home=/usr/lib/jvm/java-21-openjdk-amd64
## vscode
```json
{
"java.configuration.runtimes": [
{
"name": "JavaSE-21",
"path": "/usr/lib/jvm/java-21-openjdk-amd64",
"default": true
}
],
"java.jdt.ls.java.home": "/usr/lib/jvm/java-21-openjdk-amd64",
"java.gradle.buildServer.enabled": "off"
}
```
# Text setzen
Schriftdatei in folgendenden Ordner kopieren: `./src/main/resources/fonts/Jersey10-Regular.ttf`
```java
import java.awt.Color;
import java.awt.Graphics2D;
import de.gurkenlabs.litiengine.Game;
import de.gurkenlabs.litiengine.gui.screens.Screen;
import de.gurkenlabs.litiengine.resources.Resources;
public class FontExample extends Screen
{
public FontExample()
{
super("font");
}
public void render(Graphics2D g)
{
super.render(g);
g.setFont(Resources.fonts().get("fonts/Jersey10-Regular.ttf", 32f));
g.setColor(Color.GREEN);
Game.graphics().renderText(g, "Hello, LITIengine!", 0, 100);
g.setColor(Color.BLUE);
Game.graphics().renderText(g, "Font Test", 0, 0);
}
public static void main(String[] args)
{
Game.init();
Game.screens().add(new FontExample());
Game.start();
}
}
```
# Screens
https://litiengine.com/docs/game-api/screens/
[Screens](https://litiengine.com/api/de/gurkenlabs/litiengine/gui/screens/Screen/)
sind die Container, mit denen Sie die sichtbaren Inhalte Ihres Spiels
organisieren können. Sie rendern die Spielumgebung und gelten als übergeordnete
Elemente aller GUI-Komponenten, die Sie in einem bestimmten Zustand Ihres
Spiels anzeigen möchten. Ein Screen selbst erbt von
[GuiComponent](https://litiengine.com/api/de/gurkenlabs/litiengine/gui/GuiComponent/)
und bietet dadurch Unterstützung beim Definieren einer
[Appearance](https://litiengine.com/api/de/gurkenlabs/litiengine/gui/Appearance/)
und beim Abhören aller Arten von Eingabeereignissen (z. B. onMouseMoved(…)).
Alles, was für den Spieler sichtbar sein soll, muss auf dem aktuell aktiven
Screen gerendert werden.
Bildschirme werden durch einen eindeutigen Namen identifiziert und addressiert.
Der [ScreenManager](https://litiengine.com/api/de/gurkenlabs/litiengine/gui/screens/ScreenManager/)
enthält Instanzen aller verfügbaren `Screens` und verarbeitet,
wann immer dem Player ein anderer `Screen` angezeigt werden soll.
Es stellt den aktuell aktiven Bildschirm für die RenderComponent des Spiels bereit,
die bei jedem Tick des RenderLoop die `Screen.render(Graphics2D)`-Methode aufruft.
Das Überschreiben dieser Methode bietet die Möglichkeit, eine benutzerdefinierte
Renderpipeline zu definieren, die den Anforderungen einer bestimmten
Screen-Implementierung entspricht. Mit dem
[GameScreen](https://litiengine.com/api/de/gurkenlabs/litiengine/gui/screens/GameScreen/) stellt die LITIENGINE eine
einfache Standard-Screen-Implementierung bereit, die die aktuelle Umgebung und
alle ihre GuiComponents rendert.
Examples for screens include: Menu Screen, Credits Screen, Game Screen, Inventory Screen
Example usages:
```java
import java.awt.Color;
import java.awt.event.KeyEvent;
import de.gurkenlabs.litiengine.Game;
import de.gurkenlabs.litiengine.gui.screens.Resolution;
import de.gurkenlabs.litiengine.gui.screens.Screen;
import de.gurkenlabs.litiengine.input.Input;
class RedScreen extends Screen
{
public RedScreen()
{
super("red");
}
@Override
public void prepare()
{
super.prepare();
Game.window().getRenderComponent()
.setBackground(Color.decode("#ff0000"));
}
}
class BlueScreen extends Screen
{
public BlueScreen()
{
super("blue");
}
@Override
public void prepare()
{
super.prepare();
Game.window().getRenderComponent()
.setBackground(Color.decode("#0000ff"));
}
}
public class ScreenExample
{
public static void main(String[] args)
{
Game.init(args);
Game.window().setResolution(Resolution.Ratio4x3.RES_1024x768);
Game.screens().add(new RedScreen());
Game.screens().add(new BlueScreen());
Input.keyboard().onKeyTyped(KeyEvent.VK_1,
e -> Game.screens().display("red"));
Input.keyboard().onKeyTyped(KeyEvent.VK_2,
e -> Game.screens().display("blue"));
Game.start();
}
}
```
# Tastatur-Eingabe
```java
import java.awt.event.KeyEvent;
import de.gurkenlabs.litiengine.Game;
import de.gurkenlabs.litiengine.input.Input;
public class KeyboardInput {
public static void main(String[] args) {
Game.init();
Input.keyboard().onKeyPressed(KeyEvent.VK_ESCAPE, e -> System.exit(0));
Input.keyboard().onKeyPressed(KeyEvent.VK_1, e -> System.out.println("pressed"));
Input.keyboard().onKeyTyped(KeyEvent.VK_2, e -> System.out.println("typed"));
Input.keyboard().onKeyReleased(KeyEvent.VK_3, e -> System.out.println("released"));
Game.start();
}
}
```
# Mouse-Eingabe
```java
import de.gurkenlabs.litiengine.Game;
import de.gurkenlabs.litiengine.input.Input;
public class MouseInputExample
{
public static void main(String[] args)
{
Game.init();
Input.mouse().onClicked(e -> {
System.out.println(
"Mouse clicked at x: " + e.getX() + ", y: " + e.getY());
});
Game.start();
}
}
```