SimplexDevelopment/FeelingLucky
1
0
Fork 0
mirror of https://github.com/SimplexDevelopment/FeelingLucky.git synced 2025-04-05 00:33:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: SimplexDevelopment:main
Branches Tags
SimplexDevelopment:main
SimplexDevelopment:Spigot-Support-Branch
SimplexDevelopment:bleeding
SimplexDevelopment:v1.3.0
SimplexDevelopment:1.2.1
SimplexDevelopment:1.2.0
SimplexDevelopment:1.2.0-RC01
SimplexDevelopment:Beta-1.0
SimplexDevelopment:Beta-1.0-RC02
SimplexDevelopment:Beta-1.0-RC01
SimplexDevelopment:Beta-20220422-SNAPSHOT
SimplexDevelopment:Alpha-1.0
SimplexDevelopment:Alpha-RC04
SimplexDevelopment:Alpha-RC03
SimplexDevelopment:Alpha-RC02
SimplexDevelopment:Alpha-RC01
..
compare: SimplexDevelopment:1.2.0
Branches Tags
SimplexDevelopment:main
SimplexDevelopment:Spigot-Support-Branch
SimplexDevelopment:bleeding
SimplexDevelopment:v1.3.0
SimplexDevelopment:1.2.1
SimplexDevelopment:1.2.0
SimplexDevelopment:1.2.0-RC01
SimplexDevelopment:Beta-1.0
SimplexDevelopment:Beta-1.0-RC02
SimplexDevelopment:Beta-1.0-RC01
SimplexDevelopment:Beta-20220422-SNAPSHOT
SimplexDevelopment:Alpha-1.0
SimplexDevelopment:Alpha-RC04
SimplexDevelopment:Alpha-RC03
SimplexDevelopment:Alpha-RC02
SimplexDevelopment:Alpha-RC01

No commits in common. "main" and "1.2.0" have entirely different histories.
main ... 1.2.0

41 changed files with 300 additions and 1511 deletions
Show Stats Expand all files Collapse all files

32
.github/workflows/codacy-analysis.yml vendored
View File

@ -1,32 +0,0 @@
name: Codacy Security Scan
on:
push:
branches: [ "master", "main" ]
pull_request:
branches: [ "master", "main" ]
jobs:
codacy-security-scan:
name: Codacy Security Scan
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@main
- name: Run Codacy Analysis CLI
uses: codacy/codacy-analysis-cli-action@master
with:
output: results.sarif
format: sarif
# Adjust severity of non-security issues
gh-code-scanning-compat: true
# Force 0 exit code to allow SARIF file generation
# This will handover control about PR rejection to the GitHub side
max-allowed-issues: 2147483647
# Upload the SARIF file generated in the previous step
- name: Upload SARIF results file
uses: github/codeql-action/upload-sarif@main
with:
sarif_file: results.sarif

5
README.md
View File

@ -1,4 +1,4 @@
# <center>FeelingLucky v1.3.0 - A luck driven mechanics plugin.</center>
# <center>FeelingLucky v1.2.0</center>
## <center><u><span style="color:blue">Plugin Description:</u></center>
@ -17,13 +17,12 @@ Admins can set, reset, add to, and take from player's luck stat.
Admins can also reload the main configuration, as well as individual and all player configurations.
For this, the command is <b><span style="color:violet">/luck reload -m</color></b> for the main config,
<b><span style="color:violet">/luck reload</color></b> to reload all player configurations, and <b><span style="color:violet">/luck reload -p <i>PLAYER_NAME</i></span></b> to reload individual player configuration files.
Server owners and/or individuals with console access can run /rgc to regenerate the main configuration file in the case that there are values missing, corrupted, or invalid.
## <center><u><span style="color:blue">Server Requirements:</u></center>
In order to run <b>FeelingLucky</b> v<b>1.1.0</b>, the latest version of Paper or Spigot is required.
#### <center><span style="color:red">Note: Paper is REQUIRED for this plugin to run. Spigot is not supported, however Spigot support is currently in progress.</center></span>
#### <center><span style="color:red">Note: Paper is REQUIRED for this plugin to run. Spigot is not supported, and support for Spigot will not be added in the future.</center></span>
### <center>Note: If you are migrating from an Alpha build, the plugin configuration folder will need to be regenerated.</center>

5
build.gradle
View File

