Initial commit

This commit is contained in:
Ash B 2021-07-30 20:53:09 +01:00
commit ba1e60d0ce
No known key found for this signature in database
GPG key ID: 1AE71DC3E127235F
19 changed files with 940 additions and 0 deletions

24
.github/workflows/build.yml vendored Normal file
View file

@ -0,0 +1,24 @@
name: Build
on: [pull_request, push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Validate gradle wrapper
uses: gradle/wrapper-validation-action@v1
- name: Setup JDK 16
uses: actions/setup-java@v1
with:
java-version: 16
- name: Ensure gradlew is executable
run: chmod +x ./gradlew
- name: Build with gradle
run: ./gradlew build
- name: Upload build artifacts
uses: actions/upload-artifact@v2
with:
name: Artifacts
path: build/libs/

33
.gitignore vendored Normal file
View file

@ -0,0 +1,33 @@
# gradle
.gradle/
build/
out/
classes/
# eclipse
*.launch
# idea
.idea/
*.iml
*.ipr
*.iws
# vscode
.settings/
.vscode/
bin/
.classpath
.project
# macos
*.DS_Store
# fabric
run/

40
README.md Normal file
View file

@ -0,0 +1,40 @@
# Player Pronouns
Let players share their pronouns!
## For players
### Commands
To change your displayed pronouns, you can use the command `/pronouns`.
It will suggest pronouns that are configured by the server admins, along with the default set. By default, you do not have to pick one of the suggestions at all, however server owners may disable setting custom pronouns in case of abuse, although it is not recommended to do so permanently.
## For server owners
### Configuration
The mod should work out of the box without any configuration, however if you want player's pronouns to be visible, you probably want to use the placeholder somewhere.
#### Adding custom pronouns (eg. neo-pronouns)
To add custom pronoun sets, you can use the `single` and `pairs` options in the config file. `single` is for singular options such as `any` or `ask` while `pairs` is for pronouns that come in pairs and are used in the form `a/b`, for example `they` and `them`.
#### Displaying pronouns
##### In chat with Styled Chat
[Styled Chat](https://modrinth.com/mod/styled-chat) allows you to customise the formatting of chat messages.
To configure pronouns to show up like this, you can set the `chat` style to the following:
`<${player} [%playerpronouns:pronouns%]> ${message}`
![](https://cdn.discordapp.com/attachments/859419898962116642/870732808367267881/in-chat.png)
##### On the tab list with Styled Player List
[Styled Player List](https://modrinth.com/mod/styledplayerlist) allows you to customise the look and feel of the tab/player list, as well as customise the formatting used for players in the list.
```json
{
"_comment": "Ensure that you include all the other default config options",
"changePlayerName": true,
"playerNameFormat": "%player:displayname% (%playerpronouns:pronouns%)",
"updatePlayerNameEveryChatMessage": true
}
```
![](https://cdn.discordapp.com/attachments/859419898962116642/870739744286453820/2021-07-30_19.45.49.png)

56
build.gradle.kts Normal file
View file

@ -0,0 +1,56 @@
plugins {
id("fabric-loom") version "0.9.45"
id("io.github.juuxel.loom-quiltflower") version "1.2.1"
`maven-publish`
}
version = "1.0.0-beta"
group = "io.github.ashisbored"
repositories {
// needed for placeholder-api
maven {
name = "NucleoidMC"
url = uri("https://maven.nucleoid.xyz/")
}
}
dependencies {
// Minecraft
minecraft(libs.minecraft)
mappings(variantOf(libs.yarn) { classifier("v2") })
// Fabric
modImplementation(libs.fabric.loader)
modImplementation(libs.fabric.api)
// placeholder-api
modImplementation(libs.placeholder.api)
include(libs.placeholder.api)
}
tasks.processResources {
inputs.property("version", project.version)
filesMatching("fabric.mod.json") {
expand("version" to project.version)
}
}
java {
sourceCompatibility = JavaVersion.VERSION_16
targetCompatibility = JavaVersion.VERSION_16
withSourcesJar()
}
tasks.withType<JavaCompile> {
options.encoding = "UTF-8"
options.release.set(16)
}
tasks.jar {
from("LICENSE") {
rename { "${it}_${project.name}" }
}
}

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file

Binary file not shown.

View file

@ -0,0 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

185
gradlew vendored Executable file
View file

@ -0,0 +1,185 @@
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MSYS* | MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
exec "$JAVACMD" "$@"

89
gradlew.bat vendored Normal file
View file

@ -0,0 +1,89 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

17
libs.versions.toml Normal file
View file

@ -0,0 +1,17 @@
[versions]
minecraft = "1.17.1"
yarn = "1.17.1+build.31"
fabric-loader = "0.11.6"
fabric-api = "0.37.1+1.17"
placeholder-api = "1.0.1+1.17"
[libraries]
minecraft = { module = "com.mojang:minecraft", version.ref = "minecraft" }
yarn = { module = "net.fabricmc:yarn", version.ref = "yarn" }
fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
placeholder-api = { module = "eu.pb4:placeholder-api", version.ref = "placeholder-api" }

25
settings.gradle.kts Normal file
View file

@ -0,0 +1,25 @@
pluginManagement {
repositories {
maven {
name = "FabricMC"
url = uri("https://maven.fabricmc.net/")
}
maven {
name = "Cotton"
url = uri("https://server.bbkr.space/artifactory/libs-release")
}
gradlePluginPortal()
}
}
rootProject.name = "player-pronouns"
enableFeaturePreview("VERSION_CATALOGS")
dependencyResolutionManagement {
versionCatalogs {
create("libs") {
from(files("libs.versions.toml"))
}
}
}

View file

@ -0,0 +1,79 @@
package io.github.ashisbored.playerpronouns;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.mojang.datafixers.util.Pair;
import com.mojang.serialization.Codec;
import com.mojang.serialization.JsonOps;
import com.mojang.serialization.codecs.RecordCodecBuilder;
import net.fabricmc.loader.api.FabricLoader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
public class Config {
private static final Codec<Config> CODEC = RecordCodecBuilder.create(instance -> instance.group(
Codec.BOOL.fieldOf("allow_custom").forGetter(config -> config.allowCustom),
Codec.STRING.listOf().fieldOf("single").forGetter(config -> config.single),
Codec.STRING.listOf().fieldOf("pairs").forGetter(config -> config.pairs)
).apply(instance, Config::new));
private final boolean allowCustom;
private final List<String> single;
private final List<String> pairs;
private Config(boolean allowCustom, List<String> single, List<String> pairs) {
this.allowCustom = allowCustom;
this.single = single;
this.pairs = pairs;
}
private Config() {
this(true, Collections.emptyList(), Collections.emptyList());
}
public boolean allowCustom() {
return allowCustom;
}
public List<String> getSingle() {
return single;
}
public List<String> getPairs() {
return pairs;
}
public static Config load() {
Path path = FabricLoader.getInstance().getConfigDir().resolve("player-pronouns.json");
if (!Files.exists(path)) {
Config config = new Config();
Optional<JsonElement> result = CODEC.encodeStart(JsonOps.INSTANCE, config).result();
if (result.isPresent()) {
try {
Files.writeString(path, new GsonBuilder().setPrettyPrinting().create().toJson(result.get()));
} catch (IOException e) {
PlayerPronouns.LOGGER.warn("Failed to save default config!", e);
}
} else {
PlayerPronouns.LOGGER.warn("Failed to save default config!");
}
return new Config();
} else {
try {
String s = Files.readString(path);
JsonParser parser = new JsonParser();
JsonElement ele = parser.parse(s);
return CODEC.decode(JsonOps.INSTANCE, ele).map(Pair::getFirst).result().orElseGet(Config::new);
} catch (IOException e) {
PlayerPronouns.LOGGER.warn("Failed to load config!", e);
return new Config();
}
}
}
}

View file

@ -0,0 +1,97 @@
package io.github.ashisbored.playerpronouns;
import eu.pb4.placeholders.PlaceholderAPI;
import eu.pb4.placeholders.PlaceholderResult;
import io.github.ashisbored.playerpronouns.command.PronounsCommand;
import io.github.ashisbored.playerpronouns.data.BinaryPronounDatabase;
import io.github.ashisbored.playerpronouns.data.PronounList;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.util.Identifier;
import net.minecraft.util.WorldSavePath;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Objects;
public class PlayerPronouns implements ModInitializer {
public static final Logger LOGGER = LogManager.getLogger();
public static final String MOD_ID = "playerpronouns";
private static BinaryPronounDatabase pronounDatabase;
public static Config config;
@Override
public void onInitialize() {
LOGGER.info("Player Pronouns initialising...");
config = Config.load();
PronounList.load(config);
ServerLifecycleEvents.SERVER_STARTING.register(server -> {
try {
Path playerData = server.getSavePath(WorldSavePath.PLAYERDATA);
if (!Files.exists(playerData)) {
Files.createDirectories(playerData);
}
pronounDatabase = BinaryPronounDatabase.load(playerData.resolve("pronouns.dat"));
} catch (IOException e) {
LOGGER.error("Failed to create/load pronoun database!", e);
}
});
ServerLifecycleEvents.SERVER_STOPPING.register(server -> {
if (pronounDatabase != null) {
try {
savePronounDatabase(server);
} catch (IOException e) {
LOGGER.error("Failed to save pronoun database!", e);
}
}
});
//noinspection CodeBlock2Expr
CommandRegistrationCallback.EVENT.register((dispatcher, __) -> {
PronounsCommand.register(dispatcher);
});
PlaceholderAPI.register(new Identifier(MOD_ID, "pronouns"), ctx -> {
if (!ctx.hasPlayer()) {
return PlaceholderResult.invalid("missing player");
}
ServerPlayerEntity player = ctx.getPlayer();
if (pronounDatabase == null) {
return PlaceholderResult.value("Unknown");
}
String pronouns = pronounDatabase.get(player.getUuid());
return PlaceholderResult.value(Objects.requireNonNullElse(pronouns, "Unknown"));
});
}
private static void savePronounDatabase(MinecraftServer server) throws IOException {
Path playerData = server.getSavePath(WorldSavePath.PLAYERDATA);
if (!Files.exists(playerData)) {
Files.createDirectories(playerData);
}
pronounDatabase.save(playerData.resolve("pronouns.dat"));
}
public static boolean setPronouns(ServerPlayerEntity player, String pronouns) {
if (pronounDatabase == null) return false;
pronounDatabase.put(player.getUuid(), pronouns);
try {
savePronounDatabase(Objects.requireNonNull(player.getServer()));
} catch (IOException e) {
LOGGER.error("Failed to save pronoun database!", e);
}
return true;
}
}

View file

@ -0,0 +1,29 @@
package io.github.ashisbored.playerpronouns.command;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.builder.RequiredArgumentBuilder;
import io.github.ashisbored.playerpronouns.data.PronounList;
import net.minecraft.server.command.CommandManager;
import net.minecraft.server.command.ServerCommandSource;
import java.util.Locale;
public class PronounsArgument {
public static RequiredArgumentBuilder<ServerCommandSource, String> pronouns(String name) {
return CommandManager.argument(name, StringArgumentType.greedyString())
.suggests((ctx, builder) -> {
String remaining = builder.getRemainingLowerCase();
for (String pronouns : PronounList.get().getCalculatedPronounStrings()) {
if (pronouns.toLowerCase(Locale.ROOT).startsWith(remaining)) {
builder.suggest(pronouns);
}
}
return builder.buildFuture();
});
}
private PronounsArgument() { }
}

View file

@ -0,0 +1,41 @@
package io.github.ashisbored.playerpronouns.command;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.CommandDispatcher;
import io.github.ashisbored.playerpronouns.PlayerPronouns;
import io.github.ashisbored.playerpronouns.data.PronounList;
import net.minecraft.server.command.ServerCommandSource;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.text.LiteralText;
import net.minecraft.util.Formatting;
import static com.mojang.brigadier.arguments.StringArgumentType.getString;
import static io.github.ashisbored.playerpronouns.command.PronounsArgument.pronouns;
import static net.minecraft.server.command.CommandManager.literal;
public class PronounsCommand {
public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
dispatcher.register(literal("pronouns")
.then(pronouns("pronouns")
.executes(ctx -> {
ServerPlayerEntity player = ctx.getSource().getPlayer();
String pronouns = getString(ctx, "pronouns");
if (!PlayerPronouns.config.allowCustom() && !PronounList.get().getCalculatedPronounStrings().contains(pronouns)) {
ctx.getSource().sendError(new LiteralText("Custom pronouns have been disabled by the server administrator."));
return 0;
}
if (!PlayerPronouns.setPronouns(player, pronouns)) {
ctx.getSource().sendError(new LiteralText("Failed to update pronouns, sorry"));
} else {
ctx.getSource().sendFeedback(new LiteralText("Updated your pronouns to " + pronouns + "!")
.formatted(Formatting.GREEN), false);
}
return Command.SINGLE_SUCCESS;
})
)
);
}
}

View file

@ -0,0 +1,80 @@
package io.github.ashisbored.playerpronouns.data;
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import org.jetbrains.annotations.Nullable;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.UUID;
public class BinaryPronounDatabase {
private final Object2ObjectMap<UUID, String> data;
private BinaryPronounDatabase(Object2ObjectMap<UUID, String> data) {
this.data = data;
}
private BinaryPronounDatabase() {
this(new Object2ObjectOpenHashMap<>());
}
public void put(UUID uuid, @Nullable String pronouns) {
if (pronouns == null) {
this.data.remove(uuid);
} else {
this.data.put(uuid, pronouns);
}
}
public @Nullable String get(UUID uuid) {
return this.data.get(uuid);
}
public synchronized void save(Path path) throws IOException {
try (OutputStream os = Files.newOutputStream(path);
DataOutputStream out = new DataOutputStream(os)) {
out.writeShort(0x4567); // some form of magic, idk
out.writeInt(data.size());
for (var entry : data.entrySet()) {
UUID uuid = entry.getKey();
out.writeLong(uuid.getMostSignificantBits());
out.writeLong(uuid.getLeastSignificantBits());
out.writeUTF(entry.getValue());
}
}
}
public static BinaryPronounDatabase load(Path path) throws IOException {
if (!Files.exists(path)) {
return new BinaryPronounDatabase();
}
try (InputStream is = Files.newInputStream(path);
DataInputStream in = new DataInputStream(is)) {
short magic = in.readShort();
if (magic != 0x4567) {
throw new IOException("Invalid DB magic: " + magic);
}
int size = in.readInt();
Object2ObjectOpenHashMap<UUID, String> data = new Object2ObjectOpenHashMap<>();
for (int i = 0; i < size; i++) {
long mostSigBits = in.readLong();
long leastSigBits = in.readLong();
UUID uuid = new UUID(mostSigBits, leastSigBits);
String pronouns = in.readUTF();
String old = data.put(uuid, pronouns);
if (old != null) {
throw new IOException("Duplicate UUID in database: " + uuid);
}
}
return new BinaryPronounDatabase(data);
}
}
}

View file

@ -0,0 +1,90 @@
package io.github.ashisbored.playerpronouns.data;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import io.github.ashisbored.playerpronouns.Config;
import io.github.ashisbored.playerpronouns.PlayerPronouns;
import net.minecraft.util.Pair;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
public class PronounList {
private static PronounList INSTANCE;
private final List<String> defaultSingle;
private final List<String> defaultPairs;
private final List<String> customSingle;
private final List<String> customPairs;
private final List<String> calculatedPronounStrings;
public PronounList(List<String> defaultSingle, List<String> defaultPairs, List<String> customSingle, List<String> customPairs) {
this.defaultSingle = defaultSingle;
this.defaultPairs = defaultPairs;
this.customSingle = customSingle;
this.customPairs = customPairs;
this.calculatedPronounStrings = this.computePossibleCombinations();
}
public List<String> getCalculatedPronounStrings() {
return this.calculatedPronounStrings;
}
private List<String> computePossibleCombinations() {
List<String> ret = new ArrayList<>();
ret.addAll(this.defaultSingle);
ret.addAll(this.customSingle);
List<String> combinedPairs = new ArrayList<>();
combinedPairs.addAll(this.defaultPairs);
combinedPairs.addAll(this.customPairs);
for (int i = 0; i < combinedPairs.size(); i++) {
for (int j = 0; j < combinedPairs.size(); j++) {
if (i == j) continue;
ret.add(combinedPairs.get(i) + "/" + combinedPairs.get(j));
}
}
ret.sort(Comparator.naturalOrder());
return ret;
}
public static void load(Config config) {
if (INSTANCE != null) {
throw new IllegalStateException("PronounList has already been loaded!");
}
Pair<List<String>, List<String>> defaults = loadDefaults();
INSTANCE = new PronounList(
defaults.getLeft(),
defaults.getRight(),
config.getSingle(),
config.getPairs()
);
}
public static PronounList get() {
if (INSTANCE == null) {
throw new IllegalStateException("PronounList has not been loaded!");
}
return INSTANCE;
}
private static Pair<List<String>, List<String>> loadDefaults() {
try (InputStream is = Objects.requireNonNull(PronounList.class.getResourceAsStream("/default_pronouns.json"));
InputStreamReader reader = new InputStreamReader(is)) {
JsonObject ele = new JsonParser().parse(reader).getAsJsonObject();
JsonArray jsonSingle = ele.getAsJsonArray("single");
JsonArray jsonPairs = ele.getAsJsonArray("pairs");
List<String> single = new ArrayList<>();
List<String> pairs = new ArrayList<>();
jsonSingle.forEach(e -> single.add(e.getAsString()));
jsonPairs.forEach(e -> pairs.add(e.getAsString()));
return new Pair<>(single, pairs);
} catch (IOException e) {
PlayerPronouns.LOGGER.error("Failed to load default pronouns!", e);
return new Pair<>(Collections.emptyList(), Collections.emptyList());
}
}
}

View file

@ -0,0 +1,15 @@
{
"_comment": "See default_pronouns.txt",
"single": [
"any",
"ask",
"avoid",
"other"
],
"pairs": [
"he", "him",
"it", "its",
"she", "her",
"they", "them"
]
}

View file

@ -0,0 +1,3 @@
The default pronouns are sorted in the file alphabetically to avoid bias.
Pairs are pronouns that can be combined in the form a/b, and are ordered with both forms on the same line.
The list of default pronouns is based on the available pronouns on https://pronoundb.org/

View file

@ -0,0 +1,32 @@
{
"schemaVersion": 1,
"id": "playerpronouns",
"version": "${version}",
"name": "Player Pronouns",
"description": "A server-side mod adding pronouns!",
"authors": [
"Ash (ashisbored)"
],
"contact": {
"sources": "https://github.com/ashisbored/player-pronouns",
"issues": "https://github.com/ashisbored/player-pronouns/issues"
},
"license": "MIT",
"environment": "*",
"entrypoints": {
"main": [
"io.github.ashisbored.playerpronouns.PlayerPronouns"
]
},
"depends": {
"fabricloader": ">=0.11.6",
"fabric": "*",
"minecraft": "1.17.x",
"java": ">=16"
}
}