Add info files and update formatting to Google standards

Author: stringfromjava

.editorconfig

@@ -1,15 +1,46 @@
 # https://editorconfig.org
+# http://editorconfig.org
 root = true
 
 [*]
-indent_style = space
-end_of_line = lf
 charset = utf-8
-trim_trailing_whitespace = true
+end_of_line = lf
 insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.java]
+# 2-space indentation (Google Style Guide Section 4.2)
+indent_style = space
+
+# Limit line length to 100 characters (Section 4.4)
+max_line_length = 100
+
+# Standard Java formatting rules
+ij_java_use_single_class_imports = true
+ij_java_insert_inner_class_imports = false
+ij_java_class_count_to_use_import_on_demand = 999
+ij_java_names_count_to_use_import_on_demand = 999
+ij_java_packages_to_use_import_on_demand = unset
+ij_java_blank_lines_before_class_end = 1
+ij_java_blank_lines_after_class_header = 1
+
+# Block formatting (Section 4.1.2)
+ij_java_class_brace_style = end_of_line
+ij_java_method_brace_style = end_of_line
+
+# Space before opening brace (Section 4.6.2)
+ij_java_space_before_class_left_brace = true
+ij_java_space_before_method_left_brace = true
+ij_java_space_before_if_left_brace = true
+ij_java_space_before_while_left_brace = true
+ij_java_space_before_for_left_brace = true
+ij_java_space_before_try_left_brace = true
+ij_java_space_before_catch_left_brace = true
+ij_java_space_before_switch_left_brace = true
+ij_java_space_before_synchronized_left_brace = true
 
 [*.{java,scala,groovy,kt,kts}]
-indent_size = 4
+indent_size = 2
 
 [*.gradle]
 indent_size = 2

COMPILING.md