@ -3,7 +3,7 @@ plugins {
}
group = 'io.github.simplex'
version = '1.3.0'
version = '1.2.0'
repositories {
mavenCentral()
@ -12,8 +12,7 @@ repositories {
}
dependencies {
compileOnly("io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT")
implementation 'redis.clients:jedis:3.7.0'
compileOnly("io.papermc.paper:paper-api:1.19-R0.1-SNAPSHOT")
}
def targetJavaVersion = 17

2
gradle/wrapper/gradle-wrapper.properties vendored
View File

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

54
src/main/java/io/github/simplex/api/LuckContainer.java
View File

@ -1,68 +1,18 @@
package io.github.simplex.api;
import java.io.Serializable;
import org.bukkit.entity.Player;
/**
* The LuckContainer interface represents a container for player luck.
* It provides methods to get and set the verbosity of the luck container,
* check if a number matches or is close to the luck value, get the multiplier,
* get the associated player, and get the luck value.
*
* This interface is Serializable, which means it can be written to a stream
* and restored.
*/
import java.io.Serializable;
public interface LuckContainer extends Serializable {
/**
* Checks if the luck container is verbose.
*
* @return true if the luck container is verbose, false otherwise.
*/
boolean isVerbose();
/**
* Sets the verbosity of the luck container.
*
* @param verbose the verbosity to set.
*/
void setVerbose(boolean verbose);
/**
* Checks if a number matches the luck value.
*
* @param number the number to check.
* @return true if the number matches the luck value, false otherwise.
*/
boolean isMatch(double number);
/**
* Checks if a number is close to the luck value within a certain range.
*
* @param number the number to check.
* @param range the range within which the number is considered close.
* @return true if the number is close to the luck value, false otherwise.
*/
boolean isClose(double number, int range);
/**
* Gets the multiplier of the luck container.
*
* @return the multiplier.
*/
double multiplier();
/**
* Gets the player associated with the luck container.
*
* @return the associated player.
*/
Player associatedPlayer();
/**
* Gets the luck value of the luck container.
*
* @return the luck value.
*/
double getValue();
}

16
src/main/java/io/github/simplex/lib/Messages.java
View File

@ -1,25 +1,21 @@
package io.github.simplex.lib;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.Component;
public enum Messages
{
public enum Messages {
NOT_FROM_CONSOLE(MiniComponent.err("This command may only be used in game.")),
NO_PERMISSION(MiniComponent.err("You do not have permission to use this command.")),
NO_PLAYER(MiniComponent.warn("That player cannot be found.")),
OUT_OF_BOUNDS(MiniComponent.err("Number must be between -1024.0 and 1024.0")),
VERBOSE_DISABLED(MiniComponent.err("Verbose mode is currently disabled globally."));
OUT_OF_BOUNDS(MiniComponent.err("Number must be between -1024.0 and 1024.0"));
private final ComponentLike message;
private final Component message;
Messages(ComponentLike message)
{
Messages(Component message) {
this.message = message;
}
public ComponentLike get()
{
public Component get() {
return message;
}
}

10
src/main/java/io/github/simplex/lib/MiniComponent.java
View File

@ -1,12 +1,10 @@
package io.github.simplex.lib;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.ComponentLike;
import net.kyori.adventure.text.format.TextColor;
import net.kyori.adventure.text.format.TextDecoration;
import org.bukkit.ChatColor;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.Nullable;
public class MiniComponent {
private final String content;
@ -23,17 +21,17 @@ public class MiniComponent {
}
@Contract("_ -> new")
public static ComponentLike info(String content) {
public static Component info(String content) {
return new MiniComponent(content).color(ChatColor.GREEN).send();
}
@Contract("_ -> new")
public static ComponentLike warn(String content) {
public static Component warn(String content) {
return new MiniComponent(content).color(ChatColor.YELLOW).decorate(TextDecoration.ITALIC).send();
}
@Contract("_ -> new")
public static ComponentLike err(String content) {
public static Component err(String content) {
return new MiniComponent(content).color(ChatColor.RED).decorate(TextDecoration.BOLD).send();
}
@ -47,7 +45,7 @@ public class MiniComponent {
return this;
}
public @Nullable Component send() {
public Component send() {
if (color == null) {
if (decoration == null) return Component.empty().content(content);

167
src/main/java/io/github/simplex/luck/Config.java
View File

@ -1,25 +1,20 @@
package io.github.simplex.luck;
import io.github.simplex.luck.listener.AbstractListener;
import io.github.simplex.luck.util.Logs;
import io.github.simplex.luck.util.SneakyWorker;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import io.github.simplex.sql.SQLType;
import org.bukkit.configuration.file.YamlConfiguration;
import org.jetbrains.annotations.NotNull;
public class Config extends YamlConfiguration
{
private final Map<String, Object> configEntries = new HashMap<>()
{{
import java.io.File;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings("ResultOfMethodCallIgnored")
public class Config extends YamlConfiguration {
private final Map<String, Object> configEntries = new HashMap<>() {{
put("high_rarity_chance", 512.0);
put("medium_rarity_chance", 128.0);
put("low_rarity_chance", 64.0);
put("global_verbosity", true);
put("block_drops", "LOW");
put("bonemeal", "MED");
put("cheat_death", "MED");
@ -35,34 +30,28 @@ public class Config extends YamlConfiguration
put("take_damage", "MED");
put("unbreakable", "HIGH");
}};
private final File configFile;
private File configFile;
public Config(FeelingLucky plugin)
{
public Config(FeelingLucky plugin) {
File dataFolder = plugin.getDataFolder();
if (dataFolder.mkdirs())
{
if (dataFolder.mkdirs()) {
plugin.getLogger().info("Created new data folder. Writing new configuration file...");
plugin.saveResource("config.yml", true);
}
File configFile = new File(dataFolder, "config.yml");
if (!configFile.exists())
{
if (!configFile.exists()) {
plugin.getLogger().info("No configuration file exists. Creating a new one...");
plugin.saveResource("config.yml", true);
}
this.configFile = configFile;
if (validateIntegrity(this.configFile))
{
if (validateIntegrity(this.configFile)) {
load();
}
else
{
} else {
configEntries.forEach(super::set);
Logs.warn("Your configuration file is missing keys. " +
plugin.getLogger().warning("Your configuration file is missing keys. " +
"\nPlease use /rgc in the console to regenerate the config file. " +
"\nAlternatively, delete the config.yml and restart your server. " +
"\nIt is safe to ignore this, as default values will be used." +
@ -70,148 +59,40 @@ public class Config extends YamlConfiguration
}
}
public void save()
{
public void save() {
SneakyWorker.sneakyTry(() -> save(configFile));
}
public void load()
{
public void load() {
SneakyWorker.sneakyTry(() -> load(configFile));
}
public void reload()
{
public void reload() {
save();
load();
}
public boolean validateIntegrity(@NotNull File fromDisk)
{
public boolean validateIntegrity(@NotNull File fromDisk) {
YamlConfiguration disk = YamlConfiguration.loadConfiguration(fromDisk);
if (disk.getKeys(true).isEmpty())
{
if (disk.getKeys(true).size() <= 0) {
return false;
}
boolean result = true;
for (String key : configEntries.keySet())
{
if (!disk.getKeys(false).contains(key))
{
if (result)
result = false;
for (String key : configEntries.keySet()) {
if (!disk.getKeys(false).contains(key)) {
if (result) result = false;
}
}
return result;
}
public AbstractListener.Rarity getRarity(String name)
{
public AbstractListener.Rarity getRarity(String name) {
return AbstractListener.Rarity.valueOf(getString(name));
}
public double getChance(String path)
{
public double getChance(String path) {
return getDouble(path);
}
public boolean isVerboseGlobal() {
return getBoolean("global_verbosity");
}
public SQLType getSQLType() {
return SQLType.fromString(Objects.requireNonNull(getString("database_type")));
}
public SQLiteWrapper getSQLite() {
return new SQLiteWrapper();
}
public RedisWrapper getRedis() {
return new RedisWrapper();
}
public MySQLWrapper getMySQL() {
return new MySQLWrapper();
}
public final class SQLiteWrapper {
private final String path;
public SQLiteWrapper() {
this.path = getString("sqlite.path");
}
public String getPath() {
return path;
}
}
public final class RedisWrapper {
private final String host;
private final String port;
private final String password;
private final int database;
public RedisWrapper() {
this.host = getString("redis.host");
this.port = getString("redis.port");
this.password = getString("redis.password");
this.database = getInt("redis.database");
}
public String getHost() {
return host;
}
public String getPort() {
return port;
}
public String getPassword() {
return password;
}
public int getDatabase() {
return database;
}
}
public final class MySQLWrapper {
private final String host;
private final int port;
private final String database;
private final String username;
private final String password;
public MySQLWrapper() {
this.host = getString("mysql.host");
this.port = getInt("mysql.port");
this.database = getString("mysql.database");
this.username = getString("mysql.username");
this.password = getString("mysql.password");
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public String getDatabase() {
return database;
}
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
}
}

119
src/main/java/io/github/simplex/luck/FeelingLucky.java
View File

@ -3,43 +3,28 @@ package io.github.simplex.luck;
import io.github.simplex.luck.listener.*;
import io.github.simplex.luck.player.PlayerConfig;
import io.github.simplex.luck.player.PlayerHandler;
import io.github.simplex.luck.util.Logs;
import io.github.simplex.luck.util.LuckCMD;
import io.github.simplex.luck.util.RegenerateConfigCMD;
import io.github.simplex.luck.util.SpecialFootItem;
import io.github.simplex.metrics.Metrics;
import org.bukkit.command.CommandMap;
import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import io.github.simplex.sql.MySQL;
import io.github.simplex.sql.Redis;
import io.github.simplex.sql.SQLType;
import io.github.simplex.sql.SQLite;
import net.kyori.adventure.chat.ChatType;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandMap;
import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.NotNull;
public final class FeelingLucky extends JavaPlugin {
private final Map<UUID, PlayerConfig> configMap = new HashMap<>();
private final File playerDirectory = new File(getDataFolder(), "players");
private final SpecialFootItem specialFootItem = new SpecialFootItem();
private final ChatType.Bound bind = ChatType.CHAT.bind(Component.text(getName()));
private PlayerHandler handler;
private Config config;
private MySQL mysql;
private SQLite sqlite;
private Redis Redis;
private boolean shouldLoadPhysical = false;
public Map<UUID, PlayerConfig> getConfigMap() {
return configMap;
}
@ -48,14 +33,12 @@ public final class FeelingLucky extends JavaPlugin {
public void onEnable() {
getLogger().info("Initializing metrics...");
new Metrics(this, 15054);
getLogger().info("Metrics loaded. Initializing SQL...");
initSQL();
getLogger().info("Metrics loaded. Initializing the PlayerHandler...");
handler = new PlayerHandler(this);
getLogger().info("Initialization complete! Attempting to register the Listeners...");
registerListeners();
getLogger().info("Registration complete! Attempting to load all saved player configurations...");
getLogger().info("Registration complete! Attempting to load all player configuration files...");
loadPlayerConfigurations();
getLogger().info("Player configurations loaded! Initializing PlayerHandler...");
handler = new PlayerHandler(this);
getLogger().info("Attempting to load the main configuration...");
config = new Config(this);
getLogger().info("Main Config loaded successfully! Loading commands...");
@ -75,69 +58,6 @@ public final class FeelingLucky extends JavaPlugin {
getLogger().info("Complete! Goodbye! :)");
}
private void initSQL() {
switch (config.getSQLType()) {
case MYSQL -> {
try {
mysql = new MySQL(this);
} catch (Exception e) {
getLogger().severe("Failed to initialize MySQL. Falling back to standard plugin configuration.");
Logs.error(e);
shouldLoadPhysical(true);
}
}
case SQLITE -> {
try {
sqlite = new SQLite(this);
} catch (SQLException e) {
getLogger().severe("Failed to initialize SQLite. Falling back to standard plugin configuration.");
Logs.error(e);
shouldLoadPhysical(true);
}
}
case REDIS -> {
Redis = new Redis(this);
}
}
}
private void saveToSQL() {
switch (config.getSQLType()) {
case MYSQL -> {
mysql.savePlayers();
}
case SQLITE -> {
try {
sqlite.savePlayers();
} catch (Exception e) {
Logs.error(e);
}
}
case REDIS -> {
Redis = new Redis(this);
Redis.savePlayers();
}
}
}
private void loadPlayersFromSQL() {
switch (config.getSQLType()) {
case MYSQL -> {
mysql.loadPlayers();
}
case SQLITE -> {
try {
sqlite.loadPlayers();
} catch (SQLException e) {
Logs.error(e);
}
}
case REDIS -> {
Redis.loadPlayers();
}
}
}
private void loadPlayerConfigurations() {
if (!playerDirectory.exists()) {
getLogger().info("No directory exists. Creating...");
@ -146,18 +66,11 @@ public final class FeelingLucky extends JavaPlugin {
return;
}
if (config.getSQLType() != SQLType.NONE && !shouldLoadPhysical()) {
loadPlayersFromSQL();
getLogger().info("Successfully loaded all configurations from SQL!");
return;
}
File[] files = playerDirectory.listFiles();
if (files != null) {
Arrays.stream(files).forEach(file ->
{
Arrays.stream(files).forEach(file -> {
UUID uuid = UUID.fromString(file.getName().split("\\.")[0]);
configMap.put(uuid, PlayerConfig.initFromFile(this, file));
configMap.put(uuid, PlayerConfig.initFrom(this, file));
});
configMap.forEach((u, pc) -> pc.load());
getLogger().info("Successfully loaded all configurations!");
@ -177,7 +90,7 @@ public final class FeelingLucky extends JavaPlugin {
new IllOmen(this);
new ItemDrops(this);
new JumpBoost(this);
// new OreVein(this); (Currently unstable & unsafe).
new OreVein(this);
new PlayerListener(this);
new RandomEffect(this);
new RestoreHunger(this);
@ -200,19 +113,7 @@ public final class FeelingLucky extends JavaPlugin {
return specialFootItem;
}
private void shouldLoadPhysical(boolean state) {
shouldLoadPhysical = state;
}
private boolean shouldLoadPhysical() {
return shouldLoadPhysical;
}
public CommandMap getCommandMap() {
return getServer().getCommandMap();
}
public ChatType.Bound bind() {
return bind;
}
}

7
src/main/java/io/github/simplex/luck/listener/AbstractListener.java
View File

@ -1,9 +1,8 @@
package io.github.simplex.luck.listener;
import io.github.simplex.luck.Config;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.PlayerHandler;
import net.kyori.adventure.audience.Audience;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
public abstract class AbstractListener implements Listener {
@ -36,8 +35,4 @@ public abstract class AbstractListener implements Listener {
LOW,
NONE
}
public Audience asAudience(final Player player) {
return player;
}
}

19
src/main/java/io/github/simplex/luck/listener/BlockDrops.java
View File

@ -1,35 +1,28 @@
package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import io.github.simplex.luck.util.SneakyWorker;
import java.util.List;
import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockDropItemEvent;
public final class BlockDrops extends AbstractListener
{
public BlockDrops(FeelingLucky plugin)
{
import java.util.List;
public final class BlockDrops extends AbstractListener {
public BlockDrops(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void extraBlockDrops(BlockDropItemEvent event)
{
public void extraBlockDrops(BlockDropItemEvent event) {
Player player = event.getPlayer();
Luck luck = getHandler().getLuckContainer(player);
List<Item> items = event.getItems();
if (luck.quickRNG(luck.getValue()) && doesQualify("block_drops", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("block_drops", luck.getValue())) {
event.getItems().addAll(items.stream().map(SneakyWorker::move).toList());
}
if (luck.isVerbose())
asAudience(player).sendMessage(MiniComponent.info("You got lucky and received extra drops!"));
}
}

8
src/main/java/io/github/simplex/luck/listener/BonemealFullCrop.java
View File

@ -4,7 +4,6 @@ import io.github.simplex.lib.ItemBuilder;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import net.kyori.adventure.audience.Audience;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.Ageable;
@ -24,7 +23,6 @@ public final class BonemealFullCrop extends AbstractListener {
@EventHandler
public void bonemealFullCrop(PlayerInteractEvent event) {
Player player = event.getPlayer();
Audience pAud = player;
Action action = event.getAction();
ItemStack bonemeal = ItemBuilder.of(Material.BONE_MEAL).build();
Luck luck = getHandler().getLuckContainer(player);
@ -45,12 +43,6 @@ public final class BonemealFullCrop extends AbstractListener {
crop.setAge(crop.getMaximumAge());
data.merge(crop);
block.setBlockData(data);
if (luck.isVerbose()) {
asAudience(player).sendMessage(MiniComponent.info("Your luck has caused your crop to become ready for" +
" " +
"harvest!"));
}
}
}
}

19
src/main/java/io/github/simplex/luck/listener/CheatDeath.java
View File

@ -3,35 +3,26 @@ package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import net.kyori.adventure.audience.Audience;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.PlayerDeathEvent;
public final class CheatDeath extends AbstractListener
{
public CheatDeath(FeelingLucky plugin)
{
public final class CheatDeath extends AbstractListener {
public CheatDeath(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void cheatDeath(PlayerDeathEvent event)
{
public void cheatDeath(PlayerDeathEvent event) {
Player player = event.getPlayer();
Luck luck = getHandler().getLuckContainer(player);
double absorption = Math.round(Luck.RNG().nextDouble(5.0, 10.0));
if (luck.quickRNG(luck.getValue()) && doesQualify("cheat_death", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("cheat_death", luck.getValue())) {
event.setCancelled(true);
player.setHealth(1.0);
player.setAbsorptionAmount(absorption);
if (luck.isVerbose())
{
asAudience(player).sendMessage(MiniComponent.info("You got lucky and cheated death!"));
}
player.sendMessage(MiniComponent.of("You got lucky and cheated death!").send());
}
}
}

30
src/main/java/io/github/simplex/luck/listener/EnchantmentBoost.java
View File

@ -1,52 +1,40 @@
package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import java.util.List;
import java.util.Map;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.enchantment.EnchantItemEvent;
public final class EnchantmentBoost extends AbstractListener
{
public EnchantmentBoost(FeelingLucky plugin)
{
import java.util.List;
import java.util.Map;
public final class EnchantmentBoost extends AbstractListener {
public EnchantmentBoost(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void enchantItem(EnchantItemEvent event)
{
public void enchantItem(EnchantItemEvent event) {
Map<Enchantment, Integer> enchMap = event.getEnchantsToAdd();
List<Enchantment> enchList = enchMap.keySet().stream().toList();
Player player = event.getEnchanter();
Luck luck = getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("enchanting", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("enchanting", luck.getValue())) {
Enchantment particular = enchList.get(Luck.RNG().nextInt(enchList.size()));
int rng = Luck.RNG().nextInt(1, 5);
if ((enchMap.get(particular) + rng) > particular.getMaxLevel())
{
if ((enchMap.get(particular) + rng) > particular.getMaxLevel()) {
enchMap.replace(particular, particular.getMaxLevel());
}
enchMap.replace(particular, enchMap.get(particular) + rng);
if (luck.isVerbose())
{
asAudience(player).sendMessage(
MiniComponent.info("Your luck has given you an extra random enchantment."));
}
}
}
public FeelingLucky plugin()
{
public FeelingLucky plugin() {
return plugin;
}
}

18
src/main/java/io/github/simplex/luck/listener/ExpBoost.java
View File

@ -1,38 +1,28 @@
package io.github.simplex.luck.listener;
import com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import org.bukkit.entity.ExperienceOrb;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
public final class ExpBoost extends AbstractListener
{
public ExpBoost(FeelingLucky plugin)
{
public final class ExpBoost extends AbstractListener {
public ExpBoost(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void boostExperienceGain(PlayerPickupExperienceEvent event)
{
public void boostExperienceGain(PlayerPickupExperienceEvent event) {
ExperienceOrb orb = event.getExperienceOrb();
int n = orb.getExperience();
int math = (5 * n ^ 2) / (2 * n + 4);
int rounded = Math.round(math);
Player player = event.getPlayer();
Luck luck = plugin.getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("experience", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("experience", luck.getValue())) {
orb.setExperience(rounded);
if (luck.isVerbose())
{
asAudience(player).sendMessage(
MiniComponent.info("Your luck has given you extra experience!"));
}
}
}
}

20
src/main/java/io/github/simplex/luck/listener/GiveDamage.java
View File

@ -8,30 +8,20 @@ import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class GiveDamage extends AbstractListener
{
public GiveDamage(FeelingLucky plugin)
{
public class GiveDamage extends AbstractListener {
public GiveDamage(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void playerAttack(EntityDamageByEntityEvent e)
{
public void playerAttack(EntityDamageByEntityEvent e) {
if ((e.getDamager() instanceof Player player)
&& (e.getEntity() instanceof LivingEntity))
{
&& (e.getEntity() instanceof LivingEntity)) {
double nextDmg = e.getDamage() + Luck.RNG().nextDouble(1.0, 5.0);
Luck luck = plugin.getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("give_damage", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("give_damage", luck.getValue())) {
e.setDamage(nextDmg);
if (luck.isVerbose())
{
asAudience(player).sendMessage(
MiniComponent.info("Your luck gave you a critical hit!"));
}
}
}
}

65
src/main/java/io/github/simplex/luck/listener/HideCheck.java
View File

@ -3,47 +3,58 @@ package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Monster;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerToggleSneakEvent;
public class HideCheck extends AbstractListener
{
public HideCheck(FeelingLucky plugin)
{
import java.util.*;
public class HideCheck extends AbstractListener {
public Map<Player, List<Entity>> entityMapList = new HashMap<>();
public HideCheck(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void checkForSneak(PlayerToggleSneakEvent event)
{
public void initPlayerMaps(PlayerJoinEvent event) {
entityMapList.put(event.getPlayer(), List.of());
}
@EventHandler
public void checkTargeting(EntityTargetLivingEntityEvent event) {
if (event.getTarget() instanceof Player player) {
if (event.getEntity() instanceof LivingEntity entity) {
List<Entity> buffer = entityMapList.get(player).isEmpty() ?
new ArrayList<>() : entityMapList.get(player);
buffer.add(entity);
entityMapList.replace(player, buffer);
}
}
}
@EventHandler
public void checkForSneak(PlayerToggleSneakEvent event) {
Player player = event.getPlayer();
if (player.isSneaking())
return;
if (player.isSneaking()) return;
Luck luck = plugin.getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("hide_check", luck.getValue()))
{
player.getNearbyEntities(25, 25, 25)
.stream()
.filter(e -> e instanceof Monster)
.map(e -> (Monster) e)
.forEach(m ->
{
final LivingEntity target = m.getTarget();
if (target != null && target.getUniqueId().equals(player.getUniqueId()))
{
m.setTarget(null);
}
if (luck.quickRNG(luck.getValue()) && doesQualify("hide_check", luck.getValue())) {
entityMapList.get(player).forEach(e -> {
e.getTrackedPlayers().remove(player);
});
player.sendMessage(MiniComponent.info("Your luck has hidden you from sight."));
}
}
if (luck.isVerbose())
{
asAudience(player).sendMessage(MiniComponent.info("Your luck has hidden you from sight."));
}
}
@EventHandler
public void removePlayerOnLeave(PlayerQuitEvent event) {
entityMapList.remove(event.getPlayer());
}
}

62
src/main/java/io/github/simplex/luck/listener/IllOmen.java
View File

@ -11,92 +11,70 @@ import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class IllOmen extends AbstractListener
{
public IllOmen(FeelingLucky plugin)
{
public class IllOmen extends AbstractListener {
public IllOmen(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void reconnectCheck(PlayerJoinEvent event)
{
public void reconnectCheck(PlayerJoinEvent event) {
Player player = event.getPlayer();
PotionEffectType type = PotionEffectType.BAD_OMEN;
Luck luck = getHandler().getLuckContainer(player);
if (player.hasPotionEffect(type))
{
if (player.hasPotionEffect(type)) {
luck.cache();
double maths = luck.getValue() - (luck.getValue() * 0.25);
luck.setValue(maths);
asAudience(player).sendMessage(MiniComponent.info("A -25% debuff has been applied to your luck from the " +
"Bad Omen " +
"status effect."));
}
else if (luck.cached(player) && !player.hasPotionEffect(type))
{
player.sendMessage(MiniComponent.info("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
} else if (luck.cached(player) && !player.hasPotionEffect(type)) {
luck.restore();
asAudience(player).sendMessage(MiniComponent.info("The -25% debuff to your luck has been removed."));
player.sendMessage("The -25% debuff to your luck has been removed.");
}
}
@EventHandler
public void effectApplyCheck(EntityPotionEffectEvent event)
{
public void effectApplyCheck(EntityPotionEffectEvent event) {
EntityPotionEffectEvent.Cause cause = EntityPotionEffectEvent.Cause.PATROL_CAPTAIN;
EntityPotionEffectEvent.Action added = EntityPotionEffectEvent.Action.ADDED;
EntityPotionEffectEvent.Action changed = EntityPotionEffectEvent.Action.CHANGED;
if (event.getCause().equals(cause) && (event.getAction().equals(added) || event.getAction().equals(changed)))
{
if (event.getEntity() instanceof Player player)
{
if (event.getCause().equals(cause) && (event.getAction().equals(added) || event.getAction().equals(changed))) {
if (event.getEntity() instanceof Player player) {
Luck luck = plugin.getHandler().getLuckContainer(player);
luck.cache();
double maths = luck.getValue() - (luck.getValue() * 0.25);
luck.setValue(maths);
asAudience(player).sendMessage(
MiniComponent.warn("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
player.sendMessage(MiniComponent.warn("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
}
}
}
@EventHandler
public void effectRemoveCheck(EntityPotionEffectEvent event)
{
public void effectRemoveCheck(EntityPotionEffectEvent event) {
PotionEffect old = event.getOldEffect();
EntityPotionEffectEvent.Action cleared = EntityPotionEffectEvent.Action.CLEARED;
EntityPotionEffectEvent.Action removed = EntityPotionEffectEvent.Action.REMOVED;
if (old == null)
return;
if (old == null) return;
if (old.getType().equals(PotionEffectType.BAD_OMEN) && (event.getAction().equals(cleared) || event.getAction()
.equals(
removed)))
{
if ((event.getEntity() instanceof Player player))
{
if (old.getType().equals(PotionEffectType.BAD_OMEN) && (event.getAction().equals(cleared) || event.getAction().equals(removed))) {
if ((event.getEntity() instanceof Player player)) {
Luck luck = plugin.getHandler().getLuckContainer(player);
if (luck.cached(player))
{
if (luck.cached(player)) {
luck.restore();
asAudience(player).sendMessage(MiniComponent.info("The -25% debuff to your luck has been removed."));
player.sendMessage("The -25% debuff to your luck has been removed.");
}
}
}
}
@EventHandler
public void disconnectCheck(PlayerQuitEvent event)
{
if (event.getPlayer().hasPotionEffect(PotionEffectType.BAD_OMEN))
{
public void disconnectCheck(PlayerQuitEvent event) {
if (event.getPlayer().hasPotionEffect(PotionEffectType.BAD_OMEN)) {
Luck luck = plugin.getHandler().getLuckContainer(event.getPlayer());
if (luck.cached(event.getPlayer()))
{
if (luck.cached(event.getPlayer())) {
luck.restore();
}
}

49
src/main/java/io/github/simplex/luck/listener/ItemDrops.java
View File

@ -1,11 +1,7 @@
package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Item;
import org.bukkit.entity.LivingEntity;
@ -16,32 +12,30 @@ import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityDropItemEvent;
import org.bukkit.inventory.ItemStack;
public class ItemDrops extends AbstractListener
{
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class ItemDrops extends AbstractListener {
private final Map<UUID, Player> entityPlayerMap = new HashMap<>();
private boolean canAffect = false;
public ItemDrops(FeelingLucky plugin)
{
public ItemDrops(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void checkForPreItemDrop(EntityDamageByEntityEvent event)
{
if (!(event.getEntity() instanceof LivingEntity entity))
{
public void checkForPreItemDrop(EntityDamageByEntityEvent event) {
if (!(event.getEntity() instanceof LivingEntity entity)) {
return;
}
if (!(event.getDamager() instanceof Player player))
{
if (!(event.getDamager() instanceof Player player)) {
return;
}
if (entity.getHealth() > 0.0)
{
if (!(entity.getHealth() <= 0.0)) {
return;
}
@ -49,10 +43,8 @@ public class ItemDrops extends AbstractListener
}
@EventHandler
public void checkForDroppedItems(EntityDeathEvent event)
{
if (event.getEntity() instanceof Player)
{
public void checkForDroppedItems(EntityDeathEvent event) {
if (event.getEntity() instanceof Player) {
canAffect = false;
return;
}
@ -61,32 +53,23 @@ public class ItemDrops extends AbstractListener
}
@EventHandler
public void itemDrops(EntityDropItemEvent event)
{
public void itemDrops(EntityDropItemEvent event) {
Entity entity = event.getEntity();
if (entityPlayerMap.get(entity.getUniqueId()) == null)
return;
if (entityPlayerMap.get(entity.getUniqueId()) == null) return;
if (!canAffect)
return;
if (!canAffect) return;
Player player = entityPlayerMap.get(entity.getUniqueId());
Luck luck = getHandler().getLuckContainer(player);
Item item = event.getItemDrop();
ItemStack stack = item.getItemStack();
int amount = stack.getAmount();
if (luck.quickRNG(luck.getValue()) && doesQualify("item_drops", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("item_drops", luck.getValue())) {
int rng = Luck.RNG().nextInt(2, 5);
amount += rng;
stack.setAmount(amount);
event.getItemDrop().setItemStack(stack);
if (luck.isVerbose())
{
asAudience(player).sendMessage(MiniComponent.info("Your luck earned you some extra loot!"));
}
}
}
}

6
src/main/java/io/github/simplex/luck/listener/JumpBoost.java
View File

@ -21,11 +21,7 @@ public class JumpBoost extends AbstractListener {
Vector velocity = player.getVelocity().clone();
if (luck.quickRNG(luck.getValue()) && doesQualify("jump_boost", luck.getValue())) {
player.setVelocity(velocity.multiply(2.5));
if (luck.isVerbose()) {
asAudience(player).sendMessage(MiniComponent.info("Your luck gave you an extra boost to your jump!"));
}
player.setVelocity(new Vector(velocity.getX(), velocity.getY() + 3, velocity.getZ()));
}
}
}

61
src/main/java/io/github/simplex/luck/listener/OreVein.java
View File

@ -3,24 +3,17 @@ package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Tag;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBreakEvent;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
import java.util.stream.Stream;
@ApiStatus.Experimental
public class OreVein extends AbstractListener {
public OreVein(FeelingLucky plugin) {
@ -29,49 +22,31 @@ public class OreVein extends AbstractListener {
}
@EventHandler
public void playerMine(@NotNull BlockBreakEvent event) {
public void playerMine(BlockBreakEvent event) {
Player player = event.getPlayer();
Luck luck = plugin.getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("ore_vein", luck.getValue()) && event.getBlock().isValidTool(player.getInventory().getItemInMainHand())) {
Material minedBlockType = event.getBlock().getType();
Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
getOresInArea(event.getBlock(), minedBlockType).forEach(Block::breakNaturally);
getOresInArea(event.getBlock()).forEach(Block::breakNaturally);
player.sendMessage(MiniComponent.info("Your luck has let you mine all the blocks with one swing."));
});
}
}
public Set<Block> getOresInArea(@NotNull Block block, Material minedBlockType) {
Set<Block> blocks = new HashSet<>();
Queue<Block> queue = new LinkedList<>();
Set<Location> visited = new HashSet<>();
Location initialLocation = block.getLocation();
queue.add(block);
visited.add(initialLocation);
while (!queue.isEmpty()) {
Block currentBlock = queue.poll();
Location currentLocation = currentBlock.getLocation();
// Check if the current block is within the maximum radius from the initial block
if (initialLocation.distance(currentLocation) > 16) {
continue;
}
blocks.add(currentBlock);
for (BlockFace face : BlockFace.values()) {
Block neighbour = currentBlock.getRelative(face);
Location neighbourLocation = neighbour.getLocation();
if (!visited.contains(neighbourLocation) && neighbour.getType().equals(minedBlockType)) {
queue.add(neighbour);
visited.add(neighbourLocation);
public Stream<Block> getOresInArea(Block block) {
Stream.Builder<Block> streamBuilder = Stream.builder();
Location start = block.getLocation();
World world = block.getWorld();
Stream<Tag<Material>> materialStream = Stream.of(Tag.COAL_ORES, Tag.COPPER_ORES, Tag.DIAMOND_ORES, Tag.GOLD_ORES, Tag.IRON_ORES, Tag.EMERALD_ORES, Tag.LAPIS_ORES, Tag.REDSTONE_ORES);
for (int x = start.getBlockX() - 15; x <= start.getBlockX() + 15; x++) {
for (int y = start.getBlockY() - 15; y <= start.getBlockY() + 15; y++) {
for (int z = start.getBlockZ() - 15; z <= start.getBlockZ() + 15; z++) {
Location location = new Location(world, x, y, z);
Material blockType = location.getBlock().getType();
if (materialStream.anyMatch(o -> o.isTagged(blockType))) {
streamBuilder.add(location.getBlock());
}
}
}
return blocks;
}
return streamBuilder.build().filter(b -> b.getType().equals(block.getType()));
}
}

11
src/main/java/io/github/simplex/luck/listener/PlayerListener.java
View File

@ -37,16 +37,15 @@ public final class PlayerListener extends AbstractListener {
Luck luck = getHandler().getLuckContainer(player);
if (timer.onCooldown(player)) {
asAudience(player).sendMessage(MiniComponent.err("That feature can only be used once every 30 seconds."));
asAudience(player).sendMessage(MiniComponent.info("You have " + timer.remaining(player) + " seconds " +
"remaining."));
player.sendMessage(MiniComponent.err("That feature can only be used once every 30 seconds."));
player.sendMessage(MiniComponent.info("You have " + timer.remaining(player) + " seconds remaining."));
return;
}
if (action.isRightClick() && player.getInventory().getItemInMainHand().getType().equals(foot.getType())) {
if (foot.getItemMeta().equals(special.meta()) || foot.equals(special.get())) {
luck.setMultiplier(luck.multiplier() + 0.1);
asAudience(player).sendMessage(MiniComponent.info("Your luck multiplier has increased by 0.1!"));
player.sendMessage(MiniComponent.info("Your luck multiplier has increased by 0.1!"));
}
double rng = Luck.RNG().nextDouble(2.0, 5.0);
rng = Math.round(rng);
@ -54,7 +53,7 @@ public final class PlayerListener extends AbstractListener {
luck.addTo(rng);
plugin.getHandler().updatePlayer(player, luck);
timer.setCooldown(player.getUniqueId(), System.currentTimeMillis());
asAudience(player).sendMessage(MiniComponent.info("Your luck has been increased by " + rng + " points."));
player.sendMessage(MiniComponent.info("Your luck has been increased by " + rng + " points."));
}
}
@ -77,7 +76,7 @@ public final class PlayerListener extends AbstractListener {
if (luck.quickRNG(33.0)) {
luck.takeFrom(5.0);
plugin.getHandler().updatePlayer(player, luck);
asAudience(player).sendMessage(MiniComponent.warn("Your luck has been decreased by 5 points!"));
player.sendMessage(MiniComponent.warn("Your luck has been decreased by 5 points!"));
}
}
}

34
src/main/java/io/github/simplex/luck/listener/RandomEffect.java
View File

@ -4,24 +4,22 @@ import io.github.simplex.lib.MiniComponent;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
import io.github.simplex.luck.util.ListBox;
import java.util.List;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.potion.PotionEffect;
public class RandomEffect extends AbstractListener
{
public RandomEffect(FeelingLucky plugin)
{
import java.util.List;
public class RandomEffect extends AbstractListener {
public RandomEffect(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void giveRandomEffect(PlayerRespawnEvent respawn)
{
public void giveRandomEffect(PlayerRespawnEvent respawn) {
Player player = respawn.getPlayer();
Luck luck = plugin.getHandler().getLuckContainer(player);
@ -29,21 +27,14 @@ public class RandomEffect extends AbstractListener
int size = effectList.size();
PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
player.addPotionEffect(random);
if (luck.isVerbose())
{
asAudience(player).sendMessage(
MiniComponent.info("Thanks to luck, a random positive potion effect has " +
"been applied to you."));
}
player.sendMessage(MiniComponent.info("Thanks to luck, a random positive potion effect has been applied to you."));
}
}
@EventHandler
public void giveRandomEffect(PlayerTeleportEvent tp)
{
public void giveRandomEffect(PlayerTeleportEvent tp) {
Player player = tp.getPlayer();
Luck luck = plugin.getHandler().getLuckContainer(player);
@ -51,14 +42,9 @@ public class RandomEffect extends AbstractListener
int size = effectList.size();
PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
player.addPotionEffect(random);
if (luck.isVerbose())
{
asAudience(player).sendMessage(
MiniComponent.info("Thanks to luck, a random positive potion effect has been applied to you."));
}
player.sendMessage(MiniComponent.info("Thanks to luck, a random positive potion effect has been applied to you."));
}
}
}

36
src/main/java/io/github/simplex/luck/listener/RestoreHunger.java
View File

@ -1,6 +1,5 @@
package io.github.simplex.luck.listener;
import io.github.simplex.lib.MiniComponent;
import io.github.simplex.lib.PotionEffectBuilder;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.Luck;
@ -11,44 +10,27 @@ import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class RestoreHunger extends AbstractListener
{
public RestoreHunger(FeelingLucky plugin)
{
public class RestoreHunger extends AbstractListener {
public RestoreHunger(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void restoreHunger(PlayerItemConsumeEvent event)
{
public void restoreHunger(PlayerItemConsumeEvent event) {
ItemStack item = event.getItem();
Luck luck = getHandler().getLuckContainer(event.getPlayer());
PotionEffect effect = PotionEffectBuilder.newEffect()
.type(PotionEffectType.SATURATION)
.amplifier(2)
.duration(10)
.particles(false)
.create();
if (luck.notDefault())
{
PotionEffect effect = PotionEffectBuilder.newEffect().type(PotionEffectType.SATURATION).amplifier(2).duration(10).particles(false).create();
if (luck.notDefault()) {
double percentage = luck.getValue();
ListBox.foods.forEach(food ->
{
if (item.isSimilar(food) && (luck.quickRNG(percentage) && doesQualify(
"restore_hunger", percentage)))
{
ListBox.foods.forEach(food -> {
if (item.isSimilar(food)) {
if (luck.quickRNG(percentage) && doesQualify("restore_hunger", percentage)) {
event.getPlayer().setExhaustion(event.getPlayer().getExhaustion() + 2);
event.getPlayer().addPotionEffect(effect);
}
}
});
if (luck.isVerbose())
{
asAudience(event.getPlayer())
.sendMessage(MiniComponent.info("Your luck has restored your hunger a little more."));
}
}
}
}

15
src/main/java/io/github/simplex/luck/listener/TakeDamage.java
View File

@ -25,7 +25,8 @@ public class TakeDamage extends AbstractListener {
}
Player player = (Player) event.getEntity();
Luck luck = getHandler().getLuckContainer(player);
if (ListBox.acceptedCauses.contains(event.getCause()) && (luck.notDefault())) {
if (ListBox.acceptedCauses.contains(event.getCause())) {
if (luck.notDefault()) {
double percentage = luck.getValue();
/*
@ -37,7 +38,7 @@ public class TakeDamage extends AbstractListener {
if (luck.quickRNG(percentage)) {
event.setCancelled(true);
player.damage(event.getDamage() * 2);
asAudience(player).sendMessage(MiniComponent.warn("You were unlucky and took double damage!"));
player.sendMessage(MiniComponent.warn("You were unlucky and took double damage!"));
}
return;
}
@ -46,10 +47,11 @@ public class TakeDamage extends AbstractListener {
event.setCancelled(true);
player.damage(event.getDamage() / 2);
}
}
}
if (ListBox.sideCauses.contains(event.getCause()) && (luck.notDefault())) {
if (ListBox.sideCauses.contains(event.getCause())) {
if (luck.notDefault()) {
double percentage = luck.getValue();
/*
@ -69,10 +71,9 @@ public class TakeDamage extends AbstractListener {
event.setCancelled(true);
player.getActivePotionEffects().removeIf(p -> ListBox.potionEffects.contains(p.getType()));
player.setFireTicks(0);
asAudience(player).sendMessage(MiniComponent.info("You got lucky and your afflictions were cured" +
"."));
player.sendMessage(MiniComponent.info("You got lucky and your afflictions were cured."));
}
}
}
}
}

27
src/main/java/io/github/simplex/luck/listener/UnbreakableTool.java
View File

@ -11,41 +11,30 @@ import org.bukkit.inventory.CraftingInventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
public class UnbreakableTool extends AbstractListener
{
public UnbreakableTool(FeelingLucky plugin)
{
public class UnbreakableTool extends AbstractListener {
public UnbreakableTool(FeelingLucky plugin) {
super(plugin);
register(this);
}
@EventHandler
public void unbreakableTool(CraftItemEvent event)
{
public void unbreakableTool(CraftItemEvent event) {
CraftingInventory inventory = event.getInventory();
ItemStack stack = inventory.getResult();
if (stack == null)
return;
if (stack == null) return;
ItemMeta meta = stack.getItemMeta();
if (ItemBuilder.isTool(stack.getType()) && (event.getWhoClicked() instanceof Player player))
{
if (ItemBuilder.isTool(stack.getType())) {
if (event.getWhoClicked() instanceof Player player) {
Luck luck = getHandler().getLuckContainer(player);
if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue()))
{
if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue())) {
meta.setUnbreakable(true);
stack.setItemMeta(meta);
inventory.setResult(stack);
if (luck.isVerbose())
{
asAudience(player)
.sendMessage(
MiniComponent.info("By the grace of Luck you have crafted an unbreakable tool!"));
player.sendMessage(MiniComponent.info("By the grace of Luck you have crafted an unbreakable tool!"));
}
}
}
}
}

51
src/main/java/io/github/simplex/luck/player/DynamicConfig.java
View File

@ -1,51 +0,0 @@
package io.github.simplex.luck.player;
import java.util.UUID;
public class DynamicConfig {
private UUID playerUUID;
private String username;
private double luckValue;
private boolean isVerbose;
private double multiplier;
public String getPlayerUUID() {
return playerUUID.toString();
}
public void setPlayerUUID(UUID playerUUID) {
this.playerUUID = playerUUID;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public double getLuckValue() {
return luckValue;
}
public void setLuckValue(double luckValue) {
this.luckValue = luckValue;
}
public boolean isVerbose() {
return isVerbose;
}
public void setVerbose(boolean isVerbose) {
this.isVerbose = isVerbose;
}
public double getMultiplier() {
return multiplier;
}
public void setMultiplier(double multiplier) {
this.multiplier = multiplier;
}
}

58
src/main/java/io/github/simplex/luck/player/Luck.java
View File

@ -4,16 +4,10 @@ import io.github.simplex.api.LuckContainer;
import io.github.simplex.luck.FeelingLucky;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.*;
@SuppressWarnings("all")
public class Luck implements LuckContainer {
@ -25,7 +19,6 @@ public class Luck implements LuckContainer {
private double BASE_VALUE;
private double multiplier;
private double tempSave;
private boolean verbose;
public Luck(FeelingLucky plugin, Player player) {
this(plugin, player, 1.0);
@ -41,16 +34,10 @@ public class Luck implements LuckContainer {
event = new PlayerLuckChangeEvent(this);
}
/**
* This creates a new instance of a pseudorandom number generator based off entropy provided by the operating system.
* This will allow for a much purer randomization, due to entropy being different for each call.
*
* @return A new instance of SecureRandom. Each time this method is called a new instance is created to provide maximum variation with entropic calculations.
*/
@Contract(pure = true,
value = "-> new")
public static @NotNull SecureRandom RNG() {
return new SecureRandom(SecureRandom.getSeed(20));
public static @NotNull SplittableRandom RNG() {
return new SplittableRandom();
}
public static boolean quickRNGnoMultiplier(double value) {
@ -66,10 +53,6 @@ public class Luck implements LuckContainer {
return (value >= actual);
}
public boolean playerHasLuckPE() {
return player.hasPotionEffect(PotionEffectType.LUCK);
}
public FeelingLucky getPlugin() {
return plugin;
}
@ -86,23 +69,6 @@ public class Luck implements LuckContainer {
return markedPlayers.contains(player);
}
@Override
public void setVerbose(final boolean verbose) {
if (!plugin.getConfig().isVerboseGlobal())
return;
this.verbose = verbose;
}
@Override
public boolean isVerbose() {
if (plugin.getConfig().isVerboseGlobal()) {
return verbose;
}
return false;
}
@Override
public boolean isMatch(double number) {
return getValue() == number;
@ -123,12 +89,6 @@ public class Luck implements LuckContainer {
return player;
}
/**
* Quickly calculate whether or not the player has enough luck to trigger the condition.
*
* @param value The players luck value.
* @return True if the player meets the criteria, false if they do not.
*/
public boolean quickRNG(double value) {
double rng;
if (value >= 1024.0) {
@ -137,19 +97,13 @@ public class Luck implements LuckContainer {
rng = RNG().nextDouble(0.0, 1024.0);
}
AtomicReference<Double> multiplier = new AtomicReference<>(multiplier());
double actual = Math.round((rng / 1024) * 100);
double newVal = Math.round((value / 1024) * 100);
if (playerHasLuckPE()) {
player.getActivePotionEffects()
.stream()
.filter(p -> p.getType().equals(PotionEffectType.LUCK))
.findFirst()
.ifPresent(p -> multiplier.updateAndGet(v -> (v + p.getAmplifier())));
if (multiplier() > 1.0) {
return ((value * multiplier()) >= actual);
}
return ((newVal * multiplier.get()) >= actual);
return (value >= actual);
}
public void reset() {

215
src/main/java/io/github/simplex/luck/player/PlayerConfig.java
View File

@ -1,209 +1,106 @@
package io.github.simplex.luck.player;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.util.Logs;
import java.io.File;
import java.io.IOException;
import java.util.UUID;
import io.github.simplex.luck.util.SneakyWorker;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.attribute.Attribute;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
public class PlayerConfig
{
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
public class PlayerConfig {
private final File configFile;
private final OfflinePlayer player;
private final FeelingLucky plugin;
private YamlConfiguration config;
private volatile YamlConfiguration config;
public PlayerConfig(FeelingLucky plugin, Player player)
{
this.plugin = plugin;
@SuppressWarnings("ResultOfMethodCallIgnored")
public PlayerConfig(FeelingLucky plugin, Player player) {
this.player = player;
configFile = configFile(plugin, player);
if (!plugin.getDataFolder().exists()) plugin.getDataFolder().mkdirs();
File dataFolder = new File(plugin.getDataFolder(), "players");
if (!dataFolder.exists()) dataFolder.mkdirs();
File file = new File(dataFolder, player.getUniqueId() + ".yml");
if (!file.exists()) {
String name = "username: " + player.getName();
String luck = "luck: " + 0;
String multiplier = "multiplier: " + 1.0;
SneakyWorker.sneakyTry(() -> {
file.createNewFile();
BufferedWriter writer = new BufferedWriter(new FileWriter(file, StandardCharsets.UTF_8));
writer.write(name);
writer.newLine();
writer.write(luck);
writer.newLine();
writer.write(multiplier);
writer.close();
});
}
configFile = file;
config = YamlConfiguration.loadConfiguration(configFile);
String tempUsername = config.getString("username");
if (tempUsername == null)
{
if (tempUsername == null) {
config.set("username", player.getName());
config.set("luck", plugin.getHandler().getLuckContainer(player).getDefaultValue());
config.set("multiplier", "1.0");
config.set("verbose", plugin.getConfig().isVerboseGlobal());
save();
}
}
protected PlayerConfig(FeelingLucky plugin, File file)
{
this.plugin = plugin;
protected PlayerConfig(FeelingLucky plugin, File file) {
this.configFile = file;
this.player = Bukkit.getOfflinePlayer(UUID.fromString(file.getName().split("\\.")[0]));
config = YamlConfiguration.loadConfiguration(configFile);
}
protected PlayerConfig(FeelingLucky plugin, DynamicConfig user)
{
this.plugin = plugin;
this.player = Bukkit.getOfflinePlayer(UUID.fromString(user.getPlayerUUID()));
configFile = configFile(plugin, player);
config = YamlConfiguration.loadConfiguration(configFile);
}
@Contract("_, _ -> new")
public static PlayerConfig initFromFile(FeelingLucky plugin, File file)
{
public static PlayerConfig initFrom(FeelingLucky plugin, File file) {
return new PlayerConfig(plugin, file);
}
public static PlayerConfig fromDynamicConfig(FeelingLucky plugin, DynamicConfig config)
{
PlayerConfig playerConfig = new PlayerConfig(plugin, config);
playerConfig.setUsername(config.getPlayerUUID());
playerConfig.setLuck(config.getLuckValue());
playerConfig.setMultiplier(config.getMultiplier());
playerConfig.setVerbose(config.isVerbose());
return playerConfig;
public void save() {
SneakyWorker.sneakyTry(() -> config.save(configFile));
}
public DynamicConfig toDynamicConfig()
{
DynamicConfig dynamicConfig = new DynamicConfig();
dynamicConfig.setPlayerUUID(player.getUniqueId());
dynamicConfig.setLuckValue(getLuck());
dynamicConfig.setVerbose(isVerbose());
dynamicConfig.setMultiplier(getMultiplier());
return dynamicConfig;
public void load() {
SneakyWorker.sneakyTry(() -> config = YamlConfiguration.loadConfiguration(configFile));
}
@SuppressWarnings("ResultOfMethodCallIgnored")
@NotNull
private File configFile(FeelingLucky plugin, OfflinePlayer player)
{
if (!plugin.getDataFolder().exists())
plugin.getDataFolder().mkdirs();
File dataFolder = new File(plugin.getDataFolder(), "players");
if (!dataFolder.exists())
dataFolder.mkdirs();
File file = new File(dataFolder, player.getUniqueId() + ".yml");
if (!file.exists())
{
try
{
file.createNewFile();
final YamlConfiguration v0 = new YamlConfiguration();
v0.set("username", player.getName());
v0.set("luck", 0);
v0.set("multiplier", 1.0);
v0.set("verbose", plugin.getConfig().isVerboseGlobal());
v0.save(file);
}
catch (IOException ex)
{
Logs.error(ex);
}
}
return file;
}
public void save()
{
try
{
config.save(configFile);
}
catch (IOException ex)
{
Logs.error(ex);
}
}
public void load()
{
try
{
config.load(configFile);
}
catch (IOException | InvalidConfigurationException ex)
{
Logs.error(ex);
Logs.warn("Attempting to reinitialize variable... this is dangerous!");
try
{
config = YamlConfiguration.loadConfiguration(configFile);
}
catch (IllegalArgumentException th)
{
Logs.error(th);
}
}
}
public void reload()
{
public void reload() {
save();
load();
}
public OfflinePlayer getPlayer()
{
public OfflinePlayer getPlayer() {
return player;
}
public String getUsername() {
return config.getString("username");
}
public double getLuck()
{
return config.getDouble("luck");
}
public void setLuck(double luck)
{
config.set("luck", luck);
reload();
}
public double getMultiplier()
{
return config.getDouble("multiplier");
}
public void setMultiplier(double multiplier)
{
config.set("multiplier", multiplier);
reload();
}
public boolean isVerbose()
{
return config.getBoolean("verbose");
}
public void setVerbose(final boolean verbose)
{
config.set("verbose", verbose);
reload();
}
public void setUsername(String name)
{
public void setUsername(String name) {
config.set("username", name);
reload();
save();
}
public YamlConfiguration getConfig()
{
public void setLuck(double luck) {
config.set("luck", luck);
save();
}
public void setMultiplier(double multiplier) {
config.set("multiplier", multiplier);
save();
}
public YamlConfiguration getConfig() {
return config;
}
}

9
src/main/java/io/github/simplex/luck/player/PlayerHandler.java
View File

@ -1,7 +1,6 @@
package io.github.simplex.luck.player;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.sql.SQLType;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -39,10 +38,9 @@ public class PlayerHandler implements Listener {
plugin.getConfigMap().put(player.getUniqueId(), playerConfig);
}
String username = playerConfig.getUsername();
double luck = playerConfig.getLuck();
double multiplier = playerConfig.getMultiplier();
boolean verbose = plugin.getConfig().isVerboseGlobal() && playerConfig.isVerbose();
String username = playerConfig.getConfig().getString("username");
double luck = playerConfig.getConfig().getDouble("luck");
double multiplier = playerConfig.getConfig().getDouble("multiplier");
if (!player.getName().equalsIgnoreCase(username)) {
playerConfig.getConfig().set("username", player.getName());
@ -51,7 +49,6 @@ public class PlayerHandler implements Listener {
}
Luck container = new Luck(plugin, player, multiplier);
container.setVerbose(verbose);
container.setValue(luck);
playerLuckMap.put(player, container);

52
src/main/java/io/github/simplex/luck/util/Logs.java
View File

@ -1,52 +0,0 @@
package io.github.simplex.luck.util;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Logs
{
private static final Logger logger = LoggerFactory.getLogger("FeelingLucky");
private Logs()
{
throw new AssertionError();
}
public static void info(String message)
{
logger.info(message);
}
public static void warn(String message)
{
logger.warn(message);
}
public static void warn(String message, Throwable th)
{
logger.warn(message, th);
}
public static void warn(Throwable th)
{
final String msg = ExceptionUtils.getRootCauseMessage(th);
logger.warn(msg);
}
public static void error(String message)
{
logger.error(message);
}
public static void error(String message, Throwable th)
{
logger.error(message, th);
}
public static void error(Throwable th)
{
final String msg = ExceptionUtils.getRootCauseMessage(th);
logger.error(msg, th);
}
}

17
src/main/java/io/github/simplex/luck/util/LuckCMD.java
View File

@ -114,23 +114,6 @@ public class LuckCMD extends Command implements TabCompleter, PluginIdentifiable
return true;
}
if (args[0].equalsIgnoreCase("verbose") && sender instanceof Player player) {
if (!plugin.getConfig().isVerboseGlobal()) {
player.sendMessage(Messages.VERBOSE_DISABLED.get());
return true;
}
final boolean a1 = Boolean.parseBoolean(args[1]);
Luck luck = plugin.getHandler().getLuckContainer(player);
PlayerConfig config = plugin.getConfigMap().get(player.getUniqueId());
luck.setVerbose(a1);
plugin.getHandler().updatePlayer(player, luck);
config.setVerbose(a1);
sender.sendMessage(MiniComponent.info("Verbose mode set to " + a1 + "."));
return true;
}
if (args[0].equalsIgnoreCase("reset")) {
Player player = Bukkit.getPlayer(args[1]);

2
src/main/java/io/github/simplex/luck/util/SneakyWorker.java
View File

@ -21,7 +21,7 @@ public class SneakyWorker {
+ ex.getClass().getSimpleName()
+ " has occurred. A cause will be printed. \n\n"
+ ex.getCause();
Logs.error(sb);
Bukkit.getLogger().severe(sb);
}
}

94
src/main/java/io/github/simplex/sql/MySQL.java
View File

@ -1,94 +0,0 @@
package io.github.simplex.sql;
import io.github.simplex.luck.Config;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.DynamicConfig;
import io.github.simplex.luck.player.PlayerConfig;
import io.github.simplex.luck.util.Logs;
import io.github.simplex.sql.users.MySQLUser;
import java.sql.*;
import java.util.UUID;
public class MySQL {
private final Connection connection;
private final FeelingLucky plugin;
public MySQL(FeelingLucky plugin) throws SQLException {
this.plugin = plugin;
Config.MySQLWrapper mySQLWrapper = plugin.getConfig().getMySQL();
String host = mySQLWrapper.getHost();
int port = mySQLWrapper.getPort();
String database = mySQLWrapper.getDatabase();
String username = mySQLWrapper.getUsername();
String password = mySQLWrapper.getPassword();
connection = DriverManager.getConnection("jdbc:mysql://" + host + ":" + port + "/" + database, username, password);
if (connection != null) {
try (PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS PlayerConfig (playerUUID VARCHAR(36), username VARCHAR(16), luckValue DOUBLE, isVerbose BOOLEAN, multiplier DOUBLE)")) {
statement.execute();
}
}
}
public Connection getConnection() {
return connection;
}
public void loadPlayers() {
try (PreparedStatement statement = connection.prepareStatement("SELECT * FROM PlayerConfig");
ResultSet resultSet = statement.executeQuery()) {
while (resultSet.next()) {
String playerUUID = resultSet.getString("playerUUID");
MySQLUser mySQLUser = new MySQLUser(connection, UUID.fromString(playerUUID));
DynamicConfig userConfig = mySQLUser.loadUserConfig();
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
plugin.getConfigMap().put(UUID.fromString(playerUUID), playerConfig);
}
} catch (SQLException e) {
Logs.error(e);
}
}
public void savePlayer(final PlayerConfig playerConfig) {
MySQLUser mySQLUser = new MySQLUser(connection, playerConfig.getPlayer().getUniqueId());
mySQLUser.saveUserConfig(playerConfig.toDynamicConfig());
}
public void loadPlayer(final UUID playerUUID) {
try (PreparedStatement statement = connection.prepareStatement("SELECT * FROM PlayerConfig WHERE playerUUID = ?")) {
statement.setString(1, playerUUID.toString());
try (ResultSet resultSet = statement.executeQuery()) {
if (resultSet.next()) {
MySQLUser mySQLUser = new MySQLUser(connection, playerUUID);
DynamicConfig userConfig = mySQLUser.loadUserConfig();
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
plugin.getConfigMap().put(playerUUID, playerConfig);
}
}
} catch (SQLException e) {
Logs.error(e);
}
}
public void savePlayers() {
for (UUID playerUUID : plugin.getConfigMap().keySet()) {
PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
MySQLUser mySQLUser = new MySQLUser(connection, playerUUID);
mySQLUser.saveUserConfig(playerConfig.toDynamicConfig());
}
}
public void closeConnection() {
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
Logs.error(e);
}
}
}
}

77
src/main/java/io/github/simplex/sql/Redis.java
View File

@ -1,77 +0,0 @@
package io.github.simplex.sql;
import io.github.simplex.luck.Config;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.DynamicConfig;
import io.github.simplex.luck.player.PlayerConfig;
import io.github.simplex.sql.users.RedisUser;
import java.util.Set;
import java.util.UUID;
public class Redis {
private final redis.clients.jedis.Jedis jedis;
private final FeelingLucky plugin;
public Redis(final FeelingLucky plugin) {
this.plugin = plugin;
final Config.RedisWrapper redisWrapper = plugin.getConfig().getRedis();
final String host = redisWrapper.getHost();
final String password = redisWrapper.getPassword();
final String port = redisWrapper.getPort();
final int database = redisWrapper.getDatabase();
jedis = new redis.clients.jedis.Jedis(host, Integer.parseInt(port));
jedis.auth(password);
jedis.select(database);
}
public redis.clients.jedis.Jedis getJedis() {
return jedis;
}
public void closeConnection() {
jedis.close();
}
public void loadPlayers() {
Set<String> playerUUIDs = jedis.keys("*");
for (String playerUUID : playerUUIDs) {
RedisUser redisUser = new RedisUser(jedis, UUID.fromString(playerUUID));
DynamicConfig userConfig = redisUser.loadUserConfig();
// Create a new PlayerConfig instance with the loaded data
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
// Add the PlayerConfig instance to the map
plugin.getConfigMap().put(UUID.fromString(playerUUID), playerConfig);
}
}
public void savePlayers() {
for (UUID playerUUID : plugin.getConfigMap().keySet()) {
PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
RedisUser redisUser = new RedisUser(jedis, playerUUID);
redisUser.saveUserConfig(playerConfig.toDynamicConfig());
}
}
public void loadPlayer(UUID playerUUID) {
RedisUser redisUser = new RedisUser(jedis, playerUUID);
DynamicConfig userConfig = redisUser.loadUserConfig();
// Create a new PlayerConfig instance with the loaded data
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
// Add the PlayerConfig instance to the map
plugin.getConfigMap().put(playerUUID, playerConfig);
}
public void savePlayer(UUID playerUUID) {
PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
RedisUser redisUser = new RedisUser(jedis, playerUUID);
redisUser.saveUserConfig(playerConfig.toDynamicConfig());
}
}

17
src/main/java/io/github/simplex/sql/SQLType.java
View File

@ -1,17 +0,0 @@
package io.github.simplex.sql;
public enum SQLType {
SQLITE,
MYSQL,
REDIS,
NONE;
public static SQLType fromString(String type) {
return switch (type.toLowerCase()) {
case "sqlite" -> SQLITE;
case "mysql" -> MYSQL;
case "redis" -> REDIS;
default -> NONE;
};
}
}

83
src/main/java/io/github/simplex/sql/SQLite.java
View File

@ -1,83 +0,0 @@
package io.github.simplex.sql;
import io.github.simplex.luck.FeelingLucky;
import io.github.simplex.luck.player.DynamicConfig;
import io.github.simplex.luck.player.PlayerConfig;
import io.github.simplex.luck.util.Logs;
import io.github.simplex.sql.users.SQLiteUser;
import java.sql.*;
import java.util.UUID;
public class SQLite {
private final Connection connection;
private final FeelingLucky plugin;
public SQLite(final FeelingLucky plugin) throws SQLException {
this.plugin = plugin;
final String databaseFilePath = plugin.getConfig().getSQLite().getPath();
connection = DriverManager.getConnection("jdbc:sqlite:" + databaseFilePath);
if (connection != null) createTable();
}
public Connection getConnection() {
return connection;
}
public void closeConnection() throws SQLException {
if (connection != null) {
connection.close();
}
}
public void createTable() throws SQLException {
try (PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS PlayerConfig (playerUUID VARCHAR(36), username VARCHAR(16), luckValue DOUBLE, isVerbose BOOLEAN, multiplier DOUBLE)")) {
statement.execute();
}
}
public void loadPlayers() throws SQLException {
try (PreparedStatement statement = connection.prepareStatement("SELECT playerUUID FROM PlayerConfig");
ResultSet resultSet = statement.executeQuery()) {
while (resultSet.next()) {
UUID playerUUID = UUID.fromString(resultSet.getString("playerUUID"));
SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
DynamicConfig userConfig = sqliteUser.loadUserConfig();
// Create a new PlayerConfig instance with the loaded data
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
// Add the PlayerConfig instance to the map
plugin.getConfigMap().put(playerUUID, playerConfig);
}
}
}
public void savePlayers() throws SQLException {
for (UUID playerUUID : plugin.getConfigMap().keySet()) {
PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
sqliteUser.saveUserConfig(playerConfig.toDynamicConfig());
}
}
public void loadPlayer(UUID playerUUID) throws SQLException {
SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
DynamicConfig userConfig = sqliteUser.loadUserConfig();
// Create a new PlayerConfig instance with the loaded data
PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
// Add the PlayerConfig instance to the map
plugin.getConfigMap().put(playerUUID, playerConfig);
}
public void savePlayer(UUID playerUUID) throws SQLException {
PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
sqliteUser.saveUserConfig(playerConfig.toDynamicConfig());
}
}

67
src/main/java/io/github/simplex/sql/users/MySQLUser.java
View File

@ -1,67 +0,0 @@
package io.github.simplex.sql.users;
import io.github.simplex.luck.player.DynamicConfig;
import io.github.simplex.luck.util.Logs;
import org.bukkit.Bukkit;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.UUID;
public class MySQLUser {
private final Connection connection;
private final String playerUUID;
public MySQLUser(Connection connection, UUID playerUUID) {
this.connection = connection;
this.playerUUID = playerUUID.toString();
}
public DynamicConfig loadUserConfig() {
DynamicConfig config = new DynamicConfig();
try {
PreparedStatement statement = connection.prepareStatement(
"SELECT * FROM PlayerConfig WHERE playerUUID = ?"
);
statement.setString(1, playerUUID);
ResultSet resultSet = statement.executeQuery();
if (resultSet.next()) {
config.setPlayerUUID(UUID.fromString(resultSet.getString("uuid")));
config.setUsername(Bukkit.getOfflinePlayer(UUID.fromString(resultSet.getString("uuid"))).getName());
config.setLuckValue(resultSet.getInt("luckValue"));
config.setVerbose(resultSet.getBoolean("isVerbose"));
config.setMultiplier(resultSet.getDouble("multiplier"));
}
} catch (SQLException e) {
Logs.error(e);
}
return config;
}
public void saveUserConfig(DynamicConfig config) {
try {
PreparedStatement statement = connection.prepareStatement(
"INSERT INTO PlayerConfig (playerUUID, username, luckValue, isVerbose, multiplier) VALUES (?, ?, ?, ?, ?) " +
"ON DUPLICATE KEY UPDATE username = ?, luckValue = ?, isVerbose = ?, multiplier = ?"
);
statement.setString(1, playerUUID);
statement.setString(2, config.getUsername());
statement.setDouble(3, config.getLuckValue());
statement.setBoolean(4, config.isVerbose());
statement.setDouble(5, config.getMultiplier());
statement.setString(6, config.getUsername());
statement.setDouble(7, config.getLuckValue());
statement.setBoolean(8, config.isVerbose());
statement.setDouble(9, config.getMultiplier());
statement.executeUpdate();
} catch (SQLException e) {
Logs.error(e);
}
}
}

37
src/main/java/io/github/simplex/sql/users/RedisUser.java
View File

@ -1,37 +0,0 @@
package io.github.simplex.sql.users;
import io.github.simplex.luck.player.DynamicConfig;
import org.bukkit.Bukkit;
import redis.clients.jedis.Jedis;
import java.util.UUID;
public class RedisUser {
private final Jedis jedis;
private final String playerUUID;
public RedisUser(Jedis jedis, UUID playerUUID) {
this.jedis = jedis;
this.playerUUID = playerUUID.toString();
}
public DynamicConfig loadUserConfig() {
DynamicConfig config = new DynamicConfig();
config.setPlayerUUID(UUID.fromString(jedis.hget(playerUUID, "uuid")));
config.setUsername(Bukkit.getOfflinePlayer(UUID.fromString(jedis.hget(playerUUID, "username"))).getName());
config.setLuckValue(Integer.parseInt(jedis.hget(playerUUID, "luckValue")));
config.setVerbose(Boolean.parseBoolean(jedis.hget(playerUUID, "isVerbose")));
config.setMultiplier(Double.parseDouble(jedis.hget(playerUUID, "multiplier")));
return config;
}
public void saveUserConfig(DynamicConfig config) {
jedis.hset(playerUUID, "uuid", config.getPlayerUUID());
jedis.hset(playerUUID, "username", config.getUsername());
jedis.hset(playerUUID, "luckValue", String.valueOf(config.getLuckValue()));
jedis.hset(playerUUID, "isVerbose", String.valueOf(config.isVerbose()));
jedis.hset(playerUUID, "multiplier", String.valueOf(config.getMultiplier()));
}
}

65
src/main/java/io/github/simplex/sql/users/SQLiteUser.java
View File

@ -1,65 +0,0 @@
package io.github.simplex.sql.users;
import io.github.simplex.luck.player.DynamicConfig;
import io.github.simplex.luck.util.Logs;
import org.bukkit.Bukkit;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.UUID;
public class SQLiteUser {
private final Connection connection;
private final String playerUUID;
public SQLiteUser(Connection connection, UUID playerUUID) {
this.connection = connection;
this.playerUUID = playerUUID.toString();
}
public DynamicConfig loadUserConfig() {
DynamicConfig config = new DynamicConfig();
try {
PreparedStatement statement = connection.prepareStatement(
"SELECT * FROM PlayerConfig WHERE playerUUID = ?"
);
statement.setString(1, playerUUID);
ResultSet resultSet = statement.executeQuery();
if (resultSet.next()) {
config.setPlayerUUID(UUID.fromString(resultSet.getString("playerUUID")));
config.setUsername(
Bukkit.getOfflinePlayer(
UUID.fromString(
resultSet.getString("playerUUID")))
.getName());
config.setLuckValue(resultSet.getDouble("luckValue"));
config.setVerbose(resultSet.getBoolean("isVerbose"));
config.setMultiplier(resultSet.getDouble("multiplier"));
}
} catch (SQLException e) {
Logs.error(e);
}
return config;
}
public void saveUserConfig(DynamicConfig config) {
try {
PreparedStatement statement = connection.prepareStatement(
"INSERT INTO PlayerConfig (playerUUID, username, luckValue, isVerbose, multiplier) VALUES (?, ?, ?, ?, ?)"
);
statement.setString(1, playerUUID);
statement.setString(2, config.getUsername());
statement.setDouble(3, config.getLuckValue());
statement.setBoolean(4, config.isVerbose());
statement.setDouble(5, config.getMultiplier());
statement.executeUpdate();
} catch (SQLException e) {
Logs.error(e);
}
}
}

34
src/main/resources/config.yml
View File

@ -8,19 +8,14 @@ high_rarity_chance: 512.0
medium_rarity_chance: 128.0
low_rarity_chance: 64.0
# Change whether verbosity is enabled globally or not.
# If the verbosity is set to true, then all players will have the option to turn it off for themselves only.
# If the verbosity is set to false, then players will not have the option to turn it on.
global_verbosity: true
# The following entries are for the rarity level of each event trigger.
# This will determine which rarity chance to use which ensures players
# The following values are accepted: NONE, LOW, MED, HIGH
#- None implies that there is no rarity chance attributed to that feature.
# - None implies that there is no rarity chance attributed to that feature.
# These entries are case-sensitive.
block_drops: LOW
bone_meal: MED
bonemeal: MED
cheat_death: MED
enchanting: HIGH
experience: HIGH
@ -33,28 +28,3 @@ random_effect: HIGH
restore_hunger: NONE
take_damage: MED
unbreakable: HIGH
# This section is for Database storage.
# If you wish to use a database, you must fill out the following information.
#database_types: MYSQL, SQLITE, REDIS, NONE
database_type: NONE
# MySQL Database
mysql:
host: localhost
port: 3306
database: minecraft
username: root
password: password
# SQLite Database
sqlite:
path: database.db
# Redis Database
redis:
host: localhost
port: 6379
password: password
database: 0