feat: Improved docs (#61)

* fix: Fix some issues in latest release

* fix: Fix broken devcontainers on github codespaces

* fix: Remove unused programs from devcontainers

* fix: Add vi to installed programs

* fix: Fix some small errors in docs

* wip: Start to rewrite the tick loop using tokio

* Docu normal installation Step 1

* Docs normal installation

Changed a bit the Wording

* Docs installation normal Step 2

* Revert "wip: Start to rewrite the tick loop using tokio"

This reverts commit 598217b.

* Removed the Work in Progress Disclaimer

* Draft for Step 3 and 4

* Repaired docs relative links

* Testing commit

* Improved Draft

* Reworked the controller documentation Draft for installation and usage

* reordering folders

* Reorder the Docs folder

* Improved documentation

* Renamed Driver to Plugin

* Reworked the Welcome documentation

* Improved the documentation

* Improved Docs

* More Improved Docs

* Renamed some stuff and again a bit more Improved the docs

* imrpoved docs

* Draft for documentation of Templates

* improved Draft Template docs

* renamed folder

* Improving Wrapper Documentation

* Reworked jvm

---------

Co-authored-by: HttpRafa <60099368+HttpRafa@users.noreply.github.com>

Author: shdctx

docs/api/index.md

@@ -1,3 +1,16 @@
 # Available Options
 
-Currently, the cloud offers a first-party JVM library. This library is compatible with all programming languages that compile to JVM bytecode, providing a versatile solution for developers working within the JVM ecosystem.
+Atomic Cloud provides a first-party JVM library designed to offer seamless integration for developers working within the JVM ecosystem. This library is compatible with all programming languages that compile to JVM bytecode, making it a versatile and powerful solution for a wide range of projects.
+
+Key benefits include:
+
+- **Broad Compatibility:**  
+  Leverage the library with any JVM-based language, including Java, Kotlin, Scala, Groovy, and others.
+
+- **First-Party Support:**  
+  Enjoy the reliability and robustness of a library developed and maintained by the Atomic Cloud team.
+
+- **Versatile Integration:**  
+  Easily integrate cloud functionalities into your existing JVM projects, streamlining development and enhancing application performance.
+
+Explore this option to maximize your development capabilities within the JVM environment.

docs/api/jvm/channels.md

@@ -0,0 +1,64 @@
+# Channels
+
+Channels are a pub/sub (publish/subscribe) messaging system within Atomic Cloud designed for efficient, secure, real‑time communication between servers. They work similarly to MQTT and are ideal for implementing features such as party systems, player notifications, and any functionality that requires inter‑server messaging.
+
+## Table of Contents
+
+- [What Are Channels?](#what-are-channels)
+- [Prerequisites](#prerequisites)
+- [Receiving Messages](#receiving-messages)
+- [Sending Messages](#sending-messages)
+- [Conclusion](#conclusion)
+
+## What Are Channels?
+
+Channels provide a central, consistent method for sending and receiving messages across distributed servers. By using channels, you ensure data integrity and security throughout your application, making it easier to orchestrate communication between various services or components.
+
+## Prerequisites
+
+Before using channels, make sure to:
+
+- **Choose a Unique Channel Name:**  
+  The channel name serves as the unique identifier for message routing.
+
+- **Subscribe to the Channel:**  
+  Only servers or clients that subscribe to a channel will receive its messages.
+
+- **Unsubscribe When Needed:**  
+  Subscribers can unsubscribe at any time to stop receiving messages.
+
+## Receiving Messages
+
+To receive messages from a channel, subscribe and register a message handler using the JVM API.
+
+### Example
+
+```java
+// Subscribe to the "party/invites" channel
+Cloud.channels().subscribe("party/invites");
+
+// Register a handler to process incoming messages on "party/invites"
+Cloud.channels().registerHandler("party/invites", (message) -> {
+    // Define your message handling logic here
+    System.out.println("Received message: " + message);
+});
+```
+
+Once subscribed, every message sent to the channel will trigger the registered handler.
+
+## Sending Messages
+
+Sending messages is simple. Use the API to send a message to a channel, and all subscribers will receive it.
+
+### Example
+
+```java
+// Send a message to the "party/invites" channel
+Cloud.channels().sendMessage("party/invites", "test");
+```
+
+In this example, the string `"test"` is broadcast to all clients subscribed to the "party/invites" channel.
+
+## Conclusion
+
+Channels in Atomic Cloud offer a robust and secure method for inter‑server communication, allowing you to easily implement real‑time features with minimal setup. By following the steps above, you can integrate channels into your project to enable seamless, efficient messaging between distributed services.

docs/api/jvm/index.md

@@ -0,0 +1,33 @@
+# JVM API Integration
+
+The Atomic Cloud API is available through the **GitHub Packages Maven repository**. Authentication may be required to access it. For more details, visit the [package page](https://github.com/HttpRafa/atomic-cloud/packages/2219240).
+
+## Adding the API to Your Project
+
+### **Maven**
+To include the API in a **Maven** project, add the following dependency to your `pom.xml` file:
+
+```xml
+<dependency>
+    <groupId>io.atomic.cloud</groupId>
+    <artifactId>api</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+</dependency>
+```
+
+### **Gradle**
+For **Gradle** projects, add the following dependency to your `build.gradle.kts` file:
+
+```kotlin
+dependencies {
+    implementation("io.atomic.cloud:api:0.1.0-SNAPSHOT")
+}
+```
+
+If you're using Groovy-based Gradle (`build.gradle`), use:
+
+```gradle
+dependencies {
+    implementation 'io.atomic.cloud:api:0.1.0-SNAPSHOT'
+}
+```