mirrors/BetterRTP
1
0
Fork 0
mirror of https://github.com/RonanPlugins/BetterRTP.git synced 2025-08-17 09:05:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

cooldowns saved to database

Browse Source
This commit is contained in:
SuperRonanCraft 2021-09-24 21:31:14 -04:00
parent 9499d36482
commit 86bf26535e
3 changed files with 78 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pom.xml
View File

@ -103,6 +103,14 @@
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>9</source>
<target>9</target>
</configuration>
</plugin>
</plugins>
</build>

64
src/main/java/me/SuperRonanCraft/BetterRTP/player/rtp/RTPCooldown.java
View File

@ -1,6 +1,7 @@
package me.SuperRonanCraft.BetterRTP.player.rtp;
import lombok.Getter;
import me.SuperRonanCraft.BetterRTP.references.database.DatabaseCooldowns;
import me.SuperRonanCraft.BetterRTP.references.file.FileBasics;
import me.SuperRonanCraft.BetterRTP.BetterRTP;
import org.bukkit.configuration.InvalidConfigurationException;
@ -9,29 +10,32 @@ import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
public class RTPCooldown {
private final HashMap<UUID, Long> cooldowns = new HashMap<>(); //Cooldown timer for each player
private HashMap<UUID, Integer> locked = null; //Players locked from rtp'ing ever again
private HashMap<UUID, Integer> uses = null; //Players locked from rtp'ing ever again
private final DatabaseCooldowns database = new DatabaseCooldowns();
@Getter boolean enabled;
private int
timer, //Cooldown timer
lockedAfter; //Rtp's before being locked
public void load() {
configfile = new File(BetterRTP.getInstance().getDataFolder(), "data/cooldowns.yml");
database.load();
//configfile = new File(BetterRTP.getInstance().getDataFolder(), "data/cooldowns.yml");
cooldowns.clear();
if (locked != null)
locked.clear();
if (uses != null)
uses.clear();
FileBasics.FILETYPE config = FileBasics.FILETYPE.CONFIG;
enabled = config.getBoolean("Settings.Cooldown.Enabled");
if (enabled) {
timer = config.getInt("Settings.Cooldown.Time");
lockedAfter = config.getInt("Settings.Cooldown.LockAfter");
if (lockedAfter > 0)
locked = new HashMap<>();
uses = new HashMap<>();
}
}
@ -39,11 +43,11 @@ public class RTPCooldown {
if (!enabled) return;
cooldowns.put(id, System.currentTimeMillis());
if (lockedAfter > 0) {
if (locked.containsKey(id))
locked.put(id, locked.get(id) + 1);
if (uses.containsKey(id))
uses.put(id, uses.get(id) + 1);
else
locked.put(id, 1);
savePlayer(id, true, cooldowns.get(id), locked.get(id));
uses.put(id, 1);
savePlayer(id, true, cooldowns.get(id), uses.get(id));
} else
savePlayer(id, true, cooldowns.get(id), 0);
}
@ -58,19 +62,19 @@ public class RTPCooldown {
}
public boolean locked(UUID id) {
if (locked != null && locked.containsKey(id))
return locked.get(id) >= lockedAfter;
if (uses != null && uses.containsKey(id))
return uses.get(id) >= lockedAfter;
return false;
}
public void removeCooldown(UUID id) {
if (!enabled) return;
if (lockedAfter > 0) {
locked.put(id, locked.getOrDefault(id, 1) - 1);
if (locked.get(id) <= 0) { //Remove from file as well
uses.put(id, uses.getOrDefault(id, 1) - 1);
if (uses.get(id) <= 0) { //Remove from file as well
savePlayer(id, false, 0L, 0);
} else { //Keep the player cached
savePlayer(id, false, cooldowns.get(id), locked.get(id));
savePlayer(id, false, cooldowns.get(id), uses.get(id));
}
cooldowns.remove(id);
} else { //Remove completely
@ -79,8 +83,13 @@ public class RTPCooldown {
}
}
private void savePlayer(UUID id, boolean adding, long time, int attempts) {
YamlConfiguration config = getFile();
private void savePlayer(UUID uuid, boolean adding, long time, int attempts) {
if (adding) {
database.setCooldown(uuid, time, attempts);
} else {
database.removePlayer(uuid);
}
/*YamlConfiguration config = getFile();
if (config == null) {
BetterRTP.getInstance().getLogger().severe("Unabled to save cooldown for the players UUID " + id
+ ". Cooldown file might have been compromised!");
@ -97,12 +106,12 @@ public class RTPCooldown {
config.save(configfile);
} catch (IOException e) {
e.printStackTrace();
}
}*/
}
private File configfile;
/*private File configfile;
private YamlConfiguration getFile() {
/*private YamlConfiguration getFile() {
if (!configfile.exists()) {
try {
configfile.getParentFile().mkdir();
@ -119,11 +128,16 @@ public class RTPCooldown {
e.printStackTrace();
}
return null;
}
}*/
public void loadPlayer(UUID uuid) {
if (isEnabled()) {
String id = uuid.toString();
List<Object> data = database.getCooldown(uuid);
if (data != null) {
cooldowns.put(uuid, (Long) data.get(0));
uses.put(uuid, (int) data.get(1));
}
/*String id = uuid.toString();
YamlConfiguration config = getFile();
if (config != null && config.isConfigurationSection(id))
try {
@ -131,18 +145,18 @@ public class RTPCooldown {
cooldowns.put(uuid, time);
if (lockedAfter > 0) {
int attempts = config.getInt(id + ".Attempts");
locked.put(uuid, attempts);
uses.put(uuid, attempts);
}
} catch (IllegalArgumentException e) {
BetterRTP.getInstance().getLogger().info("UUID of `" + id + "` is invalid, please delete this!");
//Bad uuid
}
}*/
}
}
public void unloadPlayer(UUID uuid) {
cooldowns.remove(uuid);
if (locked != null)
locked.remove(uuid);
if (uses != null)
uses.remove(uuid);
}
}

203
src/main/java/me/SuperRonanCraft/BetterRTP/references/database/DatabaseCooldowns.java
View File

@ -1,20 +1,14 @@
package me.SuperRonanCraft.BetterRTP.references.database;
import me.ronancraft.AmethystGear.AmethystGear;
import me.ronancraft.AmethystGear.resources.gear.ELEMENT_TYPE;
import me.ronancraft.AmethystGear.resources.gear.GEAR_TIER;
import me.ronancraft.AmethystGear.resources.gear.GEAR_TYPE;
import me.ronancraft.AmethystGear.resources.gear.catalysts.Catalyst;
import me.ronancraft.AmethystGear.resources.gear.gear.GearBaseInfo;
import me.ronancraft.AmethystGear.resources.gear.gear.GearData;
import me.ronancraft.AmethystGear.resources.helpers.HelperDate;
import me.ronancraft.AmethystGear.resources.helpers.HelperJsonConverter;
import org.bukkit.entity.Player;
import me.SuperRonanCraft.BetterRTP.BetterRTP;
import java.sql.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import java.util.logging.Level;
public class DatabaseCooldowns extends SQLite {
@ -24,22 +18,10 @@ public class DatabaseCooldowns extends SQLite {
}
public enum COLUMNS {
INDEX("id", "integer PRIMARY KEY AUTOINCREMENT"),
UUID("owner", "varchar(32)"),
//GEAR INFO
GEAR_TIER("gear_tier", "text DEFAULT 'BRONZE'"),
GEAR_LEVEL("level", "integer DEFAULT 1"),
GEAR_XP("xp", "integer DEFAULT 0"),
GEAR_CATALYST("catalyst", "text DEFAULT NULL"),
GEAR_TRACKER("trackers", "text DEFAULT NULL"), //Trackers stored in json
//BASIC GEAR INFO
IDENTIFIER("identifier", "varchar(32)"),
BASE_TIER("base_tier", "text DEFAULT 'BRONZE'"),
BASE_ELEMENT("base_element", "text DEFAULT 'WATER'"),
BASE_TYPE("base_type", "text DEFAULT 'SWORD'"),
//MISC
DATE_ACQUIRED("date_acquired", "text DEFAULT 'N/A'"),
FAVORITE("favorite", "boolean DEFAULT false"),
UUID("uuid", "varchar(32) PRIMARY KEY"),
//COOLDOWN DATA
COOLDOWN_DATE("date", "long"),
USES("uses", "integer"),
;
public String name;
@ -51,175 +33,52 @@ public class DatabaseCooldowns extends SQLite {
}
}
public boolean removeGear(GearData gear) {
public boolean removePlayer(UUID uuid) {
String sql = "DELETE FROM " + table + " WHERE "
+ COLUMNS.INDEX.name + " = ?";
+ COLUMNS.UUID.name + " = ?";
List<Object> params = new ArrayList<>() {{
add(gear.getDatabase_id());
add(uuid.toString());
}};
return sqlUpdate(sql, params);
}
public boolean removeGear(List<GearData> gear) {
String sql = "DELETE FROM " + table + " WHERE "
+ COLUMNS.INDEX.name + " IN (" + makePlaceholders(gear.size()) + ")";
List<Object> params = new ArrayList<>();
for (GearData gearData : gear)
params.add(gearData.getDatabase_id());
return sqlUpdate(sql, params);
}
private static String makePlaceholders(int len) {
StringBuilder sb = new StringBuilder(len * 2 - 1);
sb.append("?");
for (int i = 1; i < len; i++)
sb.append(",?");
return sb.toString();
}
public List<GearData> getGear(Player p) {
public List<Object> getCooldown(UUID uuid) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
List<GearData> gearList = new ArrayList<>();
conn = getSQLConnection();
ps = conn.prepareStatement("SELECT * FROM " + table + " WHERE " + COLUMNS.UUID.name + " = ?");
ps.setString(1, p.getUniqueId().toString());
ps.setString(1, uuid.toString());
rs = ps.executeQuery();
//Load all of players gear
while (rs.next()) {
GearBaseInfo baseInfo = new GearBaseInfo(
rs.getString(COLUMNS.IDENTIFIER.name),
ELEMENT_TYPE.valueOf(rs.getString( COLUMNS.BASE_ELEMENT.name)),
GEAR_TIER.valueOf(rs.getString( COLUMNS.BASE_TIER.name)),
GEAR_TYPE.valueOf(rs.getString( COLUMNS.BASE_TYPE.name))
);
GearData data = new GearData(
baseInfo,
rs.getInt( COLUMNS.INDEX.name),
rs.getString( COLUMNS.DATE_ACQUIRED.name),
GEAR_TIER.valueOf(rs.getString( COLUMNS.GEAR_TIER.name)),
rs.getInt( COLUMNS.GEAR_LEVEL.name),
rs.getInt( COLUMNS.GEAR_XP.name),
HelperJsonConverter.getCatalystFromJson(rs.getString(COLUMNS.GEAR_CATALYST.name)),
HelperJsonConverter.getTrackersFromJson(rs.getString(COLUMNS.GEAR_TRACKER.name))
);
data.setFavorite(rs.getBoolean(COLUMNS.FAVORITE.name));
if (data.getGear().getIdentifier() != null)
gearList.add(data);
if (rs.next()) {
List<Object> data = new ArrayList<>();
data.add(rs.getLong(COLUMNS.COOLDOWN_DATE.name));
data.add(rs.getInt(COLUMNS.USES.name));
return data;
}
return gearList;
} catch (SQLException ex) {
AmethystGear.getInstance().getLogger().log(Level.SEVERE, Errors.sqlConnectionExecute(), ex);
BetterRTP.getInstance().getLogger().log(Level.SEVERE, Errors.sqlConnectionExecute(), ex);
} finally {
close(ps, rs, conn);
}
return null;
}
public void fixGear(Player player) {
//This is here incase in the future someone smart breaks my database and I gotta fix it in code...
}
//Create gear
public GearData addNewGear(Player p, GearBaseInfo _gear) {
String date = HelperDate.getDate(HelperDate.getDate());
GearData gearData = new GearData(_gear, date);
//Default Catalyst
gearData.setCatalysts(List.of(new Catalyst(1, _gear.getElement())));
String pre = "INSERT INTO ";
//Set a player Cooldown
public void setCooldown(UUID uuid, Long time, int uses) {
String pre = "INSERT OR REPLACE INTO ";
String sql = pre + table + " ("
+ COLUMNS.UUID.name + ", "
//GEAR INFO
+ COLUMNS.GEAR_TIER.name + ", "
+ COLUMNS.GEAR_LEVEL.name + ", "
+ COLUMNS.GEAR_XP.name + ", "
+ COLUMNS.GEAR_CATALYST.name + ", "
+ COLUMNS.GEAR_TRACKER.name + ", "
//BASE GEAR INFO
+ COLUMNS.IDENTIFIER.name + ", "
+ COLUMNS.BASE_ELEMENT.name + ", "
+ COLUMNS.BASE_TYPE.name + ", "
+ COLUMNS.BASE_TIER.name + ", "
//MISC
+ COLUMNS.DATE_ACQUIRED.name + ", "
+ COLUMNS.FAVORITE.name + " "
+ ") VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+ COLUMNS.COOLDOWN_DATE.name + ", "
+ COLUMNS.USES.name + " "
+ ") VALUES(?, ?, ?)";
List<Object> params = new ArrayList<>() {{
add(p.getUniqueId().toString());
//GEAR INFO
add(gearData.getTier().name());
add(gearData.getLevel());
add(gearData.getXp());
add(HelperJsonConverter.getJsonFromCatalysts(gearData.getCatalysts()));
add(HelperJsonConverter.getJsonFromTrackers(gearData.getTrackers()));
//BASE GEAR INFO
add(gearData.getGear().getIdentifier());
add(gearData.getGear().getElement().name());
add(gearData.getGear().getType().name());
add(gearData.getGear().getTier().name());
//MISC
add(date);
add(gearData.isFavorite());
add(uuid.toString());
add(time);
add(uses);
}};
gearData.setDatabase_id(sqlGetIndex(sql, params));
return gearData;
}
public boolean updateGear(GearData gear) {
String sql = "UPDATE " + table + " SET "
+ COLUMNS.GEAR_TIER.name + " = ?, "
+ COLUMNS.GEAR_LEVEL.name + " = ?, "
+ COLUMNS.GEAR_XP.name + " = ?, "
+ COLUMNS.GEAR_CATALYST.name + " = ?, "
+ COLUMNS.GEAR_TRACKER.name + " = ?, "
+ COLUMNS.FAVORITE.name + " = ? "
+ "WHERE "
+ COLUMNS.INDEX.name + " = ?";
List<Object> params = new ArrayList<>() {{
add(gear.getTier().name());
add(gear.getLevel());
add(gear.getXp());
add(HelperJsonConverter.getJsonFromCatalysts(gear.getCatalysts()));
add(HelperJsonConverter.getJsonFromTrackers(gear.getTrackers()));
add(gear.isFavorite());
//Database Index
add(gear.getDatabase_id());
}};
gear.setUpdated(false); //Gear has been uploaded, no need to update if nothing new has changed
return sqlUpdate(sql, params);
}
private int sqlGetIndex(String statement, List<Object> params) {
Connection conn = null;
PreparedStatement ps = null;
int index = -1;
try {
conn = getSQLConnection();
ps = conn.prepareStatement(statement, Statement.RETURN_GENERATED_KEYS);
if (params != null) {
Iterator<Object> it = params.iterator();
int paramIndex = 1;
while (it.hasNext()) {
ps.setObject(paramIndex, it.next());
paramIndex++;
}
}
ps.executeUpdate();
ResultSet rs = ps.getGeneratedKeys();
if (rs.next()) {
//HelperItemGeneral.applyData(HelperData.getData(gear.item), GENERAL_DATA_INT.DATABASE_INDEX, rs.getInt(1));
index = rs.getInt(1);
}
} catch (SQLException ex) {
AmethystGear.getInstance().getLogger().log(Level.SEVERE, Errors.sqlConnectionExecute(), ex);
} finally {
close(ps, null, conn);
}
return index;
sqlUpdate(sql, params);
}
}