Merge pull request #209 from HytaleModding/crowdin-translations

New translations from Crowdin

Author: ItsNeil17

content/docs/af-ZA/guides/ecs/hytale-ecs.mdx

@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understading of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherite a class in Java, we inherite all of its attribues and methods.
+While in composotion we can choose for each object what it refrence and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity'  component that stores the speed along the each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.

content/docs/af-ZA/guides/ecs/index.mdx

@@ -18,10 +18,10 @@ A variable has three key components:
 In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
 
 ```java
-int age;
-age = 18;
+int age; // A declaration
+age = 18; // An assignment
 
-int age = 18; // Declaration and assignment in one line
+int age = 18; // Declaration and assignment in one line, also considered an initialization
 ```
 
 ## Primitive Data Types
@@ -44,7 +44,7 @@ Sometimes you might not want a variable to stay the same type. You can convert b
 
 ```java
 int num = 10;
-double decimalNum = (double) num; // 10.0 - works automatically
+double decimalNum = num; // 10.0 - works automatically
 ```
 
 ### Manual (Casting)

content/docs/af-ZA/guides/java-basics/01-variables.mdx

@@ -1,5 +1,5 @@
 ---
-title: 05 - Control Flow Loops
+title: 04 - Control Flow Loops
 description: Learn how to repeat code efficiently using loops in Java
 ---
 

content/docs/af-ZA/guides/java-basics/04-control-flow-loops.mdx

@@ -336,7 +336,7 @@ You've seen `public` - it means "anyone can access this". We'll learn more about
 public class Example {
     public String publicVar;      // Anyone can access
     private String privateVar;    // Only this class can access
-    // (no modifier) String defaultVar; // Package access
+    /* (no modifier) */ String defaultVar; // Package access
 }
 ```
 

content/docs/af-ZA/guides/java-basics/07-introduction-oop.mdx

@@ -0,0 +1,64 @@
+---
+title: Browsing the server.jar code
+description: Learn how to patch the server.jar and browse the source code.
+---
+
+The ~~patcher~~ allows you to more easily prepare an environment for exploring the Hytale Server without publishing the decompiled code.
+
+## Setup
+
+- Clone the patcher `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory. `cd patcher`
+
+- Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
+  one of these:
+
+  - `python -m venv .venv`
+  - `python3 -m venv .venv` (Linux)
+  - `py -3.13 -m venv .venv` (Windows)
+
+  In the last one, specifying the version is recommended if you have multiple Pythons installed.
+
+- Activate the virtual environment:
+  - Windows: `".venv\Scripts\activate"`  (including the quotes)
+  - Linux/Mac: `source .venv/bin/activate`
+  - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
+
+- Inside the venv, you have to install the dependencies
+  - `pip install -r requirements.txt`
+
+- Install these dependencies and ensure they are on PATH:
+  - `git`
+  - `java` you need JDK 25 or newer
+  - `jar` (comes with JDK inside the bin folder)
+  - `mvn`
+
+## Usage
+
+Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+
+Then run this:
+
+```shell
+python run.py setup
+```
+
+It will
+
+- copy the HytaleServer.jar into `work/download`
+  - (on Windows) fix `META-INF/license` name collision
+- decompile it using Fernflower and save the output to `work/decompile`
+- set up a Maven project in `hytale-server` with the decompiled code
+
+You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
+you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure SDK and Language level to _25_.
+
+If IDEA does not offer an option to run the main file, right-click the `src` folder -> Mark Directory As -> Sources Root
+then reload the maven project:\
+![_readme_images/img.png](/assets/reload-maven.png)\
+It is located in the "m" icon on the right side:\
+![_readme_images/m.png](/assets/maven.png)\
+If you don't see it, enable it under View -> Tool Windows -> Maven.\
+![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters

content/docs/af-ZA/guides/plugin/browsing-serverjar.mdx

@@ -0,0 +1,47 @@
+---
+title: Formatting the chat
+description: Learn how to format the chat using the PlayerChatEvent
+authors:
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+![chat format example](/assets/guides/chat-example.png)
+
+The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
+You can cancel this event as well as modify the content and the formatter.
+
+```java
+public class ChatFormatter {
+
+  public static void onPlayerChat(PlayerChatEvent event) {
+    PlayerRef sender = event.getSender();
+    if(event.getContent().equalsIgnoreCase("poo")) {
+      event.setCancelled(true);
+      sender.sendMessage(Message.raw("Hey, you cannot say that!").color(Color.RED));
+    }
+
+    if(event.getContent().equalsIgnoreCase("you stink")) {
+      event.setContent("i stink");
+    }
+
+    event.setFormatter((playerRed, message) ->
+        Message.join(
+            Message.raw("[COOL] ").color(Color.RED),
+            Message.raw(sender.getUsername()).color(Color.YELLOW),
+            Message.raw(" : " + message).color(Color.PINK)
+        ));
+
+  }
+}
+```
+
+The formatter is the following interface:
+
+```java
+  public interface Formatter {
+    @Nonnull
+    Message format(@Nonnull PlayerRef playerRef, @Nonnull String message);
+  }
+}
+```