@@ -0,0 +1,47 @@
+# How to Compile FNF:JE
+
+There are two main ways you can download and compile the game's code: with GitHub Desktop or the terminal.
+
+In this guide, we'll use the GitHub Desktop method, since it the most user-friendly experience, which provides you a nice UI and does all the hard stuff for you!
+
+# Prerequisites (for all methods)
+- A [GitHub](https://github.com) account to download the game's GitHub repository.
+- A [Java Development Kit (JDK)](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html) to compile the game's code.
+- An integrated development environment.
+    - We recommend either one of the options listed below:
+        - [Intellij IDEA](https://www.jetbrains.com/idea/download/) (RECOMMENDED)
+        - [Eclipse](https://www.eclipse.org/downloads/)
+        - [VS Code](https://code.visualstudio.com/)
+- Some basic knowledge of programming (especially Gradle) and how to navigate an IDE. 
+
+# Step-by-Step Guide
+
+1. Visit the official [GitHub Desktop website](https://desktop.github.com/download/) and download the app.
+
+> [!TIP]
+> If you're on Linux, don't worry! You can install a community made version by running the following commands in the terminal:
+> ```shell
+> wget -qO - https://mirror.mwt.me/shiftkey-desktop/gpgkey | gpg --dearmor | sudo tee /usr/share/keyrings/mwt-desktop.gpg > /dev/null
+> sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/mwt-desktop.gpg] https://mirror.mwt.me/shiftkey-desktop/deb/ any main" > /etc/apt/sources.list.d/mwt-desktop.list'
+> ```
+> When it's done downloading, you can install the application by running the following command:
+> ```shell
+> sudo apt update && sudo apt install github-desktop
+> ```
+
+2. When GitHub Desktop is done installing, sign in with your GitHub account when prompted to do so.
+
+3. Go back to your browser and (on the official home page for FNF:JE's repository), click the green `<> Code` button and select `Open with GitHub Desktop`. You should see a prompt asking if you want to clone the game's code.
+
+4. Click the blue `Clone` button and wait for the game's code to download.
+
+> [!TIP]
+> We recommend putting the game's code in a place where you'll easily remember where it's at, such as your `Documents\GitHub` folder if you're on Windows!
+
+5. Launch your IDE and open the game's folder when prompted to do so.
+
+> [!IMPORTANT]
+> When you open the game's folder, your IDE will most likely start running Gradle tasks. Don't worry, this is normal and expected!
+
+6. When the tasks are finished, you can now run the game's code! You can do so by running the applicable task depending on the platform.
+   - For example, you can run the desktop version by executing the task `lwjgl3:run`.

CONTRIBUTING.md

@@ -0,0 +1,110 @@
+# How to Contribute
+
+Around here, things are somewhat simple. All we ask is that you follow the basic rules and have common sense.
+
+## Basic Info
+
+- When you create a pull request to be merged into `develop`, please note that the rules will be *heavily* enforced. This is NOT because we want to be mean, but rather it's to make sure that FNF:JE has a good codebase. We don't want any contributors to deal with poorly put together code!
+- If you're looking for how to compile the game, please take a look at [COMPILING.md](COMPILING.md)!
+
+## Issues
+
+If you wish to fix a bug, make an enhancement, or even wish to
+simply make a recommendation, then no worries! You can make an [issue](https://github.com/stringfromjava/Starcore/issues)
+or create a sub-issue and help someone with something that needs to be worked on!
+
+> [!IMPORTANT]
+> Make sure to set the base branch to `develop` on your pull request, or otherwise ***it will NOT be merged and accepted!!***
+
+## Comments & Formatting
+
+Comments are very valuable because they allow you and other
+programmers to easily understand what is happening in your code.
+
+However, sometimes they can be a hindrance as well.
+
+If your comments have typos, aren't clear or concise, or just
+hard to understand in general, then they won't be any
+use. Even too many comments are unnecessary, since your code should be
+self documented and easily readable.
+
+<u>***Formatting MUST match the [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html).***</u>
+
+### Example of GOOD Comments (With Good Formatting)
+
+```java
+/**
+ * Plays a sound. (Duh.)
+ *
+ * @param path The path to play the sound from.
+ * @return The sound instance itself, as a {@link FunkinSound}.
+ */
+public static FunkinSound playSound(String path) {
+  FunkinSound sound = new FunkinSound(path);
+  if (sound.ID != -1) { // libGDX will return -1 if the sound fails to play.
+    soundPool.put(sound.ID, sound);
+  }
+  sound.play();
+  return sound;
+}
+```
+
+### Example of BAD Comments (With Bad Formatting)
+
+```java
+/**
+ * ooohhhhhef idkk plays a sound igg??????
+ *
+ * @prm daPatyhh its da path to play der sound (iykyk :fire:)
+ * @return tf you think vro :broken_heart:
+ */
+public static 
+FunkinSound playSound  (String   
+                                path) 
+{
+      FunkinSound sound =       new FunkinSound(path);
+    if
+    (sound.ID != -1){ // i have lito have no idea what this does :wilted_flower:
+  soundPool.put(sound.ID, sound);
+    }
+sound.play();
+        return sound;
+}
+```
+
+# libGDX
+
+This is a [libGDX](https://libgdx.com/) project generated with [gdx-liftoff](https://github.com/libgdx/gdx-liftoff).
+
+## Platforms
+
+FNF:JE is designed to run on multiple different platforms. Below are the different modules that hold the code for each one.
+
+- `core`: Main module with the game's logic shared by all platforms. <u>This is where you want to write your source code!</u>
+- `lwjgl3`: Primary desktop platform using [LWJGL3](https://www.lwjgl.org/). This is what launches the desktop versions of the game!
+- `android`: Android mobile platform. <u>This requires the Android SDK, which can be downloaded and configured simply by running the universal [setup file](setup/android_setup.sh)!</u>
+
+## Gradle
+
+This project uses [Gradle](https://gradle.org/) to manage dependencies.
+The Gradle wrapper was included, so you can run Gradle tasks using `gradlew.bat` or `./gradlew` commands.
+
+# Gradle Flags and Tasks
+
+- `--continue`: when using this flag, errors will not stop the tasks from running.
+- `--daemon`: thanks to this flag, Gradle daemon will be used to run chosen tasks.
+- `--offline`: when using this flag, cached dependency archives will be used.
+- `--refresh-dependencies`: this flag forces validation of all dependencies. Useful for snapshot versions.
+- `android:lint`: performs Android project validation.
+- `build`: builds sources and archives of every project.
+- `cleanEclipse`: removes Eclipse project data.
+- `cleanIdea`: removes IntelliJ project data.
+- `clean`: removes `build` folders, which store compiled classes and built archives.
+- `eclipse`: generates Eclipse project data.
+- `idea`: generates IntelliJ project data.
+- `lwjgl3:jar`: builds the game's runnable jar, which can be found at `lwjgl3/build/libs`.
+- `lwjgl3:run`: starts the desktop version of the game.
+- `test`: runs unit tests (if any).
+
+Note that most tasks that are not specific to a single project can be run with `name:` prefix, where the `name` should be replaced with the ID of a specific project.
+For example, `core:clean` removes `build` folder only from the `core` project.

README.md

@@ -1,35 +1,5 @@
-# Funkin-Java
+# Friday Night Funkin': Java Edition
 
-A [libGDX](https://libgdx.com/) project generated with [gdx-liftoff](https://github.com/libgdx/gdx-liftoff).
+Welcome to the official GitHub repository for the Java edition of Friday Night Funkin'!
 
-This project was generated with a template including simple application launchers and an `ApplicationAdapter` extension that draws libGDX logo.
-
-## Platforms
-
-- `core`: Main module with the application logic shared by all platforms.
-- `lwjgl3`: Primary desktop platform using LWJGL3; was called 'desktop' in older docs.
-- `android`: Android mobile platform. Needs Android SDK.
-
-## Gradle
-
-This project uses [Gradle](https://gradle.org/) to manage dependencies.
-The Gradle wrapper was included, so you can run Gradle tasks using `gradlew.bat` or `./gradlew` commands.
-Useful Gradle tasks and flags:
-
-- `--continue`: when using this flag, errors will not stop the tasks from running.
-- `--daemon`: thanks to this flag, Gradle daemon will be used to run chosen tasks.
-- `--offline`: when using this flag, cached dependency archives will be used.
-- `--refresh-dependencies`: this flag forces validation of all dependencies. Useful for snapshot versions.
-- `android:lint`: performs Android project validation.
-- `build`: builds sources and archives of every project.
-- `cleanEclipse`: removes Eclipse project data.
-- `cleanIdea`: removes IntelliJ project data.
-- `clean`: removes `build` folders, which store compiled classes and built archives.
-- `eclipse`: generates Eclipse project data.
-- `idea`: generates IntelliJ project data.
-- `lwjgl3:jar`: builds application's runnable jar, which can be found at `lwjgl3/build/libs`.
-- `lwjgl3:run`: starts the application.
-- `test`: runs unit tests (if any).
-
-Note that most tasks that are not specific to a single project can be run with `name:` prefix, where the `name` should be replaced with the ID of a specific project.
-For example, `core:clean` removes `build` folder only from the `core` project.
+### Please note that this unofficial version of the game is NOT completed! This has a long way to go, but with YOUR help, we can make this project come alive! <3

android/src/main/java/me/stringfromjava/funkin/android/AndroidLauncher.java

@@ -1,18 +1,18 @@
 package me.stringfromjava.funkin.android;
 
 import android.os.Bundle;
-
 import com.badlogic.gdx.backends.android.AndroidApplication;
 import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;
 import me.stringfromjava.funkin.FunkinGame;
 
 /** Launches the Android application. */
 public class AndroidLauncher extends AndroidApplication {
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        AndroidApplicationConfiguration configuration = new AndroidApplicationConfiguration();
-        configuration.useImmersiveMode = true; // Recommended, but not required.
-        initialize(new FunkinGame(), configuration);
-    }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    AndroidApplicationConfiguration configuration = new AndroidApplicationConfiguration();
+    configuration.useImmersiveMode = true; // Recommended, but not required.
+    initialize(new FunkinGame(), configuration);
+  }
 }