JarvisBigBalls
/
Mineplex2018-withcommit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clean up DonationManager

This commit is contained in:
samczsun 2016-10-27 22:35:27 -04:00 committed by cnr
parent f2fc70f400
commit d291521ad1
146 changed files with 1738 additions and 2323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Plugins/Mineplex.Bungee.Mineplexer/src/mineplex/bungee/playerStats/PlayerStatsRepository.java
View File

@ -35,18 +35,6 @@ public class PlayerStatsRepository extends RepositoryBase
super(DBPool.getPlayerStats());
}
@Override
public void initialize()
{
}
@Override
protected void update()
{
}
public PlayerInfo getPlayer(UUID uuid, String name, int version)
{
PlayerInfo playerInfo = null;

12
Plugins/Mineplex.BungeeRotator/src/mineplex/bungee/PlayerStatsRepository.java
View File

@ -17,18 +17,6 @@ public class PlayerStatsRepository extends RepositoryBase
super(DBPool.getPlayerStats());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
public List<IpInfo> getIpAddresses()
{
List<IpInfo> ipinfos = new ArrayList<IpInfo>(1000);

5
Plugins/Mineplex.Core.Common/src/mineplex/core/common/util/UtilServer.java
View File

@ -180,4 +180,9 @@ public class UtilServer
throwable.printStackTrace(System.out);
}
}
public static String getWebServerURL()
{
return getPlugin().getConfig().getString("webServer");
}
}

9
Plugins/Mineplex.Core.Common/src/mineplex/core/common/util/UtilTasks.java
View File

@ -31,10 +31,13 @@ public class UtilTasks
{
return t ->
{
onMainThread(() ->
if (original != null)
{
original.accept(t);
});
onMainThread(() ->
{
original.accept(t);
});
}
};
}
}

11
Plugins/Mineplex.Core/src/mineplex/core/MiniClientPlugin.java
View File

@ -16,12 +16,17 @@ public abstract class MiniClientPlugin<DataType extends Object> extends MiniPlug
private static final Object _clientDataLock = new Object();
private Map<UUID, DataType> _clientData = new HashMap<>();
public MiniClientPlugin(String moduleName, JavaPlugin plugin)
public MiniClientPlugin(String moduleName, JavaPlugin plugin)
{
super(moduleName, plugin);
}
public MiniClientPlugin(String moduleName)
{
super(moduleName);
}
@EventHandler
public void UnloadPlayer(ClientUnloadEvent event)
{

7
Plugins/Mineplex.Core/src/mineplex/core/account/CoreClient.java
View File

@ -207,4 +207,11 @@ public class CoreClient
UtilPlayer.message(_player, C.cGold + "Your test rank has been reset!");
}
}
public String getRealOrDisguisedName()
{
if (getDisguisedAs() != null)
return getDisguisedAs();
return getName();
}
}

8
Plugins/Mineplex.Core/src/mineplex/core/account/CoreClientManager.java
View File

@ -231,6 +231,14 @@ public class CoreClientManager extends MiniPlugin
_repository.getAccountId(uuid, callback);
}
public void getOrLoadClient(String playerName, Consumer<CoreClient> loadedClient)
{
CoreClient client = Get(playerName);
if (client != null)
loadedClient.accept(client);
loadClientByName(playerName, loadedClient);
}
public void loadClientByName(final String playerName, final Runnable runnable)
{
loadClientByName(playerName, client -> runnable.run());

75
Plugins/Mineplex.Core/src/mineplex/core/account/repository/AccountRepository.java
View File

@ -8,6 +8,7 @@ import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.apache.commons.dbcp2.BasicDataSource;
@ -38,7 +39,6 @@ public class AccountRepository extends MinecraftRepository
private static String UPDATE_ACCOUNT_RANK_DONOR = "UPDATE accounts SET rank=?, donorRank=?, rankPerm=false, rankExpire=now() + INTERVAL 1 MONTH WHERE uuid = ?;";
private static String UPDATE_ACCOUNT_RANK_PERM = "UPDATE accounts SET rank=?, rankPerm=true WHERE uuid = ?;";
private static String UPDATE_ACCOUNT_RANK_DONOR_PERM = "UPDATE accounts SET rank=?, donorRank=?, rankPerm=true WHERE uuid = ?;";
private static String UPDATE_ACCOUNT_NULL_RANK = "UPDATE accounts SET rank=?, donorRank=?, rankPerm=?, rankExpire=? WHERE uuid = ? AND rank IS NULL;";
private static String SELECT_ACCOUNT_UUID_BY_NAME = "SELECT uuid FROM accounts WHERE name = ? ORDER BY lastLogin DESC;";
private static String SELECT_ACCOUNT_ID_BY_UUID = "SELECT id FROM accounts WHERE accounts.uuid = ? LIMIT 1";
@ -47,16 +47,10 @@ public class AccountRepository extends MinecraftRepository
public AccountRepository(JavaPlugin plugin, String webAddress)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_webAddress = webAddress;
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_ACCOUNT_TABLE);
}
public int login(final List<ILoginProcessor> loginProcessors, final UUID uuid, final String name) throws SQLException
{
@ -190,9 +184,9 @@ public class AccountRepository extends MinecraftRepository
token.Rank = rank.toString();
token.Perm = perm;
final Callback<Rank> extraCallback = new Callback<Rank>()
final Consumer<Rank> extraCallback = response ->
{
public void run(final Rank response)
if (rank == Rank.ULTRA || rank == Rank.HERO || rank == Rank.LEGEND || rank == Rank.TITAN)
{
if (rank.isDonor())
{
@ -201,34 +195,31 @@ public class AccountRepository extends MinecraftRepository
else
executeUpdate(UPDATE_ACCOUNT_RANK_DONOR, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("donorRank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
}
if (perm)
executeUpdate(UPDATE_ACCOUNT_RANK_DONOR_PERM, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("donorRank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
else
{
if (perm)
executeUpdate(UPDATE_ACCOUNT_RANK_PERM, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
else
executeUpdate(UPDATE_ACCOUNT_RANK, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
}
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
if (callback != null)
callback.run(response);
}
});
executeUpdate(UPDATE_ACCOUNT_RANK_DONOR, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("donorRank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
}
};
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
else
{
new JsonWebCall(_webAddress + "PlayerAccount/RankUpdate").Execute(Rank.class, extraCallback, token);
if (perm)
executeUpdate(UPDATE_ACCOUNT_RANK_PERM, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
else
executeUpdate(UPDATE_ACCOUNT_RANK, new ColumnVarChar("rank", 100, rank.toString()), new ColumnVarChar("uuid", 100, uuid.toString()));
}
}), "Error saving player " + token.Name + "'s rank in AccountRepository : ");
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
if (callback != null)
callback.run(response);
}
});
};
handleMSSQLCall("PlayerAccount/RankUpdate", String.format("Error saving %s's rank: ", token.Name), token, Rank.class, extraCallback);
}
public void matchPlayerName(final Callback<List<String>> callback, final String userName)
@ -245,22 +236,6 @@ public class AccountRepository extends MinecraftRepository
asyncThread.start();
}
@Override
protected void update()
{
}
public void updateMysqlRank(final String uuid, final String rank, final boolean perm, final String rankExpire)
{
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
executeUpdate(UPDATE_ACCOUNT_NULL_RANK, new ColumnVarChar("rank", 100, rank), new ColumnVarChar("donorRank", 100, rank), new ColumnBoolean("rankPerm", perm), new ColumnTimestamp("rankExpire", Timestamp.valueOf(rankExpire)), new ColumnVarChar("uuid", 100, uuid));
}
}), "Error updating player's mysql rank AccountRepository : ");
}
public String getClientByName(String playerName)
{
return new JsonWebCall(_webAddress + "PlayerAccount/GetAccount").ExecuteReturnStream(playerName);

8
Plugins/Mineplex.Core/src/mineplex/core/achievement/ui/AchievementShop.java
View File

@ -37,17 +37,17 @@ public class AchievementShop extends ShopBase<AchievementManager>
public boolean attemptShopOpen(Player player, String targetName, PlayerStats targetStats)
{
if (!getOpenedShop().contains(player.getName()))
if (!getOpenedShop().contains(player.getUniqueId()))
{
if (!canOpenShop(player))
return false;
getOpenedShop().add(player.getName());
getOpenedShop().add(player.getUniqueId());
openShopForPlayer(player);
if (!getPlayerPageMap().containsKey(player.getName()))
if (!getPlayerPageMap().containsKey(player.getUniqueId()))
{
getPlayerPageMap().put(player.getName(), BuildPagesFor(player, targetName, targetStats));
getPlayerPageMap().put(player.getUniqueId(), BuildPagesFor(player, targetName, targetStats));
}
openPageForPlayer(player, getOpeningPageForPlayer(player));

15
Plugins/Mineplex.Core/src/mineplex/core/antihack/banwave/BanWaveRepository.java
View File

@ -1,7 +1,6 @@
package mineplex.core.antihack.banwave;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.UtilServer;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.column.ColumnInt;
@ -38,19 +37,7 @@ public class BanWaveRepository extends MinecraftRepository
BanWaveRepository()
{
super(UtilServer.getPlugin(), DBPool.getAccount());
}
@Override
protected void initialize()
{
//executeUpdate(INITIALIZE_TABLE);
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
void getPendingBanWaveInfo(int accountId, Callback<BanWaveInfo> callback)

14
Plugins/Mineplex.Core/src/mineplex/core/benefit/BenefitManagerRepository.java
View File

@ -5,7 +5,6 @@ import java.sql.SQLException;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -20,20 +19,9 @@ public class BenefitManagerRepository extends MinecraftRepository
public BenefitManagerRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_BENEFIT_TABLE);
}
@Override
protected void update()
{
}
public boolean addBenefit(int accountId, String benefit)
{
return executeUpdate(INSERT_BENEFIT, new ColumnInt("accountId", accountId), new ColumnVarChar("benefit", 100, benefit)) > 0;

59
Plugins/Mineplex.Core/src/mineplex/core/bonuses/BonusManager.java
View File

@ -47,6 +47,7 @@ import mineplex.core.bonuses.gui.BonusGui;
import mineplex.core.bonuses.gui.SpinGui;
import mineplex.core.bonuses.gui.buttons.PowerPlayClubButton;
import mineplex.core.common.Rank;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -56,7 +57,6 @@ import mineplex.core.common.util.UtilParticle.ViewDist;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.donation.DonationManager;
import mineplex.core.donation.GiveDonorData;
import mineplex.core.facebook.FacebookManager;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.hologram.Hologram;
@ -138,10 +138,6 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
private AnimationCarl _animation;
private int _visualTick;
// Donor Queues
private Queue<GiveDonorData> _coinQueue;
private Queue<GiveDonorData> _gemQueue;
public BonusManager(JavaPlugin plugin, Location carlLocation, PlayWireManager playWireManager, CoreClientManager clientManager, DonationManager donationManager, PollManager pollManager, NpcManager npcManager, HologramManager hologramManager, StatsManager statsManager, InventoryManager inventoryManager, PetManager petManager, FacebookManager facebookManager, YoutubeManager youtubeManager, GadgetManager gadgetManager, ThankManager thankManager)
{
super("Bonus", plugin);
@ -169,10 +165,6 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
_powerPlayClubRepository = new PowerPlayClubRepository(plugin, _clientManager, _donationManager);
_coinQueue = new LinkedList<>();
_gemQueue = new LinkedList<>();
if (npcManager != null)
{
_carlNpc = _npcManager.getNpcByName("Carl the Creeper");
@ -595,7 +587,7 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
if (gems > 0)
{
UtilPlayer.message(player, F.main("Carl", "Rewarded " + F.elem(gems + " Gems")));
_gemQueue.add(new GiveDonorData(null, player.getName(), "Treasure", player.getUniqueId(), coreClient.getAccountId(), gems));
_donationManager.rewardCurrencyUntilSuccess(GlobalCurrency.GEM, player, "Earned", gems);
}
if (gold > 0)
@ -606,7 +598,7 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
if (coins > 0)
{
UtilPlayer.message(player, F.main("Carl", "Rewarded " + F.elem(coins + " Treasure Shards")));
_coinQueue.add(new GiveDonorData(null, player.getName(), "Treasure", player.getUniqueId(), coreClient.getAccountId(), coins));
_donationManager.rewardCurrencyUntilSuccess(GlobalCurrency.TREASURE_SHARD, player, "Earned", coins);
}
if (tickets > 0)
@ -871,51 +863,6 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
}
}
@EventHandler
public void processQueue(UpdateEvent event)
{
if (event.getType() != UpdateType.FASTER)
return;
// Gems
final GiveDonorData gemData = _gemQueue.poll();
if (gemData != null && gemData.getAttempts() < 10)
{
_donationManager.RewardGems(data ->
{
if (data)
{
System.out.println("Successfully processed " + gemData.getGiveAmount() + " gems for " + gemData.getPlayerName());
}
else
{
gemData.incrementAttempts();
System.out.println("Failed to process gems for " + gemData.getPlayerName() + " adding to back of queue. Attempts: " + gemData.getAttempts());
_gemQueue.add(gemData);
}
}, "Earned", gemData.getPlayerName(), gemData.getUuid(), gemData.getGiveAmount());
}
// Coins
final GiveDonorData coinData = _coinQueue.poll();
if (coinData != null && coinData.getAttempts() < 10)
{
_donationManager.RewardCoins(data ->
{
if (data)
{
System.out.println("Successfully processed " + coinData.getGiveAmount() + " coins for " + coinData.getPlayerName());
}
else
{
coinData.incrementAttempts();
System.out.println("Failed to process coins for " + coinData.getPlayerName() + " adding to back of queue. Attempts: " + coinData.getAttempts());
_coinQueue.add(coinData);
}
}, "Earned", coinData.getPlayerName(), coinData.getAccountId(), coinData.getGiveAmount());
}
}
/**
* Used for disabling rank rewards during first month of release
* @return

15
Plugins/Mineplex.Core/src/mineplex/core/bonuses/BonusRepository.java
View File

@ -12,7 +12,6 @@ import mineplex.core.common.Pair;
import mineplex.core.common.util.Callback;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.core.donation.DonationManager;
import mineplex.core.recharge.Recharge;
@ -37,7 +36,7 @@ public class BonusRepository extends MinecraftRepository
public BonusRepository(JavaPlugin plugin, BonusManager bonusManager, DonationManager donationManager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_manager = bonusManager;
_donationManager = donationManager;
}
@ -433,16 +432,4 @@ public class BonusRepository extends MinecraftRepository
.set(Tables.bonus.maxVoteStreak, clientData.getMaxVoteStreak())
.where(Tables.bonus.accountId.eq(accountId)).execute();
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_BONUS_TABLE);
}
@Override
protected void update()
{
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/boosters/tips/BoosterThankManager.java
View File

@ -74,7 +74,7 @@ public class BoosterThankManager extends MiniPlugin
if (_repository.checkAmplifierThank(accountId, booster.getId()))
{
// We can thank that amplifier!
_thankManager.thankPlayer(booster.getPlayerName(), booster.getAccountId(), player.getName(), accountId,
_thankManager.thankPlayer(booster.getPlayerName(), booster.getAccountId(), player,
TIP_FOR_SPONSOR, TIP_FOR_TIPPER, "Amplifier", true, thankResult ->
runSync(() -> callback.run(fromThankResult(thankResult))));
}

20
Plugins/Mineplex.Core/src/mineplex/core/boosters/tips/BoosterThankRepository.java
View File

@ -1,13 +1,9 @@
package mineplex.core.boosters.tips;
import mineplex.core.database.MinecraftRepository;
import mineplex.database.routines.AddTip;
import mineplex.database.routines.CheckAmplifierThank;
import mineplex.database.routines.ClaimTips;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnInt;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
/**
@ -17,7 +13,7 @@ public class BoosterThankRepository extends MinecraftRepository
{
public BoosterThankRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
/**
@ -37,16 +33,4 @@ public class BoosterThankRepository extends MinecraftRepository
checkAmplifierThank.execute(jooq().configuration());
return checkAmplifierThank.getCanThank() == 1;
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
}

15
Plugins/Mineplex.Core/src/mineplex/core/botspam/repository/BotSpamRepository.java
View File

@ -8,7 +8,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.core.botspam.SpamText;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
@ -25,7 +24,7 @@ public class BotSpamRepository extends MinecraftRepository
public BotSpamRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public ArrayList<SpamText> getSpamText()
@ -70,16 +69,4 @@ public class BotSpamRepository extends MinecraftRepository
{
executeInsert(ADD_SPAM_TEXT, null, new ColumnVarChar("text", 200, spamText), new ColumnVarChar("createdBy", 100, caller), new ColumnVarChar("enabledBy", 100, caller));
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
}

39
Plugins/Mineplex.Core/src/mineplex/core/brawl/fountain/command/AddCommand.java
View File

@ -1,5 +1,7 @@
package mineplex.core.brawl.fountain.command;
import java.util.function.Consumer;
import mineplex.core.brawl.fountain.FountainManager;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
@ -8,10 +10,12 @@ import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.server.util.TransactionResponse;
import org.bukkit.entity.Player;
/**
* Command to add gems to the fountain
*
* @author Shaun Bennett
*/
public class AddCommand extends CommandBase<FountainManager>
@ -34,26 +38,23 @@ public class AddCommand extends CommandBase<FountainManager>
{
int amount = Integer.parseInt(args[0]);
Plugin.getDonationManager().purchaseUnknownSalesPackage(new Callback<TransactionResponse>()
{
@Override
public void run(TransactionResponse result)
{
if (result == TransactionResponse.Success)
Plugin.getDonationManager().purchaseUnknownSalesPackage(caller, "GemFountain.Add", GlobalCurrency.GEM, amount, false,
result ->
{
Plugin.getGemFountain().increment(caller, amount, null);
UtilPlayer.message(caller, F.main("Fountain", "Added " + F.elem(amount) + " to the fountain!"));
}
else if (result == TransactionResponse.InsufficientFunds)
{
UtilPlayer.message(caller, F.main("Fountain", "You do not have enough gems!"));
}
else
{
UtilPlayer.message(caller, F.main("Fountain", "There was an error processing your request!"));
}
}
}, caller, "GemFountain.Add", GlobalCurrency.GEM, amount, false);
if (result == TransactionResponse.Success)
{
Plugin.getGemFountain().increment(caller, amount, null);
UtilPlayer.message(caller, F.main("Fountain", "Added " + F.elem(amount) + " to the fountain!"));
}
else if (result == TransactionResponse.InsufficientFunds)
{
UtilPlayer.message(caller, F.main("Fountain", "You do not have enough gems!"));
}
else
{
UtilPlayer.message(caller, F.main("Fountain", "There was an error processing your request!"));
}
});
}
catch (NumberFormatException ex)
{

4
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/CosmeticShop.java
View File

@ -34,13 +34,13 @@ public class CosmeticShop extends ShopBase<CosmeticManager> implements PluginMes
if (!channel.equalsIgnoreCase("MC|ItemName"))
return;
if (getPlayerPageMap().containsKey(player.getName()) && getPlayerPageMap().get(player.getName()) instanceof PetTagPage)
if (getPlayerPageMap().containsKey(player.getUniqueId()) && getPlayerPageMap().get(player.getUniqueId()) instanceof PetTagPage)
{
if (message != null && message.length >= 1)
{
String tagName = new String(message);
((PetTagPage) getPlayerPageMap().get(player.getName())).SetTagName(tagName);
((PetTagPage) getPlayerPageMap().get(player.getUniqueId())).SetTagName(tagName);
}
}
}

29
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/page/GadgetPage.java
View File

@ -439,16 +439,25 @@ public class GadgetPage extends ShopPageBase<CosmeticManager, CosmeticShop>
return;
}
if(getClientManager().Get(player).isDisguised())
{
UtilPlayer.message(player, F.main("Disguise", "You cant buy things while you are disguised!"));
return;
}
getShop().openPageForPlayer(getPlayer(), new ConfirmationPage<>(player, this, new SalesPackageProcessor(player, GlobalCurrency.TREASURE_SHARD, (gadget instanceof ItemGadget ? ((ItemGadget) gadget).getAmmo() : gadget), getDonationManager(), () ->
{
getPlugin().getInventoryManager().addItemToInventory(getPlayer(), gadget.getName(), (gadget instanceof ItemGadget ? ((ItemGadget) gadget).getAmmo().getQuantity() : gadget.getQuantity()));
refresh();
}), gadget.buildIcon()));
getShop().openPageForPlayer(
getPlayer(),
new ConfirmationPage<>(
player,
this,
new SalesPackageProcessor(
player,
GlobalCurrency.TREASURE_SHARD,
(gadget instanceof ItemGadget ? ((ItemGadget) gadget).getAmmo() : gadget),
getDonationManager(),
() ->
{
getPlugin().getInventoryManager().addItemToInventory(getPlayer(), gadget.getName(), (gadget instanceof ItemGadget ? ((ItemGadget) gadget).getAmmo().getQuantity() : gadget.getQuantity()));
refresh();
}
),
gadget.buildIcon()
)
);
}
public void activateGadget(Player player, Gadget gadget)

2
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/page/Menu.java
View File

@ -111,7 +111,7 @@ public class Menu extends ShopPageBase<CosmeticManager, CosmeticShop>
Mount<?> mountActive = getPlugin().getMountManager().getActive(getPlayer());
for (Mount<?> mount : getPlugin().getMountManager().getMounts())
{
if (getDonationManager().Get(getPlayer()).OwnsUnknownPackage(mount.getName()))
if (getDonationManager().Get(getPlayer()).ownsUnknownSalesPackage(mount.getName()))
{
mountOwned++;
}

4
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/page/MountPage.java
View File

@ -66,7 +66,7 @@ public class MountPage extends ShopPageBase<CosmeticManager, CosmeticShop>
itemLore.add(C.cBlack);
itemLore.addAll(Arrays.asList(mount.getDescription()));
if (!getDonationManager().Get(getPlayer()).OwnsUnknownPackage(mount.getName()))
if (!getDonationManager().Get(getPlayer()).ownsUnknownSalesPackage(mount.getName()))
{
if (mount.getCost(GlobalCurrency.TREASURE_SHARD) == -1)
{
@ -153,7 +153,7 @@ public class MountPage extends ShopPageBase<CosmeticManager, CosmeticShop>
}
}
if (getDonationManager().Get(getPlayer()).OwnsUnknownPackage(mount.getName()))
if (getDonationManager().Get(getPlayer()).ownsUnknownSalesPackage(mount.getName()))
{
if (mount.getActive().containsKey(getPlayer()))
{

6
Plugins/Mineplex.Core/src/mineplex/core/customdata/repository/CustomDataRepository.java
View File

@ -14,7 +14,6 @@ import mineplex.core.customdata.CustomData;
import mineplex.core.customdata.CustomDataManager;
import mineplex.core.customdata.PlayerCustomData;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -37,7 +36,7 @@ public class CustomDataRepository extends MinecraftRepository
public CustomDataRepository(JavaPlugin plugin, CoreClientManager clientManager, CustomDataManager customDataManager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_clientManager = clientManager;
_customDataManager = customDataManager;
@ -49,9 +48,6 @@ public class CustomDataRepository extends MinecraftRepository
downloadDataKeys();
}
@Override
protected void update() {}
private void downloadDataKeys()
{
_dataKeys = new ArrayList<>();

128
Plugins/Mineplex.Core/src/mineplex/core/database/MinecraftRepository.java
View File

@ -1,49 +1,53 @@
package mineplex.core.database;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Iterator;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Consumer;
import javax.rmi.CORBA.Util;
import javax.sql.DataSource;
import mineplex.core.common.util.NautHashMap;
import mineplex.core.common.util.UtilServer;
import mineplex.core.server.remotecall.AsyncJsonWebCall;
import mineplex.core.server.remotecall.JsonWebCall;
import mineplex.core.thread.ThreadPool;
import mineplex.core.utils.UtilScheduler;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.DatabaseRunnable;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.Column;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import org.jooq.DSLContext;
import org.jooq.SQLDialect;
import org.jooq.impl.DSL;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
public abstract class MinecraftRepository extends RepositoryBase implements Listener
{
// Queue for failed processes
private static Object _queueLock = new Object();
private NautHashMap<DatabaseRunnable, String> _failedQueue = new NautHashMap<DatabaseRunnable, String>();
private final Object QUEUE_LOCK = new Object();
private Set<DatabaseRunnable> _failedQueue = new HashSet<>();
protected JavaPlugin _plugin; // Plugin responsible for this repository
protected JavaPlugin _plugin; // Plugin responsible for this repository
private final String _webAddress = UtilServer.getWebServerURL();
/**
* Constructor
* @param plugin - the {@link JavaPlugin} module responsible for this repository.
*
* @param dataSource - the {@link DataSource} responsible for providing the connection pool to this repository.
*/
public MinecraftRepository(JavaPlugin plugin, DataSource dataSource)
public MinecraftRepository(DataSource dataSource)
{
super(dataSource);
_plugin = plugin;
plugin.getServer().getPluginManager().registerEvents(this, plugin);
_plugin = UtilServer.getPlugin();
UtilServer.RegisterEvents(this);
UtilScheduler.runEvery(UpdateType.MIN_01, this::processDatabaseQueue);
}
protected DSLContext jooq()
@ -51,58 +55,78 @@ public abstract class MinecraftRepository extends RepositoryBase implements List
return DSL.using(DBPool.getAccount(), SQLDialect.MYSQL);
}
protected void handleDatabaseCall(final DatabaseRunnable databaseRunnable, final String errorMessage)
/**
* One day, the stars will align, and we can get rid of this
*/
@Deprecated
protected <T> void handleMSSQLCall(String uri, String error, Object param, Class<T> responseType, Consumer<T> consumer)
{
Thread asyncThread = new Thread(new Runnable()
handleDatabaseCall(new DatabaseRunnable(() ->
{
public void run()
{
try
{
databaseRunnable.run();
}
catch (Exception exception)
{
processFailedDatabaseCall(databaseRunnable, exception.getMessage(), errorMessage);
}
}
});
asyncThread.start();
new JsonWebCall(_webAddress + uri).Execute(responseType, consumer::accept, param);
}, error));
}
protected void processFailedDatabaseCall(DatabaseRunnable databaseRunnable, String errorPreMessage, String runnableMessage)
/**
* One day, the stars will align, and we can get rid of this
*/
@Deprecated
protected <T> void handleAsyncMSSQLCall(String uri, Object param, Class<T> responseType, Consumer<T> consumer)
{
new AsyncJsonWebCall(_webAddress + uri).Execute(responseType, consumer::accept, param);
}
/**
* One day, the stars will align, and we can get rid of this
*/
@Deprecated
protected <T> void handleAsyncMSSQLCall(String uri, Object param)
{
new AsyncJsonWebCall(_webAddress + uri).Execute(param);
}
private void handleDatabaseCall(DatabaseRunnable databaseRunnable)
{
ThreadPool.ASYNC.submit(() ->
{
try
{
databaseRunnable.run();
}
catch (Exception exception)
{
processFailedDatabaseCall(databaseRunnable, exception);
}
});
}
private void processFailedDatabaseCall(DatabaseRunnable databaseRunnable, Exception exception)
{
System.err.println(databaseRunnable.getErrorMessage());
exception.printStackTrace();
if (databaseRunnable.getFailedCounts() < 4)
{
databaseRunnable.incrementFailCount();
synchronized (_queueLock)
synchronized (QUEUE_LOCK)
{
_failedQueue.put(databaseRunnable, runnableMessage);
_failedQueue.add(databaseRunnable);
}
}
}
@EventHandler
public void processDatabaseQueue(UpdateEvent event)
private void processDatabaseQueue()
{
if (event.getType() != UpdateType.MIN_01)
return;
Set<DatabaseRunnable> clone;
processFailedQueue();
}
private void processFailedQueue()
{
synchronized (_queueLock)
synchronized (QUEUE_LOCK)
{
for (Iterator<DatabaseRunnable> runnablesIterator = _failedQueue.keySet().iterator(); runnablesIterator.hasNext();)
{
DatabaseRunnable databaseRunnable = runnablesIterator.next();
handleDatabaseCall(databaseRunnable, _failedQueue.get(databaseRunnable));
}
clone = new HashSet<>(_failedQueue);
_failedQueue.clear();
}
clone.forEach(this::handleDatabaseCall);
}
public JavaPlugin getPlugin()

58
Plugins/Mineplex.Core/src/mineplex/core/donation/CurrencyRewardData.java Normal file
View File

@ -0,0 +1,58 @@
package mineplex.core.donation;
import java.util.UUID;
import java.util.function.Consumer;
class CurrencyRewardData
{
private final String _playerName;
private final UUID _playerUUID;
private final String _reason;
private final int _amount;
private final Consumer<Boolean> _callback;
private int _attempts;
CurrencyRewardData(String playerName, UUID playerUUID, String reason, int amount, Consumer<Boolean> callback)
{
_playerName = playerName;
_playerUUID = playerUUID;
_reason = reason;
_amount = amount;
_callback = callback;
}
int getAttempts()
{
return _attempts;
}
void incrementAttempts()
{
_attempts++;
}
String getPlayerName()
{
return _playerName;
}
UUID getPlayerUUID()
{
return _playerUUID;
}
String getReason()
{
return _reason;
}
int getAmount()
{
return _amount;
}
Consumer<Boolean> getCallback()
{
return _callback;
}
}

597
Plugins/Mineplex.Core/src/mineplex/core/donation/DonationManager.java
View File

@ -1,371 +1,310 @@
package mineplex.core.donation;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.UUID;
import java.util.function.Consumer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import com.google.gson.Gson;
import mineplex.cache.player.PlayerCache;
import mineplex.core.MiniClientPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.account.CoreClient;
import mineplex.core.account.CoreClientManager;
import mineplex.core.account.event.ClientWebResponseEvent;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.NautHashMap;
import mineplex.core.donation.command.GemCommand;
import mineplex.core.donation.command.ShardCommand;
import mineplex.core.donation.repository.DonationRepository;
import mineplex.core.donation.repository.token.DonorTokenWrapper;
import mineplex.core.server.util.TransactionResponse;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.LinkedList;
import java.util.Queue;
import java.util.UUID;
import mineplex.core.utils.UtilScheduler;
/**
* This manager handles the rewarding of transactions in the form of sales packages and currency
*/
@ReflectivelyCreateMiniPlugin
public class DonationManager extends MiniClientPlugin<Donor>
{
private final int MAX_GIVE_ATTEMPTS = 10;
/**
* The maximum number of attempts that will be made to perform a transaction created by {@link DonationManager#rewardCurrencyUntilSuccess}
*/
public static final int MAX_GIVE_ATTEMPTS = 10;
private DonationRepository _repository;
private NautHashMap<Player, NautHashMap<String, Integer>> _gemQueue = new NautHashMap<Player, NautHashMap<String, Integer>>();
private NautHashMap<Player, NautHashMap<String, Integer>> _coinQueue = new NautHashMap<Player, NautHashMap<String, Integer>>();
private static final Gson GSON = new Gson();
private Queue<GiveDonorData> _coinAttemptQueue;
private final Map<GlobalCurrency, LinkedList<CurrencyRewardData>> _attemptUntilSuccess = new HashMap<>();
private final CoreClientManager _clientManager;
public DonationManager(JavaPlugin plugin, CoreClientManager clientManager, String webAddress)
private final CoreClientManager _clientManager = require(CoreClientManager.class);
private final DonationRepository _repository;
private DonationManager()
{
super("Donation", plugin);
_repository = new DonationRepository(plugin, webAddress);
super("Donation");
_coinAttemptQueue = new LinkedList<>();
_repository = new DonationRepository();
_clientManager = clientManager;
UtilScheduler.runEvery(UpdateType.FAST, this::processCoinAttemptQueue);
}
public CoreClientManager getClientManager()
{
return _clientManager;
}
@Override
public void addCommands()
{
// TODO: Re-add commands? Where are command implementations, seen as missing at the moment.
addCommand(new GemCommand(this));
addCommand(new ShardCommand(this));
}
@EventHandler
public void OnClientWebResponse(ClientWebResponseEvent event)
{
DonorTokenWrapper token = new Gson().fromJson(event.GetResponse(), DonorTokenWrapper.class);
LoadDonor(token, event.getUniqueId());
DonorTokenWrapper token = GSON.fromJson(event.GetResponse(), DonorTokenWrapper.class);
Get(event.getUniqueId()).loadToken(token.DonorToken);
}
private void LoadDonor(DonorTokenWrapper token, UUID uuid)
/**
* Adds an unknown sales package to the specified {@link Player}
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link TransactionResponse#InsufficientFunds}, when the player does not have enough of the currency
* {@link TransactionResponse#Success}, when everything worked fine
* {@link TransactionResponse#Failed}, when an known exception occured
* {@link TransactionResponse#AlreadyOwns}, when the player already owns the package
*/
public void purchaseUnknownSalesPackage(Player player, String packageName, GlobalCurrency currencyType, int cost, boolean oneTimePurchase, Consumer<TransactionResponse> callback)
{
Get(uuid).loadToken(token.DonorToken);
//_repository.updateGemsAndCoins(uuid, Get(token.Name).GetGems(), Get(token.Name).getCoins());
purchaseUnknownSalesPackage(_clientManager.Get(player), packageName, currencyType, cost, oneTimePurchase, callback);
}
public void purchaseUnknownSalesPackage(Callback<TransactionResponse> callback, Player player, String packageName, GlobalCurrency currencyType, int cost, boolean oneTimePurchase)
/**
* Adds an unknown sales package to the specified {@link CoreClient}
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link TransactionResponse#InsufficientFunds}, when the player does not have enough of the currency
* {@link TransactionResponse#Success}, when everything worked fine
* {@link TransactionResponse#Failed}, when an known exception occured
* {@link TransactionResponse#AlreadyOwns}, when the player already owns the package
*/
public void purchaseUnknownSalesPackage(CoreClient client, String packageName, GlobalCurrency currencyType, int cost, boolean oneTimePurchase, Consumer<TransactionResponse> callback)
{
PurchaseUnknownSalesPackage(callback, player.getName(), _clientManager.getAccountId(player), packageName, currencyType, cost, oneTimePurchase);
}
public void PurchaseUnknownSalesPackage(final Callback<TransactionResponse> callback, final String name, final int accountId, final String packageName, final GlobalCurrency currencyType, final int cost, boolean oneTimePurchase)
{
final Donor donor = Bukkit.getPlayerExact(name) != null ? Get(Bukkit.getPlayerExact(name)) : null;
Donor donor = Get(client.getUniqueId());
if (donor != null)
{
if (oneTimePurchase && donor.OwnsUnknownPackage(packageName))
if (oneTimePurchase && donor.ownsUnknownSalesPackage(packageName))
{
if (callback != null)
callback.run(TransactionResponse.AlreadyOwns);
callback.accept(TransactionResponse.AlreadyOwns);
return;
}
}
_repository.PurchaseUnknownSalesPackage(new Callback<TransactionResponse>()
_repository.purchaseUnknownSalesPackage(client.getName(), packageName, currencyType, cost, response ->
{
public void run(TransactionResponse response)
if (response == TransactionResponse.Success)
{
if (response == TransactionResponse.Success)
if (donor != null)
{
donor.addOwnedUnknownSalesPackage(packageName);
donor.addBalance(currencyType, -cost);
}
}
if (callback != null)
callback.accept(response);
});
}
/**
* Adds a known sales package to the {@link Player}
*/
public void purchaseKnownSalesPackage(Player player, int salesPackageId)
{
purchaseKnownSalesPackage(player, salesPackageId, null);
}
/**
* Adds a known sales package to the {@link CoreClient}
*/
public void purchaseKnownSalesPackage(CoreClient client, int salesPackageId)
{
purchaseKnownSalesPackage(client, salesPackageId, null);
}
/**
* Adds a known sales package to the {@link Player}
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link TransactionResponse#InsufficientFunds}, when the player does not have enough of the currency
* {@link TransactionResponse#Success}, when everything worked fine
* {@link TransactionResponse#Failed}, when an known exception occured
* {@link TransactionResponse#AlreadyOwns}, when the player already owns the package
*/
public void purchaseKnownSalesPackage(Player player, int salesPackageId, Consumer<TransactionResponse> callback)
{
purchaseKnownSalesPackage(_clientManager.Get(player), salesPackageId, callback);
}
/**
* Adds a known sales package to the {@link CoreClient}
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link TransactionResponse#InsufficientFunds}, when the player does not have enough of the currency
* {@link TransactionResponse#Success}, when everything worked fine
* {@link TransactionResponse#Failed}, when an known exception occured
* {@link TransactionResponse#AlreadyOwns}, when the player already owns the package
*/
public void purchaseKnownSalesPackage(CoreClient client, int salesPackageId, Consumer<TransactionResponse> callback)
{
_repository.purchaseKnownSalesPackage(client.getName(), salesPackageId, response ->
{
if (response == TransactionResponse.Success)
{
Donor donor = Get(client.getUniqueId());
if (donor != null)
{
donor.addOwnedKnownSalesPackage(salesPackageId);
}
}
if (callback != null)
callback.accept(response);
});
}
/**
* Rewards the specified {@link Player} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*/
public void rewardCurrency(GlobalCurrency currency, Player player, String reason, int amount)
{
rewardCurrency(currency, player, reason, amount, true, null);
}
/**
* Rewards the specified {@link Player} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link Boolean#TRUE} if the transaction succeeded
* {@link Boolean#FALSE} if the transaction failed, either during incrementation or sanity-checking
*/
public void rewardCurrency(GlobalCurrency currency, Player player, String reason, int amount, Consumer<Boolean> callback)
{
rewardCurrency(currency, player, reason, amount, true, callback);
}
/**
* Rewards the specified {@link Player} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*
* @param updateTotal Whether to update the local value for {@code currency}
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link Boolean#TRUE} if the transaction succeeded
* {@link Boolean#FALSE} if the transaction failed, either during incrementation or sanity-checking
*/
public void rewardCurrency(GlobalCurrency currency, Player player, String reason, int amount, boolean updateTotal, Consumer<Boolean> callback)
{
rewardCurrency(currency, _clientManager.Get(player), reason, amount, updateTotal, callback);
}
/**
* Rewards the specified {@link CoreClient} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*/
public void rewardCurrency(GlobalCurrency currency, CoreClient client, String reason, int amount)
{
rewardCurrency(currency, client.getName(), client.getUniqueId(), reason, amount, true, null);
}
/**
* Rewards the specified {@link CoreClient} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link Boolean#TRUE} if the transaction succeeded
* {@link Boolean#FALSE} if the transaction failed, either during incrementation or sanity-checking
*/
public void rewardCurrency(GlobalCurrency currency, CoreClient client, String reason, int amount, Consumer<Boolean> callback)
{
rewardCurrency(currency, client.getName(), client.getUniqueId(), reason, amount, true, callback);
}
/**
* Rewards the specified {@link CoreClient} with {@code amount} of {@code currency} because of {@code reason}
* This method will not retry the query if it fails
*
* @param updateTotal Whether to update the local value for {@code currency}
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link Boolean#TRUE} if the transaction succeeded
* {@link Boolean#FALSE} if the transaction failed, either during incrementation or sanity-checking
*/
public void rewardCurrency(GlobalCurrency currency, CoreClient client, String reason, int amount, boolean updateTotal, Consumer<Boolean> callback)
{
rewardCurrency(currency, client.getName(), client.getUniqueId(), reason, amount, updateTotal, callback);
}
// Private because volatile with playerName and playerUUID
private void rewardCurrency(GlobalCurrency currency, String playerName, UUID playerUUID, String reason, int amount, boolean updateTotal, Consumer<Boolean> callback)
{
_repository.reward(currency, playerName, reason, amount, success ->
{
if (success)
{
if (updateTotal)
{
Donor donor = Get(playerUUID);
if (donor != null)
{
donor.AddUnknownSalesPackagesOwned(packageName);
donor.DeductCost(cost, currencyType);
donor.addBalance(currency, amount);
}
}
if (callback != null)
callback.run(response);
}
}, name, accountId, packageName, currencyType, cost);
}
public void PurchaseKnownSalesPackage(final Callback<TransactionResponse> callback, final String name, final UUID uuid, final int cost, final int salesPackageId)
{
_repository.PurchaseKnownSalesPackage(new Callback<TransactionResponse>()
{
public void run(TransactionResponse response)
if (callback != null)
{
if (response == TransactionResponse.Success)
{
Donor donor = Get(uuid);
if (donor != null)
{
donor.AddSalesPackagesOwned(salesPackageId);
}
}
if (callback != null)
callback.run(response);
callback.accept(success);
}
}, name, uuid.toString(), cost, salesPackageId);
});
}
public void RewardGems(Callback<Boolean> callback, String caller, String name, UUID uuid, int amount)
/**
* Rewards the {@link Player} with {@code amount} of {@code currency} because of {@code reason}
* This method will retry the transaction for up to {@link DonationManager#MAX_GIVE_ATTEMPTS} attempts
*/
public void rewardCurrencyUntilSuccess(GlobalCurrency currency, Player player, String reason, int amount)
{
RewardGems(callback, caller, name, uuid, amount, true);
CoreClient client = _clientManager.Get(player);
rewardCurrencyUntilSuccess(currency, client.getName(), client.getUniqueId(), reason, amount, null);
}
public void RewardGems(final Callback<Boolean> callback, final String caller, final String name, final UUID uuid, final int amount, final boolean updateTotal)
/**
* Rewards the {@link Player} with {@code amount} of {@code currency} because of {@code reason}
* This method will retry the transaction for up to {@link DonationManager#MAX_GIVE_ATTEMPTS} attempts
*
* @param callback The callback which will be called on the main thread. Possible responses are:
* {@link Boolean#TRUE} if the transaction succeeded
* {@link Boolean#FALSE} if the transaction failed, either during incrementation or sanity-checking
*/
public void rewardCurrencyUntilSuccess(GlobalCurrency currency, Player player, String reason, int amount, Consumer<Boolean> callback)
{
_repository.gemReward(new Callback<Boolean>()
{
public void run(Boolean success)
{
if (success)
{
if (updateTotal)
{
Donor donor = Get(uuid);
if (donor != null)
{
donor.addBalance(GlobalCurrency.GEM, amount);
}
}
}
if (callback != null)
callback.run(success);
}
}, caller, name, uuid.toString(), amount);
CoreClient client = _clientManager.Get(player);
rewardCurrencyUntilSuccess(currency, client.getName(), client.getUniqueId(), reason, amount, callback);
}
public void RewardGemsLater(final String caller, final Player player, final int amount)
// private because volatile with name and accountId
private void rewardCurrencyUntilSuccess(GlobalCurrency currency, String name, UUID playerUUID, String reason, int amount, Consumer<Boolean> callback)
{
if (!_gemQueue.containsKey(player))
_gemQueue.put(player, new NautHashMap<String, Integer>());
int totalAmount = amount;
if (_gemQueue.get(player).containsKey(caller))
totalAmount += _gemQueue.get(player).get(caller);
_gemQueue.get(player).put(caller, totalAmount);
//Do Temp Change
Donor donor = Get(player.getUniqueId());
if (donor != null)
donor.addBalance(GlobalCurrency.GEM, amount);
}
@EventHandler
public void UpdateGemQueue(UpdateEvent event)
{
if (event.getType() != UpdateType.SLOWER)
return;
for (Player player : _gemQueue.keySet())
{
String caller = null;
int total = 0;
for (String curCaller : _gemQueue.get(player).keySet())
{
caller = curCaller;
total += _gemQueue.get(player).get(curCaller);
}
if (caller == null)
continue;
//Actually Add Gems
RewardGems(null, caller, player.getName(), player.getUniqueId(), total, false);
System.out.println("Queue Added [" + player + "] with Gems [" + total + "] for [" + caller + "]");
//Clean
_gemQueue.get(player).clear();
}
//Clean
_gemQueue.clear();
}
public void rewardCoinsUntilSuccess(Callback<Boolean> callback, String caller, String name, int accountId, int amount)
{
_coinAttemptQueue.add(new GiveDonorData(callback, name, caller, accountId, amount));
}
public void RewardCoins(Callback<Boolean> callback, String caller, String name, int accountId, int amount)
{
RewardCoins(callback, caller, name, accountId, amount, true);
}
public void RewardCoins(final Callback<Boolean> callback, final String caller, final String name, final int accountId, final int amount, final boolean updateTotal)
{
_repository.rewardCoins(new Callback<Boolean>()
{
public void run(Boolean success)
{
if (success)
{
if (updateTotal)
{
Donor donor = Get(name);
if (donor != null)
{
donor.addBalance(GlobalCurrency.TREASURE_SHARD, amount);
}
}
}
if (callback != null)
callback.run(success);
}
}, caller, name, accountId, amount);
}
public void RewardCoinsLater(final String caller, final Player player, final int amount)
{
if (!_coinQueue.containsKey(player))
_coinQueue.put(player, new NautHashMap<String, Integer>());
int totalAmount = amount;
if (_coinQueue.get(player).containsKey(caller))
totalAmount += _coinQueue.get(player).get(caller);
_coinQueue.get(player).put(caller, totalAmount);
//Do Temp Change
Donor donor = Get(player.getUniqueId());
if (donor != null)
donor.addBalance(GlobalCurrency.TREASURE_SHARD, amount);
}
@EventHandler
public void UpdateCoinQueue(UpdateEvent event)
{
if (event.getType() != UpdateType.SLOWER)
return;
for (final Player player : _coinQueue.keySet())
{
String tempCaller = null;
int tempTotal = 0;
for (String curCaller : _coinQueue.get(player).keySet())
{
tempCaller = curCaller;
tempTotal += _coinQueue.get(player).get(curCaller);
}
final int total = tempTotal;
final String caller = tempCaller;
if (caller == null)
continue;
if (player.isOnline() && player.isValid())
RewardCoins(null, caller, player.getName(), _clientManager.Get(player).getAccountId(), total, false);
else
{
Bukkit.getServer().getScheduler().runTaskAsynchronously(getPlugin(), new Runnable()
{
public void run()
{
RewardCoins(null, caller, player.getName(), PlayerCache.getInstance().getPlayer(player.getUniqueId()).getAccountId(), total, false);
}
});
}
System.out.println("Queue Added [" + player + "] with Coins [" + total + "] for [" + caller + "]");
//Clean
_coinQueue.get(player).clear();
}
//Clean
_coinQueue.clear();
}
@EventHandler
public void processCoinAttemptQueue(UpdateEvent event)
{
if (event.getType() != UpdateType.FAST)
return;
GiveDonorData data = _coinAttemptQueue.poll();
if (data != null)
{
_repository.rewardCoins(new Callback<Boolean>()
{
@Override
public void run(Boolean success)
{
if (success)
{
Donor donor = Get(data.getUuid());
if (donor != null)
{
donor.addBalance(GlobalCurrency.TREASURE_SHARD, data.getGiveAmount());
}
if (data.getCallback() != null) data.getCallback().run(true);
System.out.println("Successfully rewarded shards to player " + data.getPlayerName());
}
else
{
data.incrementAttempts();
if (data.getAttempts() >= MAX_GIVE_ATTEMPTS)
{
// Admit Defeat!
if (data.getCallback() != null) data.getCallback().run(false);
System.out.println("Gave up giving shards to player " + data.getPlayerName());
}
else
{
// Add again to the back of queue
_coinAttemptQueue.add(data);
System.out.println("Failed to reward shards to player " + data.getPlayerName() + ". Attempts: " + data.getAttempts());
}
}
}
}, data.getCaller(), data.getPlayerName(), data.getAccountId(), data.getGiveAmount());
}
_attemptUntilSuccess.computeIfAbsent(currency, key -> new LinkedList<>())
.add(new CurrencyRewardData(name, playerUUID, reason, amount, callback));
}
public void applyKits(String playerName)
@ -378,4 +317,56 @@ public class DonationManager extends MiniClientPlugin<Donor>
{
return new Donor();
}
private void processCoinAttemptQueue()
{
_attemptUntilSuccess.forEach((currency, playerMap) ->
{
CurrencyRewardData data = playerMap.poll();
if (data != null)
{
_repository.reward(currency, data.getPlayerName(), data.getReason(), data.getAmount(), success ->
{
if (success)
{
Donor donor = Get(data.getPlayerUUID());
if (donor != null)
{
donor.addBalance(currency, data.getAmount());
}
if (data.getCallback() != null)
{
data.getCallback().accept(true);
}
System.out.println("Successfully rewarded " + currency.getPrefix() + " to player " + data.getPlayerName());
}
else
{
data.incrementAttempts();
if (data.getAttempts() >= MAX_GIVE_ATTEMPTS)
{
// Admit Defeat!
if (data.getCallback() != null) data.getCallback().accept(false);
System.out.println("Gave up giving " + currency.getPrefix() + " to player " + data.getPlayerName());
}
else
{
playerMap.add(data);
System.out.println("Failed to reward " + currency.getPrefix() + " to player " + data.getPlayerName() + ". Attempts: " + data.getAttempts());
}
}
});
}
});
}
public CoreClientManager getClientManager()
{
return _clientManager;
}
}

180
Plugins/Mineplex.Core/src/mineplex/core/donation/Donor.java
View File

@ -11,123 +11,141 @@ import mineplex.core.donation.repository.token.CoinTransactionToken;
import mineplex.core.donation.repository.token.DonorToken;
import mineplex.core.donation.repository.token.TransactionToken;
/**
* Represents a player's donation information
*/
public class Donor
{
private final Map<GlobalCurrency, Integer> _balances = new HashMap<>();
private boolean _donated;
private List<Integer> _salesPackagesOwned = new ArrayList<Integer>();
private List<String> _unknownSalesPackagesOwned = new ArrayList<String>();
private List<TransactionToken> _transactions = new ArrayList<TransactionToken>();
private List<CoinTransactionToken> _coinTransactions = new ArrayList<CoinTransactionToken>();
private boolean _update = true;
public Donor() { }
public void loadToken(DonorToken token)
private List<Integer> _salesPackagesOwned = new ArrayList<>();
private List<String> _unknownSalesPackagesOwned = new ArrayList<>();
private List<TransactionToken> _transactions = new ArrayList<>();
private List<CoinTransactionToken> _coinTransactions = new ArrayList<>();
void loadToken(DonorToken token)
{
_balances.put(GlobalCurrency.GEM, token.Gems);
_balances.put(GlobalCurrency.TREASURE_SHARD, token.Coins);
_donated = token.Donated;
_salesPackagesOwned = token.SalesPackages;
_unknownSalesPackagesOwned = token.UnknownSalesPackages;
_transactions = token.Transactions;
_coinTransactions = token.CoinRewards;
_salesPackagesOwned = token.SalesPackages;
_unknownSalesPackagesOwned = token.UnknownSalesPackages;
_transactions = token.Transactions;
_coinTransactions = token.CoinRewards;
}
public List<Integer> GetSalesPackagesOwned()
{
return _salesPackagesOwned;
}
public List<String> GetUnknownSalesPackagesOwned()
{
return _unknownSalesPackagesOwned;
}
/**
* Get the known sales packages that this donor owns, local to this server
*/
public List<Integer> getOwnedKnownSalesPackages()
{
return _salesPackagesOwned;
}
public boolean Owns(Integer salesPackageId)
{
return salesPackageId == -1 || _salesPackagesOwned.contains(salesPackageId);
}
/**
* Get the unknown sales packages that this donor owns, local to this server
*/
public List<String> getOwnedUnknownSalesPackages()
{
return _unknownSalesPackagesOwned;
}
public void AddSalesPackagesOwned(int salesPackageId)
/**
* Checks whether this donor owns the specified known sales package, local to this server
*
* @return True if this donor owns the specified package, or if the id specified is -1
*/
public boolean ownsKnownSalesPackage(int id)
{
return id == -1 || _salesPackagesOwned.contains(id);
}
/**
* Checks whether this donor owns the specified unknown sales package, local to this server
*
* @param packageName The package name, case sensitive
*/
public boolean ownsUnknownSalesPackage(String packageName)
{
return _unknownSalesPackagesOwned.contains(packageName);
}
/**
* Adds a sales package to this donor, local to this server
*/
public void addOwnedKnownSalesPackage(int salesPackageId)
{
_salesPackagesOwned.add(salesPackageId);
}
public boolean HasDonated()
/**
* Adds an unknown sales package to this donor, local to this server
*
* @param packageName The package name, case sensitive
*/
public void addOwnedUnknownSalesPackage(String packageName)
{
return _donated;
_unknownSalesPackagesOwned.add(packageName);
}
public void DeductCost(int cost, GlobalCurrency currencyType)
{
addBalance(currencyType, -cost);
}
/**
* Removes a known sales package from this donor, local to this server
*/
public void removeOwnedKnownSalesPackage(int id)
{
_salesPackagesOwned.remove(id);
}
/**
* Removes an unknown sales package from this donor, local to this server
*
* @param packageName The package name, case sensitive
*/
public void removeOwnedUnknownSalesPackage(String packageName)
{
_unknownSalesPackagesOwned.remove(packageName);
}
/**
* Gets the balance of the specified currency for this donor, local to this server
*/
public int getBalance(GlobalCurrency currencyType)
{
return _balances.getOrDefault(currencyType, 0);
}
/**
* Modifies the balance of the specified currency by the given amount, local to this server
*
* @param amount The amount to modify the balance by. Can be positive or negative
*/
public void addBalance(GlobalCurrency currencyType, int amount)
{
_balances.merge(currencyType, amount, Integer::sum);
}
public boolean OwnsUnknownPackage(String packageName)
{
return _unknownSalesPackagesOwned.contains(packageName);
}
public boolean Updated()
{
return _update;
}
public void AddUnknownSalesPackagesOwned(String packageName)
{
_unknownSalesPackagesOwned.add(packageName);
}
public void RemoveUnknownSalesPackagesOwned(String packageName)
{
_unknownSalesPackagesOwned.remove(packageName);
}
/**
* Get the transactions associated to this player, local to this server
*/
public List<TransactionToken> getTransactions()
{
return _transactions;
}
public boolean OwnsUltraPackage()
{
for (String packageName : _unknownSalesPackagesOwned)
{
if (packageName.contains("ULTRA"))
return true;
}
return false;
}
/**
* Get the coin transactions associated to this player, local to this server
*/
public List<CoinTransactionToken> getCoinTransactions()
{
return _coinTransactions;
}
public void removeAllPackages(String packageName)
/**
* Clears all owned unknown packages with the given name, because it's a List
*
* @param packageName The name
*/
public void removeAllOwnedUnknownSalesPackages(String packageName)
{
Iterator<String> iterator = _unknownSalesPackagesOwned.iterator();
while (iterator.hasNext())
{
String pack = iterator.next();
if (pack.equals(packageName))
{
iterator.remove();
}
}
_unknownSalesPackagesOwned.removeIf(pack -> pack.equals(packageName));
}
}

71
Plugins/Mineplex.Core/src/mineplex/core/donation/GiveDonorData.java
View File

@ -1,71 +0,0 @@
package mineplex.core.donation;
import mineplex.core.common.util.Callback;
import java.util.UUID;
public class GiveDonorData
{
private final String _playerName;
private final String _caller;
private final UUID _uuid;
private final int _accountId;
private final int _giveAmount;
private final Callback<Boolean> _callback;
private int _attempts;
public GiveDonorData(Callback<Boolean> callback, String playerName, String caller, UUID uuid, int accountId, int giveAmount)
{
_callback = callback;
_playerName = playerName;
_caller = caller;
_uuid = uuid;
_accountId = accountId;
_giveAmount = giveAmount;
}
public GiveDonorData(Callback<Boolean> callback, String playerName, String caller, int accountId, int giveAmount)
{
this(callback, playerName, caller, null, accountId, giveAmount);
}
public UUID getUuid()
{
return _uuid;
}
public Callback<Boolean> getCallback()
{
return _callback;
}
public String getPlayerName()
{
return _playerName;
}
public String getCaller()
{
return _caller;
}
public int getAccountId()
{
return _accountId;
}
public int getGiveAmount()
{
return _giveAmount;
}
public int getAttempts()
{
return _attempts;
}
public void incrementAttempts()
{
_attempts++;
}
}

121
Plugins/Mineplex.Core/src/mineplex/core/donation/command/GemCommand.java
View File

@ -1,14 +1,13 @@
package mineplex.core.donation.command;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import mineplex.core.account.CoreClient;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.Callback;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UUIDFetcher;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.donation.DonationManager;
@ -30,100 +29,72 @@ public class GemCommand extends CommandBase<DonationManager>
}
String targetName = args[0];
String gemsString = args[1];
Player target = UtilPlayer.searchExact(targetName);
int amount;
try
{
amount = Integer.parseInt(args[1]);
}
catch (NumberFormatException ex)
{
UtilPlayer.message(caller, F.main("Gem", "Invalid gems Amount"));
return;
}
if (targetName.equalsIgnoreCase("@a"))
{
rewardAllGems(caller, gemsString);
}
else if (target == null)
{
UUID uuid = UUIDFetcher.getUUIDOf(targetName);
if (uuid != null)
{
rewardGems(caller, null, targetName, uuid, gemsString);
}
else
{
UtilPlayer.message(caller, F.main("Gem", "Could not find player " + F.name(targetName)));
}
rewardAllGems(caller, amount);
}
else
{
rewardGems(caller, target, target.getName(), target.getUniqueId(), gemsString);
}
}
private void rewardAllGems(Player caller, String gemsString)
{
try
{
int gems = Integer.parseInt(gemsString);
if (gems > 1000)
Plugin.getClientManager().getOrLoadClient(targetName, client ->
{
UtilPlayer.message(caller, F.main("Gem", "You can only give everybody 1000 gems at a time."));
return;
}
rewardAllGems(caller, gems);
}
catch (Exception e)
{
UtilPlayer.message(caller, F.main("Gem", "Invalid gems Amount"));
if (client != null)
{
rewardGems(caller, client, amount);
}
else
{
UtilPlayer.message(caller, F.main("Gem", "Could not find player " + F.name(targetName)));
}
});
}
}
private void rewardAllGems(Player caller, int gems)
{
if (gems > 1000)
{
UtilPlayer.message(caller, F.main("Gem", "You can only give everybody 1000 gems at a time."));
return;
}
for (Player player : UtilServer.getPlayers())
{
Plugin.RewardGems(new Callback<Boolean>()
{
public void run(Boolean completed)
{
}
}, caller.getName(), player.getName(), player.getUniqueId(), gems);
Plugin.rewardCurrency(GlobalCurrency.GEM, player, caller.getName(), gems);
}
UtilPlayer.message(caller, F.main("Gem", "Gave everyone " + F.elem(gems + " gems")));
}
private void rewardGems(final Player caller, final Player target, final String targetName, final UUID uuid, String gemsString)
private void rewardGems(Player caller, CoreClient target, int gems)
{
try
Plugin.rewardCurrency(GlobalCurrency.GEM, target, caller.getName(), gems, completed ->
{
int gems = Integer.parseInt(gemsString);
rewardGems(caller, target, targetName, uuid, gems);
}
catch (Exception e)
{
UtilPlayer.message(caller, F.main("Gem", "Invalid gems Amount"));
}
}
private void rewardGems(final Player caller, final Player target, final String targetName, final UUID uuid, final int gems)
{
Plugin.RewardGems(new Callback<Boolean>()
{
public void run(Boolean completed)
if (completed)
{
if (completed)
UtilPlayer.message(caller, F.main("Gem", "You gave " + F.elem(gems + " gems") + " to " + F.name(target.getRealOrDisguisedName()) + "."));
if (Bukkit.getPlayer(target.getUniqueId()) != null)
{
UtilPlayer.message(caller, F.main("Gem", "You gave " + F.elem(gems + " gems") + " to " + F.name(targetName) + "."));
if (target != null)
{
UtilPlayer.message(target, F.main("Gem", F.name(caller.getName()) + " gave you " + F.elem(gems + " gems") + "."));
}
}
else
{
UtilPlayer.message(caller, F.main("Gem", "There was an error giving " + F.elem(gems + " gems") + " to " + F.name(targetName) + "."));
UtilPlayer.message(Bukkit.getPlayer(target.getUniqueId()), F.main("Gem", F.name(caller.getName()) + " gave you " + F.elem(gems + " gems") + "."));
}
}
}, caller.getName(), targetName, uuid, gems);
else
{
UtilPlayer.message(caller, F.main("Gem", "There was an error giving " + F.elem(gems + " gems") + " to " + F.name(target.getRealOrDisguisedName()) + "."));
}
});
}
}

110
Plugins/Mineplex.Core/src/mineplex/core/donation/command/ShardCommand.java
View File

@ -1,14 +1,16 @@
package mineplex.core.donation.command;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import mineplex.core.account.CoreClient;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.Callback;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.donation.DonationManager;
import org.bukkit.entity.Player;
public class ShardCommand extends CommandBase<DonationManager>
{
@ -27,102 +29,72 @@ public class ShardCommand extends CommandBase<DonationManager>
}
final String targetName = args[0];
final String coinsString = args[1];
Player target = UtilPlayer.searchExact(targetName);
int amount;
try
{
amount = Integer.parseInt(args[1]);
}
catch (NumberFormatException ex)
{
UtilPlayer.message(caller, F.main("Shards", "Invalid Shards Amount"));
return;
}
if (targetName.equalsIgnoreCase("@a"))
{
rewardAllShards(caller, coinsString);
rewardAllShards(caller, amount);
}
else if (target == null)
else
{
Plugin.getClientManager().loadClientByName(targetName, client ->
Plugin.getClientManager().getOrLoadClient(targetName, client ->
{
if (client != null)
rewardCoins(caller, null, targetName, client.getAccountId(), coinsString);
{
rewardCoins(caller, client, amount);
}
else
{
UtilPlayer.message(caller, F.main("Shards", "Could not find player " + F.name(targetName)));
}
});
}
else
{
rewardCoins(caller, target, target.getName(), Plugin.getClientManager().Get(target).getAccountId(), coinsString);
}
}
private void rewardAllShards(Player caller, String shardsString)
{
try
{
int shards = Integer.parseInt(shardsString);
if (shards > 1000)
{
UtilPlayer.message(caller, F.main("Shards", "You can only give everybody 1000 shards at a time."));
return;
}
rewardAllShards(caller, shards);
}
catch (Exception e)
{
UtilPlayer.message(caller, F.main("Shards", "Invalid Shards Amount"));
}
}
private void rewardAllShards(Player caller, int shards)
{
if (shards > 1000)
{
UtilPlayer.message(caller, F.main("Shards", "You can only give everybody 1000 shards at a time."));
return;
}
for (Player player : UtilServer.getPlayers())
{
CoreClient client = Plugin.getClientManager().Get(player);
Plugin.RewardCoins(new Callback<Boolean>()
{
public void run(Boolean completed)
{
}
}, caller.getName(), player.getName(), client.getAccountId(), shards);
Plugin.rewardCurrency(GlobalCurrency.TREASURE_SHARD, player, caller.getName(), shards);
}
UtilPlayer.message(caller, F.main("Shards", "Gave everyone " + F.elem(shards + " Treasure Shards")));
}
private void rewardCoins(final Player caller, final Player target, final String targetName, final int accountId, String coinsString)
private void rewardCoins(Player caller, CoreClient target, int coins)
{
try
Plugin.rewardCurrency(GlobalCurrency.TREASURE_SHARD, target, caller.getName(), coins, completed ->
{
int coins = Integer.parseInt(coinsString);
rewardCoins(caller, target, targetName, accountId, coins);
}
catch (Exception e)
{
UtilPlayer.message(caller, F.main("Shards", "Invalid Shards Amount"));
}
}
private void rewardCoins(final Player caller, final Player target, final String targetName, final int accountId, final int coins)
{
Plugin.RewardCoins(new Callback<Boolean>()
{
public void run(Boolean completed)
if (completed)
{
if (completed)
UtilPlayer.message(caller, F.main("Shards", "You gave " + F.elem(coins + " Treasure Shards") + " to " + F.name(target.getRealOrDisguisedName()) + "."));
if (Bukkit.getPlayer(target.getUniqueId()) != null)
{
UtilPlayer.message(caller, F.main("Shards", "You gave " + F.elem(coins + " Treasure Shards") + " to " + F.name(targetName) + "."));
if (target != null)
{
UtilPlayer.message(target, F.main("Shards", F.name(caller.getName()) + " gave you " + F.elem(coins + " Treasure Shards") + "."));
}
}
else
{
UtilPlayer.message(caller, F.main("Shards", "There was an error giving " + F.elem(coins + "Treasure Shards") + " to " + F.name(targetName) + "."));
UtilPlayer.message(Bukkit.getPlayer(target.getUniqueId()), F.main("Shards", F.name(caller.getName()) + " gave you " + F.elem(coins + " Treasure Shards") + "."));
}
}
}, caller.getName(), targetName, accountId, coins);
else
{
UtilPlayer.message(caller, F.main("Shards", "There was an error giving " + F.elem(coins + "Treasure Shards") + " to " + F.name(target.getRealOrDisguisedName()) + "."));
}
});
}
}

234
Plugins/Mineplex.Core/src/mineplex/core/donation/repository/DonationRepository.java
View File

@ -1,8 +1,12 @@
package mineplex.core.donation.repository;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import mineplex.core.common.currency.Currency;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.UtilTasks;
import mineplex.core.database.MinecraftRepository;
import mineplex.core.donation.repository.token.GemRewardToken;
import mineplex.core.donation.repository.token.PurchaseToken;
@ -12,193 +16,101 @@ import mineplex.core.server.remotecall.JsonWebCall;
import mineplex.core.server.util.TransactionResponse;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.DatabaseRunnable;
import mineplex.serverdata.database.column.ColumnInt;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;
public class DonationRepository extends MinecraftRepository
{
private static String CREATE_COIN_TRANSACTION_TABLE = "CREATE TABLE IF NOT EXISTS accountCoinTransactions (id INT NOT NULL AUTO_INCREMENT, accountId INT, reason VARCHAR(100), coins INT, PRIMARY KEY (id), FOREIGN KEY (accountId) REFERENCES accounts(id));";
private static String CREATE_GEM_TRANSACTION_TABLE = "CREATE TABLE IF NOT EXISTS accountGemTransactions (id INT NOT NULL AUTO_INCREMENT, accountId INT, reason VARCHAR(100), gems INT, PRIMARY KEY (id), FOREIGN KEY (accountId) REFERENCES accounts(id));";
private static String INSERT_COIN_TRANSACTION = "INSERT INTO accountCoinTransactions(accountId, reason, coins) VALUES(?, ?, ?);";
private static String UPDATE_ACCOUNT_COINS = "UPDATE accounts SET coins = coins + ? WHERE id = ?;";
private static String UPDATE_NULL_ACCOUNT_GEMS_AND_COINS_ = "UPDATE accounts SET gems = ?, coins = ? WHERE id = ? AND gems IS NULL AND coins IS NULL;";
private static Map<GlobalCurrency, String> WEB_ADDRESSES = new HashMap<>();
private String _webAddress;
public DonationRepository(JavaPlugin plugin, String webAddress)
static
{
super(plugin, DBPool.getAccount());
_webAddress = webAddress;
WEB_ADDRESSES.put(GlobalCurrency.GEM, "PlayerAccount/GemReward");
WEB_ADDRESSES.put(GlobalCurrency.TREASURE_SHARD, "PlayerAccount/CoinReward");
}
public void PurchaseKnownSalesPackage(final Callback<TransactionResponse> callback, String name, final String uuid, final int cost, final int salesPackageId)
public DonationRepository()
{
final PurchaseToken token = new PurchaseToken();
token.AccountName = name;
super(DBPool.getAccount());
}
/**
* Purchases a known sales package.. whatever that means
*
* @param playerName The player name
* @param salesPackageId The package id
* @param callback The callback, may be null, will be run on the main thread
*/
public void purchaseKnownSalesPackage(String playerName, int salesPackageId, Consumer<TransactionResponse> callback)
{
PurchaseToken token = new PurchaseToken();
token.AccountName = playerName;
token.UsingCredits = false;
token.SalesPackageId = salesPackageId;
final Callback<TransactionResponse> extraCallback = new Callback<TransactionResponse>()
{
public void run(final TransactionResponse response)
{
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
callback.run(response);
}
});
}
};
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
new JsonWebCall(_webAddress + "PlayerAccount/PurchaseKnownSalesPackage").Execute(TransactionResponse.class, extraCallback, token);
}
}), "Error purchasing known sales package in DonationRepository : ");
handleMSSQLCall(
"PlayerAccount/PurchaseKnownSalesPackage",
String.format("Error purchasing known sales package %s for %s: ", salesPackageId, playerName),
token,
TransactionResponse.class,
UtilTasks.onMainThread(callback)
);
}
public void PurchaseUnknownSalesPackage(final Callback<TransactionResponse> callback, final String name, final int accountId, final String packageName, final Currency currencyType, final int cost)
/**
* Purchases an unknown sales package... or something
*
* @param playerName The name of the player
* @param packageName The name of the unknown package
* @param currencyType The type of currency
* @param cost The cost
* @param callback The callback, may be null. Will be run on the main thread
*/
public void purchaseUnknownSalesPackage(String playerName, String packageName, Currency currencyType, int cost, Consumer<TransactionResponse> callback)
{
final UnknownPurchaseToken token = new UnknownPurchaseToken();
token.AccountName = name;
UnknownPurchaseToken token = new UnknownPurchaseToken();
token.AccountName = playerName;
token.SalesPackageName = packageName;
token.CoinPurchase = currencyType == GlobalCurrency.TREASURE_SHARD;
token.Cost = cost;
token.Premium = false;
final Callback<TransactionResponse> extraCallback = new Callback<TransactionResponse>()
{
public void run(final TransactionResponse response)
{
if (response == TransactionResponse.Success)
{
if (currencyType == GlobalCurrency.TREASURE_SHARD)
{
executeUpdate(UPDATE_ACCOUNT_COINS, new ColumnInt("coins", -cost), new ColumnInt("id", accountId));
//executeUpdate(INSERT_COIN_TRANSACTION, new ColumnInt("id", accountId), new ColumnVarChar("reason", 100, "Purchased " + packageName), new ColumnInt("coins", -cost));
}
}
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
callback.run(response);
}
});
}
};
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
new JsonWebCall(_webAddress + "PlayerAccount/PurchaseUnknownSalesPackage").Execute(TransactionResponse.class, extraCallback, token);
}
}), "Error purchasing unknown sales package in DonationRepository : ");
handleMSSQLCall(
"PlayerAccount/PurchaseUnknownSalesPackage",
String.format("Error purchasing unknown sales package %s for %s: ", packageName, playerName),
token,
TransactionResponse.class,
UtilTasks.onMainThread(callback)
);
}
public void gemReward(final Callback<Boolean> callback, final String giver, String name, final String uuid, final int greenGems)
/**
* Update a player's currency on the MSSQL server.
*
* @param currency The type of currency
* @param playerName The name of the player
* @param reason The reason of rewarding currency
* @param amount The amount (positive or negative)
* @param callback The callback, can be null. This will be run on the main thread
*/
public void reward(GlobalCurrency currency, String playerName, String reason, int amount, Consumer<Boolean> callback)
{
final GemRewardToken token = new GemRewardToken();
token.Source = giver;
token.Name = name;
token.Amount = greenGems;
GemRewardToken token = new GemRewardToken();
token.Source = reason;
token.Name = playerName;
token.Amount = amount;
final Callback<Boolean> extraCallback = new Callback<Boolean>()
{
public void run(final Boolean response)
{
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
callback.run(response);
}
});
}
};
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
new JsonWebCall(_webAddress + "PlayerAccount/GemReward").Execute(Boolean.class, extraCallback, token);
}
}), "Error updating player gem amount in DonationRepository : ");
}
public void rewardCoins(final Callback<Boolean> callback, final String giver, String name, final int accountId, final int coins)
{
final GemRewardToken token = new GemRewardToken();
token.Source = giver;
token.Name = name;
token.Amount = coins;
final Callback<Boolean> extraCallback = new Callback<Boolean>()
{
public void run(final Boolean response)
{
if (response)
{
//executeUpdate(UPDATE_ACCOUNT_COINS, new ColumnInt("coins", coins), new ColumnInt("id", accountId));
//executeUpdate(INSERT_COIN_TRANSACTION, new ColumnInt("id", accountId), new ColumnVarChar("reason", 100, "Rewarded by " + giver), new ColumnInt("coins", coins));
}
Bukkit.getServer().getScheduler().runTask(getPlugin(), new Runnable()
{
@Override
public void run()
{
callback.run(response);
}
});
}
};
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
new JsonWebCall(_webAddress + "PlayerAccount/CoinReward").Execute(Boolean.class, extraCallback, token);
}
}), "Error updating player coin amount in DonationRepository : ");
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_COIN_TRANSACTION_TABLE);
//executeUpdate(CREATE_GEM_TRANSACTION_TABLE);
}
@Override
protected void update()
{
}
public void updateGemsAndCoins(final int accountId, final int gems, final int coins)
{
handleDatabaseCall(new DatabaseRunnable(new Runnable()
{
public void run()
{
executeUpdate(UPDATE_NULL_ACCOUNT_GEMS_AND_COINS_, new ColumnInt("gems", gems), new ColumnInt("coins", coins), new ColumnInt("id", accountId));
}
}), "Error updating player's null gems and coins DonationRepository : ");
handleMSSQLCall(
WEB_ADDRESSES.get(currency),
String.format("Error updating %s for %s: ", currency.getString(2), playerName),
token,
Boolean.class,
UtilTasks.onMainThread(callback)
);
}
public void applyKits(String playerName)
{
new AsyncJsonWebCall(_webAddress + "PlayerAccount/ApplyKits").Execute(playerName);
handleAsyncMSSQLCall("PlayerAccount/ApplyKits", playerName);
}
}

13
Plugins/Mineplex.Core/src/mineplex/core/elo/EloRepository.java
View File

@ -37,13 +37,7 @@ public class EloRepository extends MinecraftRepository
public EloRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
initialize();
}
public void initialize()
{
super(DBPool.getAccount());
}
public boolean saveElo(int accountId, int gameType, int oldElo, int elo) throws SQLException
@ -204,11 +198,6 @@ public class EloRepository extends MinecraftRepository
Bukkit.getScheduler().runTaskAsynchronously(getPlugin(), () -> executeUpdate(DELETE_STRIKES, new ColumnInt("accountId", accountId)));
}
@Override
protected void update()
{
}
public void getTopElo(int limit, Callback<List<TopEloData>> callback)
{
int gameId = 62;

15
Plugins/Mineplex.Core/src/mineplex/core/facebook/FacebookRepository.java
View File

@ -8,7 +8,6 @@ import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.common.util.Callback;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -20,19 +19,7 @@ public class FacebookRepository extends MinecraftRepository
public FacebookRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public void getCode(String codeName, Callback<FacebookCode> callback)

13
Plugins/Mineplex.Core/src/mineplex/core/friend/data/FriendRepository.java
View File

@ -36,23 +36,12 @@ public class FriendRepository extends MinecraftRepository
public FriendRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_repository = new RedisDataRepository<PlayerStatus>(ServerManager.getMasterConnection(), ServerManager.getSlaveConnection(),
Region.currentRegion(), PlayerStatus.class, "playerStatus");
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_FRIEND_TABLE);
}
@Override
protected void update()
{
}
public boolean addFriend(final Player caller, String name)
{
int rowsAffected = executeUpdate(ADD_FRIEND_RECORD, new ColumnVarChar("status", 100, "Sent"), new ColumnVarChar("name", 100, name), new ColumnVarChar("name", 100, caller.getName()));

10
Plugins/Mineplex.Core/src/mineplex/core/gadget/commands/LockCosmeticsCommand.java
View File

@ -72,9 +72,9 @@ public class LockCosmeticsCommand extends CommandBase<GadgetManager>
names[i++] = gadget.getName();
for (String name : names)
{
if (donor.OwnsUnknownPackage(name))
if (donor.ownsUnknownSalesPackage(name))
{
donor.removeAllPackages(name);
donor.removeAllOwnedUnknownSalesPackages(name);
removed++;
}
}
@ -89,14 +89,14 @@ public class LockCosmeticsCommand extends CommandBase<GadgetManager>
int removed = 0;
for (Mount<?> mount : _plugin.getMountManager().getMounts())
{
if (donor.OwnsUnknownPackage(mount.getName()))
if (donor.ownsUnknownSalesPackage(mount.getName()))
{
donor.removeAllPackages(mount.getName());
donor.removeAllOwnedUnknownSalesPackages(mount.getName());
removed++;
}
else if (mount.hasMount(caller))
{
donor.removeAllPackages(mount.getName());
donor.removeAllOwnedUnknownSalesPackages(mount.getName());
removed++;
}
}

6
Plugins/Mineplex.Core/src/mineplex/core/gadget/commands/LockInfusedCommand.java
View File

@ -67,14 +67,14 @@ public class LockInfusedCommand extends CommandBase<GadgetManager>
for (Gadget gadget : infusedItems)
{
_manager.getDonationManager().Get(player).removeAllPackages(gadget.getName());
_manager.getDonationManager().Get(player).removeAllOwnedUnknownSalesPackages(gadget.getName());
for (String possibleName : gadget.getAlternativePackageNames())
{
_manager.getDonationManager().Get(player).removeAllPackages(possibleName);
_manager.getDonationManager().Get(player).removeAllOwnedUnknownSalesPackages(possibleName);
}
}
_manager.getDonationManager().Get(player).removeAllPackages(mount.getName());
_manager.getDonationManager().Get(player).removeAllOwnedUnknownSalesPackages(mount.getName());
}

10
Plugins/Mineplex.Core/src/mineplex/core/gadget/commands/UnlockCosmeticsCommand.java
View File

@ -73,14 +73,14 @@ public class UnlockCosmeticsCommand extends CommandBase<GadgetManager>
names[i++] = gadget.getName();
for (String name : names)
{
if (donor.OwnsUnknownPackage(name))
if (donor.ownsUnknownSalesPackage(name))
{
hasGadget = true;
}
}
if (!hasGadget)
{
donor.AddUnknownSalesPackagesOwned(gadget.getName());
donor.addOwnedUnknownSalesPackage(gadget.getName());
added++;
}
}
@ -94,14 +94,14 @@ public class UnlockCosmeticsCommand extends CommandBase<GadgetManager>
int added = 0;
for (Mount<?> mount : _plugin.getMountManager().getMounts())
{
if (!donor.OwnsUnknownPackage(mount.getName()))
if (!donor.ownsUnknownSalesPackage(mount.getName()))
{
donor.AddUnknownSalesPackagesOwned(mount.getName());
donor.addOwnedUnknownSalesPackage(mount.getName());
added++;
}
else if (!mount.hasMount(caller))
{
donor.AddUnknownSalesPackagesOwned(mount.getName());
donor.addOwnedUnknownSalesPackage(mount.getName());
added++;
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/arrowtrail/titan/ArrowTrailTitan.java
View File

@ -45,7 +45,7 @@ public class ArrowTrailTitan extends ArrowEffectGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/death/titan/DeathTitan.java
View File

@ -34,7 +34,7 @@ public class DeathTitan extends DeathEffectGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/doublejump/titan/DoubleJumpTitan.java
View File

@ -39,7 +39,7 @@ public class DoubleJumpTitan extends DoubleJumpEffectGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

6
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/item/ItemCoal.java
View File

@ -105,7 +105,7 @@ public class ItemCoal extends ItemGadget
Manager.getInventoryManager().addItemToInventory(player, getName(), -_hat);
player.getInventory().setItem(Manager.getActiveItemSlot(), ItemStackFactory.Instance.CreateStack(getDisplayMaterial(), getDisplayData(), 1, F.item(Manager.getInventoryManager().Get(player).getItemCount(getName()) + " " + getName())));
Manager.getDonationManager().Get(player).AddUnknownSalesPackagesOwned("Lump of Coal Hat");
Manager.getDonationManager().Get(player).addOwnedUnknownSalesPackage("Lump of Coal Hat");
}
else
{
@ -147,7 +147,7 @@ public class ItemCoal extends ItemGadget
Manager.getInventoryManager().addItemToInventory(player, getName(), -_pet);
player.getInventory().setItem(Manager.getActiveItemSlot(), ItemStackFactory.Instance.CreateStack(getDisplayMaterial(), getDisplayData(), 1, F.item(Manager.getInventoryManager().Get(player).getItemCount(getName()) + " " + getName())));
Manager.getDonationManager().Get(player).AddUnknownSalesPackagesOwned("Coal Apparition");
Manager.getDonationManager().Get(player).addOwnedUnknownSalesPackage("Coal Apparition");
}
});
@ -180,7 +180,7 @@ public class ItemCoal extends ItemGadget
Manager.getInventoryManager().addItemToInventory(player, getName(), -_particle);
player.getInventory().setItem(Manager.getActiveItemSlot(), ItemStackFactory.Instance.CreateStack(getDisplayMaterial(), getDisplayData(), 1, F.item(Manager.getInventoryManager().Get(player).getItemCount(getName()) + " " + getName())));
Manager.getDonationManager().Get(player).AddUnknownSalesPackagesOwned("Coal Fumes");
Manager.getDonationManager().Get(player).addOwnedUnknownSalesPackage("Coal Fumes");
}
else
{

55
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/item/ItemCoinBomb.java
View File

@ -16,6 +16,7 @@ import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.LineFormat;
import mineplex.core.common.util.UtilAction;
@ -34,14 +35,14 @@ public class ItemCoinBomb extends ItemGadget
{
private HashMap<Item, Long> _active = new HashMap<Item, Long>();
private HashSet<Item> _coins = new HashSet<Item>();
public ItemCoinBomb(GadgetManager manager)
{
super(manager, "Treasure Party Bomb",
UtilText.splitLineToArray(C.cWhite + "It's party time! You'll be everyone's favourite player when you use one of these!", LineFormat.LORE),
-1,
Material.PRISMARINE, (byte)0,
30000, new Ammo("Treasure Party Bomb", "1 Coin Party Bomb", Material.PRISMARINE, (byte)0, new String[] { C.cWhite + "1 Treasure Party Bomb" }, 2000, 1));
super(manager, "Treasure Party Bomb",
UtilText.splitLineToArray(C.cWhite + "It's party time! You'll be everyone's favourite player when you use one of these!", LineFormat.LORE),
-1,
Material.PRISMARINE, (byte) 0,
30000, new Ammo("Treasure Party Bomb", "1 Coin Party Bomb", Material.PRISMARINE, (byte) 0, new String[]{C.cWhite + "1 Treasure Party Bomb"}, 2000, 1));
}
@Override
@ -50,20 +51,20 @@ public class ItemCoinBomb extends ItemGadget
Item item = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()), new ItemStack(Material.PRISMARINE));
UtilAction.velocity(item, player.getLocation().getDirection(), 1, false, 0, 0.2, 1, false);
_active.put(item, System.currentTimeMillis());
//Inform
for (Player other : UtilServer.getPlayers())
UtilPlayer.message(other, C.cAqua + C.Bold + player.getName() + C.cWhite + C.Bold + " has thrown a " + C.cAqua + C.Bold + "Treasure Party Bomb" + C.cWhite + C.Bold + "!");
}
@EventHandler
public void Update(UpdateEvent event)
{
if (event.getType() != UpdateType.TICK)
return;
Iterator<Item> itemIterator = _active.keySet().iterator();
while (itemIterator.hasNext())
{
Item item = itemIterator.next();
@ -75,20 +76,20 @@ public class ItemCoinBomb extends ItemGadget
UtilFirework.playFirework(item.getLocation(), FireworkEffect.builder().flicker(false).withColor(Color.AQUA).with(Type.BURST).trail(false).build());
else
item.getWorld().playSound(item.getLocation(), Sound.FIREWORK_LAUNCH, 1f, 1f);
Item coin = item.getWorld().dropItem(item.getLocation().add(0, 1, 0), new ItemStack(Material.PRISMARINE_SHARD));
//Velocity
long passed = System.currentTimeMillis() - time;
Vector vel = new Vector(Math.sin(passed/300d), 0, Math.cos(passed/300d));
UtilAction.velocity(coin, vel, Math.abs(Math.sin(passed/3000d)), false, 0, 0.2 + Math.abs(Math.cos(passed/3000d))*0.8, 1, false);
Vector vel = new Vector(Math.sin(passed / 300d), 0, Math.cos(passed / 300d));
UtilAction.velocity(coin, vel, Math.abs(Math.sin(passed / 3000d)), false, 0, 0.2 + Math.abs(Math.cos(passed / 3000d)) * 0.8, 1, false);
coin.setPickupDelay(40);
_coins.add(coin);
}
if (UtilTime.elapsed(time, 23000))
{
item.remove();
@ -96,7 +97,7 @@ public class ItemCoinBomb extends ItemGadget
}
}
}
@EventHandler
public void Pickup(PlayerPickupItemEvent event)
{
@ -108,27 +109,27 @@ public class ItemCoinBomb extends ItemGadget
{
event.setCancelled(true);
event.getItem().remove();
Manager.getDonationManager().RewardCoinsLater(getName() + " Pickup", event.getPlayer(), 4);
Manager.getDonationManager().rewardCurrency(GlobalCurrency.TREASURE_SHARD, event.getPlayer(), getName() + " Pickup", 4);
event.getPlayer().getWorld().playSound(event.getPlayer().getLocation(), Sound.ORB_PICKUP, 1f, 2f);
//UtilPlayer.message(event.getPlayer(), C.cGreen + C.Bold + "+4 Gems");
}
}
@EventHandler
public void Clean(UpdateEvent event)
{
if (event.getType() != UpdateType.FAST)
return;
Iterator<Item> coinIterator = _coins.iterator();
while (coinIterator.hasNext())
{
Item coin = coinIterator.next();
if (!coin.isValid() || coin.getTicksLived() > 1200)
{
coin.remove();

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphBlaze.java
View File

@ -83,7 +83,7 @@ public class MorphBlaze extends MorphGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.HERO))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

108
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphBunny.java
View File

@ -46,23 +46,23 @@ import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
public class MorphBunny extends MorphGadget
{
{
private HashSet<Player> _jumpCharge = new HashSet<Player>();
private HashMap<Item, String> _eggs = new HashMap<Item, String>();
public MorphBunny(GadgetManager manager)
{
super(manager, "Easter Bunny Morph", UtilText.splitLinesToArray(new String[]
{
C.cGray + "Happy Easter!",
C.blankLine,
"#" + C.cWhite + "Charge Crouch to use Super Jump",
"#" + C.cWhite + "Left Click to use Hide Easter Egg",
C.blankLine,
"#" + C.cRed +C.Bold + "WARNING: " + ChatColor.RESET + "Hide Easter Egg uses 500 Shards" ,
}, LineFormat.LORE),
super(manager, "Easter Bunny Morph", UtilText.splitLinesToArray(new String[]
{
C.cGray + "Happy Easter!",
C.blankLine,
"#" + C.cWhite + "Charge Crouch to use Super Jump",
"#" + C.cWhite + "Left Click to use Hide Easter Egg",
C.blankLine,
"#" + C.cRed + C.Bold + "WARNING: " + ChatColor.RESET + "Hide Easter Egg uses 500 Shards",
}, LineFormat.LORE),
-5,
Material.MONSTER_EGG, (byte)98);
Material.MONSTER_EGG, (byte) 98);
}
@Override
@ -86,17 +86,17 @@ public class MorphBunny extends MorphGadget
player.removePotionEffect(PotionEffectType.SPEED);
player.removePotionEffect(PotionEffectType.JUMP);
}
@EventHandler
public void jumpTrigger(PlayerToggleSneakEvent event)
{
Player player = event.getPlayer();
if (!isActive(player))
return;
//Start
if (!event.getPlayer().isSneaking())
{
@ -108,13 +108,13 @@ public class MorphBunny extends MorphGadget
{
float power = player.getExp();
player.setExp(0f);
UtilAction.velocity(player, power * 4, 0.4, 4, true);
player.getWorld().playSound(player.getLocation(), Sound.CAT_HIT, 0.75f, 2f);
}
}
@EventHandler
public void jumpBoost(UpdateEvent event)
{
@ -122,23 +122,23 @@ public class MorphBunny extends MorphGadget
return;
Iterator<Player> jumpIter = _jumpCharge.iterator();
while (jumpIter.hasNext())
{
Player player = jumpIter.next();
if (!player.isValid() || !player.isOnline() || !player.isSneaking())
{
jumpIter.remove();
continue;
}
player.setExp(Math.min(0.9999f, player.getExp() + 0.03f));
player.playSound(player.getLocation(), Sound.FIZZ, 0.25f + player.getExp() * 0.5f, 0.5f + player.getExp());
}
}
@EventHandler
public void eggHide(PlayerInteractEvent event)
{
@ -155,85 +155,85 @@ public class MorphBunny extends MorphGadget
UtilPlayer.message(player, F.main("Gadget", "You do not have enough Shards."));
return;
}
if (!Recharge.Instance.use(player, "Hide Egg", 30000, true, false))
return;
//Color
//Item
ItemStack eggStack = ItemStackFactory.Instance.CreateStack(Material.MONSTER_EGG, (byte)0, 1, "Hidden Egg" + System.currentTimeMillis());
ItemStack eggStack = ItemStackFactory.Instance.CreateStack(Material.MONSTER_EGG, (byte) 0, 1, "Hidden Egg" + System.currentTimeMillis());
eggStack.setDurability((short) 98);
Item egg = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()), eggStack);
UtilAction.velocity(egg, player.getLocation().getDirection(), 0.2, false, 0, 0.2, 1, false);
Manager.getDonationManager().RewardCoinsLater(this.getName() + " Egg Hide", player, -500);
Manager.getDonationManager().rewardCurrency(GlobalCurrency.TREASURE_SHARD, player, this.getName() + " Egg Hide", -500);
egg.setPickupDelay(40);
_eggs.put(egg, player.getName());
//Announce
Bukkit.broadcastMessage(C.cYellow + C.Bold + player.getName() +
Bukkit.broadcastMessage(C.cYellow + C.Bold + player.getName() +
ChatColor.RESET + C.Bold + " hid an " +
C.cYellow + C.Bold + "Easter Egg" +
ChatColor.RESET + C.Bold + " worth " +
C.cYellow + C.Bold + "450 Shards");
for (Player other : UtilServer.getPlayers())
other.playSound(other.getLocation(), Sound.CAT_HIT, 1.5f, 1.5f);
}
@EventHandler
public void eggPickup(PlayerPickupItemEvent event)
{
if (_eggs.containsKey(event.getItem()) && !_eggs.get(event.getItem()).equals(event.getPlayer().getName()))
{
_eggs.remove(event.getItem());
event.setCancelled(true);
event.getItem().remove();
Manager.getDonationManager().RewardCoinsLater(getName() + " Egg Pickup", event.getPlayer(), 450);
Manager.getDonationManager().rewardCurrency(GlobalCurrency.TREASURE_SHARD, event.getPlayer(), getName() + " Egg Pickup", 450);
event.getPlayer().getWorld().playSound(event.getPlayer().getLocation(), Sound.ORB_PICKUP, 1.5f, 0.75f);
event.getPlayer().getWorld().playSound(event.getPlayer().getLocation(), Sound.ORB_PICKUP, 1.5f, 1.25f);
UtilFirework.playFirework(event.getItem().getLocation(), Type.BURST, Color.YELLOW, true, true);
//Announce
Bukkit.broadcastMessage(C.cGold + C.Bold + event.getPlayer().getName() +
Bukkit.broadcastMessage(C.cGold + C.Bold + event.getPlayer().getName() +
ChatColor.RESET + C.Bold + " found an " +
C.cGold + C.Bold + "Easter Egg" +
ChatColor.RESET + C.Bold + "! " + _eggs.size() + " Eggs left!");
}
}
}
@EventHandler
public void eggClean(UpdateEvent event)
{
if (event.getType() != UpdateType.FAST)
return;
Iterator<Item> eggIter = _eggs.keySet().iterator();
while (eggIter.hasNext())
{
Item egg = eggIter.next();
if (!egg.isValid() || egg.getTicksLived() > 24000)
{
egg.remove();
eggIter.remove();
//Announce
Bukkit.broadcastMessage(
ChatColor.RESET + C.Bold + "No one found an " +
C.cGold + C.Bold + "Easter Egg" +
ChatColor.RESET + C.Bold + "! " + _eggs.size() + " Eggs left!");
C.cGold + C.Bold + "Easter Egg" +
ChatColor.RESET + C.Bold + "! " + _eggs.size() + " Eggs left!");
}
else
{
@ -242,7 +242,7 @@ public class MorphBunny extends MorphGadget
}
}
}
@EventHandler
public void eggDespawnCancel(ItemDespawnEvent event)
{

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphCreeper.java
View File

@ -170,7 +170,7 @@ public class MorphCreeper extends MorphGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.HERO))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphPig.java
View File

@ -86,7 +86,7 @@ public class MorphPig extends MorphGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.ULTRA))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphTitan.java
View File

@ -227,7 +227,7 @@ public class MorphTitan extends MorphGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}

68
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphVillager.java
View File

@ -37,21 +37,21 @@ import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
public class MorphVillager extends MorphGadget implements IThrown
{
{
private HashSet<Item> _gems = new HashSet<Item>();
public MorphVillager(GadgetManager manager)
{
super(manager, "Villager Morph", UtilText.splitLinesToArray(new String[]
{
C.cGray + "HURRRR! MURR HURRR!",
C.blankLine,
"#" + C.cWhite + "Left Click to use Gem Throw",
C.blankLine,
"#" + C.cRed +C.Bold + "WARNING: " + ChatColor.RESET + "Gem Throw uses 20 Gems"
}, LineFormat.LORE),
super(manager, "Villager Morph", UtilText.splitLinesToArray(new String[]
{
C.cGray + "HURRRR! MURR HURRR!",
C.blankLine,
"#" + C.cWhite + "Left Click to use Gem Throw",
C.blankLine,
"#" + C.cRed + C.Bold + "WARNING: " + ChatColor.RESET + "Gem Throw uses 20 Gems"
}, LineFormat.LORE),
12000,
Material.EMERALD, (byte)0);
Material.EMERALD, (byte) 0);
}
@Override
@ -86,42 +86,42 @@ public class MorphVillager extends MorphGadget implements IThrown
UtilPlayer.message(player, F.main("Gadget", "You do not have enough Gems."));
return;
}
if (!Recharge.Instance.use(player, getName(), 800, false, false, "Cosmetics"))
return;
player.getWorld().playSound(player.getLocation(), Sound.VILLAGER_IDLE, 1f, 1f);
//Item
Item gem = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()), new ItemStack(Material.EMERALD));
UtilAction.velocity(gem, player.getLocation().getDirection(), 1, false, 0, 0.2, 1, false);
//Throw
Manager.getProjectileManager().AddThrow(gem, player, this, -1, true, true, true, true,
Manager.getProjectileManager().AddThrow(gem, player, this, -1, true, true, true, true,
null, 1.4f, 0.8f, null, null, 0, UpdateType.TICK, 0.5f);
Manager.getDonationManager().RewardGems(null, this.getName() + " Throw", player.getName(), player.getUniqueId(), -20);
Manager.getDonationManager().rewardCurrency(GlobalCurrency.GEM, player, this.getName() + " Throw", -20);
gem.setPickupDelay(40);
_gems.add(gem);
}
@Override
public void Collide(LivingEntity target, Block block, ProjectileUser data)
{
if (target == null)
return;
if (target instanceof Player)
if (Manager.collideEvent((Player) data.getThrower(), this, (Player) target))
return;
//Pull
UtilAction.velocity(target,
UtilAction.velocity(target,
UtilAlg.getTrajectory(data.getThrown().getLocation(), target.getEyeLocation()),
1, false, 0, 0.2, 0.8, true);
UtilAction.velocity(data.getThrown(),
UtilAlg.getTrajectory(target, data.getThrown()),
0.5, false, 0, 0, 0.8, true);
@ -133,15 +133,15 @@ public class MorphVillager extends MorphGadget implements IThrown
@Override
public void Idle(ProjectileUser data)
{
}
@Override
public void Expire(ProjectileUser data)
{
}
@EventHandler
public void Pickup(PlayerPickupItemEvent event)
{
@ -149,25 +149,25 @@ public class MorphVillager extends MorphGadget implements IThrown
{
event.setCancelled(true);
event.getItem().remove();
Manager.getDonationManager().RewardGemsLater(getName() + " Pickup", event.getPlayer(), 16);
Manager.getDonationManager().rewardCurrency(GlobalCurrency.GEM, event.getPlayer(), getName() + " Pickup", 16);
event.getPlayer().getWorld().playSound(event.getPlayer().getLocation(), Sound.ORB_PICKUP, 1f, 2f);
}
}
@EventHandler
public void Clean(UpdateEvent event)
{
if (event.getType() != UpdateType.FAST)
return;
Iterator<Item> gemIterator = _gems.iterator();
while (gemIterator.hasNext())
{
Item gem = gemIterator.next();
if (!gem.isValid() || gem.getTicksLived() > 1200)
{
gem.remove();

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/particle/ParticleKronos.java
View File

@ -56,7 +56,7 @@ public class ParticleKronos extends ParticleGadget
/*Until it becomes purchasable*/if (Manager.getClientManager().Get(event.getPlayer()).GetRank().equals(Rank.TITAN))
//if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/particle/titan/ParticleTitan.java
View File

@ -96,7 +96,7 @@ public class ParticleTitan extends ParticleGadget
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

4
Plugins/Mineplex.Core/src/mineplex/core/gadget/types/Gadget.java
View File

@ -182,12 +182,12 @@ public abstract class Gadget extends SalesPackageBase implements Listener
public boolean ownsGadget(Player player)
{
if(isFree() || _free) return true;
if(Manager.getDonationManager().Get(player).OwnsUnknownPackage(getName())) { return true; }
if(Manager.getDonationManager().Get(player).ownsUnknownSalesPackage(getName())) { return true; }
if(Manager.getInventoryManager().Get(player).getItemCount(getName()) > 0) { return true; }
for(String alt : _alternativePackageNames)
{
if(Manager.getDonationManager().Get(player).OwnsUnknownPackage(alt)) { return true; }
if(Manager.getDonationManager().Get(player).ownsUnknownSalesPackage(alt)) { return true; }
if(Manager.getInventoryManager().Get(player).getItemCount(alt) > 0) { return true; }
}

15
Plugins/Mineplex.Core/src/mineplex/core/giveaway/GiveawayRepository.java
View File

@ -12,7 +12,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -26,7 +25,7 @@ public class GiveawayRepository extends MinecraftRepository
public GiveawayRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public boolean canGiveaway(int accountId, String giveawayName, String cooldownName)
@ -119,16 +118,4 @@ public class GiveawayRepository extends MinecraftRepository
return giveawayData;
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
}

8
Plugins/Mineplex.Core/src/mineplex/core/globalpacket/listeners/GlobalGiveCoins.java
View File

@ -6,6 +6,7 @@ import org.bukkit.event.Listener;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.Rank;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -68,15 +69,14 @@ public class GlobalGiveCoins implements Listener
final int fAmount = amount;
for (final Player p : UtilServer.getPlayers())
{
_donationManager.RewardCoins(new Callback<Boolean>()
_donationManager.rewardCurrency(GlobalCurrency.TREASURE_SHARD, p, "Global Coins", amount, response ->
{
@Override
public void run(Boolean data)
if (response)
{
UtilPlayer.message(p, F.main("Global", "You received " + F.elem(fAmount + " Coins") + "."));
UtilTextMiddle.display(C.cYellow + fAmount + " Coins", C.cGold + "received from " + e.getCallerName() + "!", p);
}
}, "Global Coins", p.getName(), _clientManager.getAccountId(p), amount);
});
}
}
}

13
Plugins/Mineplex.Core/src/mineplex/core/globalpacket/listeners/GlobalGiveGems.java
View File

@ -5,6 +5,7 @@ import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import mineplex.core.common.Rank;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -65,15 +66,11 @@ public class GlobalGiveGems implements Listener
final int fAmount = amount;
for (final Player p : UtilServer.getPlayers())
{
_donationManager.RewardGems(new Callback<Boolean>()
_donationManager.rewardCurrency(GlobalCurrency.GEM, p, "Global Gems", amount, success ->
{
@Override
public void run(Boolean data)
{
UtilPlayer.message(p, F.main("Global", "You received " + F.elem(fAmount + " Gems") + "."));
UtilTextMiddle.display(C.cYellow + fAmount + " Gems", C.cGold + "received from " + e.getCallerName() + "!", p);
}
}, "Global Gems", p.getName(), p.getUniqueId(), amount);
UtilPlayer.message(p, F.main("Global", "You received " + F.elem(fAmount + " Gems") + "."));
UtilTextMiddle.display(C.cYellow + fAmount + " Gems", C.cGold + "received from " + e.getCallerName() + "!", p);
});
}
}
}

13
Plugins/Mineplex.Core/src/mineplex/core/ignore/data/IgnoreRepository.java
View File

@ -5,7 +5,6 @@ import java.sql.SQLException;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnVarChar;
import org.bukkit.entity.Player;
@ -18,17 +17,7 @@ public class IgnoreRepository extends MinecraftRepository
public IgnoreRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public boolean addIgnore(final Player caller, String name)

6
Plugins/Mineplex.Core/src/mineplex/core/incognito/repository/IncognitoRepository.java
View File

@ -13,7 +13,7 @@ public class IncognitoRepository extends MinecraftRepository
public IncognitoRepository(IncognitoManager incognitoManager)
{
super(incognitoManager.getPlugin(), DBPool.getAccount());
super(DBPool.getAccount());
}
public void setStatus(int accountId, boolean status)
@ -26,8 +26,4 @@ public class IncognitoRepository extends MinecraftRepository
{
executeUpdate(CREATE_TABLE);
}
protected void update()
{
}
}

17
Plugins/Mineplex.Core/src/mineplex/core/inventory/data/InventoryRepository.java
View File

@ -10,7 +10,6 @@ import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.common.util.NautHashMap;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -30,21 +29,7 @@ public class InventoryRepository extends MinecraftRepository
public InventoryRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
/*
executeUpdate(CREATE_INVENTORY_TABLE);
executeUpdate(CREATE_INVENTORY_RELATION_TABLE);
*/
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public void addItem(String name)

15
Plugins/Mineplex.Core/src/mineplex/core/leaderboard/StatEventsRepository.java
View File

@ -2,7 +2,6 @@ package mineplex.core.leaderboard;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -37,21 +36,9 @@ public class StatEventsRepository extends MinecraftRepository
*/
public StatEventsRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_EVENTS_TABLE);
//executeUpdate(CREATE_STAT_RELATION_TABLE);
}
@Override
protected void update()
{
}
/**
* Insert (or update) a new stat event record for today into the repository.

2
Plugins/Mineplex.Core/src/mineplex/core/message/MessageManager.java
View File

@ -246,7 +246,7 @@ public class MessageManager extends MiniClientPlugin<ClientMessage>
Get(from).LastToTime = System.currentTimeMillis();
// Chiss or defek7
if (GetClientManager().Get(to).GetRank() == Rank.DEVELOPER)
if (GetClientManager().Get(to).getRealOrDisguisedRank() == Rank.DEVELOPER)
{
UtilPlayer.message(from, C.cPurple + to.getName() + " is often AFK or minimized, due to plugin development.");
UtilPlayer.message(from, C.cPurple + "Please be patient if they do not reply instantly.");

2
Plugins/Mineplex.Core/src/mineplex/core/mount/types/MountDragon.java
View File

@ -108,7 +108,7 @@ public class MountDragon extends DragonMount
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.HERO))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/mount/types/MountTitan.java
View File

@ -137,7 +137,7 @@ public class MountTitan extends Mount<MountTitanData>
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.TITAN))
{
Manager.getDonationManager().Get(event.getPlayer()).AddUnknownSalesPackagesOwned(getName());
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
}

12
Plugins/Mineplex.Core/src/mineplex/core/pet/repository/PetRepository.java
View File

@ -19,7 +19,7 @@ public class PetRepository extends MinecraftRepository
public PetRepository(JavaPlugin plugin, String webAddress)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_webAddress = webAddress;
}
@ -43,14 +43,4 @@ public class PetRepository extends MinecraftRepository
{
new AsyncJsonWebCall(_webAddress + "Pets/UpdatePet").Execute(token);
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
}

10
Plugins/Mineplex.Core/src/mineplex/core/playwire/PlayWireManager.java
View File

@ -17,6 +17,7 @@ import mineplex.core.Managers;
import mineplex.core.MiniDbClientPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.bonuses.BonusManager;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -32,7 +33,7 @@ public class PlayWireManager extends MiniDbClientPlugin<PlayWireClientData>
private static final int MAX_TICKETS_PER_PERIOD = 5;
private final long COOL_DOWN = TimeUnit.HOURS.getMilliseconds() * 24;
private static final int REWARD_MESSAGE_DELAY_SECONDS = 10;
private final CoreClientManager _clientManager;
private final PlayWireRepository _repository;
@ -127,11 +128,11 @@ public class PlayWireManager extends MiniDbClientPlugin<PlayWireClientData>
try (Connection c = DBPool.getAccount().getConnection(); Statement statement = c.createStatement())
{
final String query = "UPDATE bonus SET tickets = tickets + 1 WHERE accountId = " + accountId + ";SELECT tickets FROM bonus WHERE accountId = " + accountId;
statement.execute(query);
statement.getUpdateCount();
statement.getMoreResults();
ResultSet rs = statement.getResultSet();
if (rs.next())
{
@ -175,7 +176,8 @@ public class PlayWireManager extends MiniDbClientPlugin<PlayWireClientData>
if (response == ResponseType.COUNTED)
{
attemptRedeem(player);
} else
}
else
{
player.sendMessage(response.getMessage());
}

54
Plugins/Mineplex.Core/src/mineplex/core/poll/PollManager.java
View File

@ -16,9 +16,11 @@ import com.google.gson.JsonObject;
import net.minecraft.server.v1_8_R3.IChatBaseComponent.ChatSerializer;
import net.minecraft.server.v1_8_R3.PacketPlayOutChat;
import mineplex.core.MiniDbClientPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.Rank;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -114,7 +116,7 @@ public class PollManager extends MiniDbClientPlugin<PlayerPollData>
player.sendMessage("");
for (int i = 1; i <= answers.length; i++)
{
if (answers[i-1] != null && answers[i-1].length() > 0)
if (answers[i - 1] != null && answers[i - 1].length() > 0)
{
String message = C.cGreen + i + ". " + answers[i - 1];
// Base message object
@ -156,47 +158,27 @@ public class PollManager extends MiniDbClientPlugin<PlayerPollData>
Get(player).addAnswer(poll.getId(), answer);
// Here we add the answer into the database, and once that is successful we give the coin reward
_plugin.getServer().getScheduler().runTaskAsynchronously(_plugin, new Runnable()
_plugin.getServer().getScheduler().runTaskAsynchronously(_plugin, () ->
{
@Override
public void run()
if (_repository.addPollAnswer(uuid, poll.getId(), answer))
{
if (_repository.addPollAnswer(uuid, poll.getId(), answer))
UtilPlayer.message(player, F.main("Carl", "Thanks for your response!"));
player.playSound(player.getEyeLocation(), Sound.LEVEL_UP, 1F, 0);
// Poll response successful, give coins
_donationManager.rewardCurrency(GlobalCurrency.GEM, player, "Poll", poll.getCoinReward(), gemSuccessful ->
{
// Poll response successful, give coins
_donationManager.RewardGems(new Callback<Boolean>()
if (gemSuccessful)
{
@Override
public void run(Boolean completed)
UtilPlayer.message(player, F.main("Carl", "You received " + F.elem(poll.getCoinReward() + "") + " Gems!"));
}
_donationManager.rewardCurrency(GlobalCurrency.TREASURE_SHARD, player, "Poll", poll.getCoinReward(), completed ->
{
if (completed)
{
if (completed)
{
_donationManager.RewardCoins(new Callback<Boolean>()
{
@Override
public void run(Boolean completed)
{
if (completed)
{
// Need to get out of Async code
_plugin.getServer().getScheduler().runTask(_plugin, new Runnable()
{
@Override
public void run()
{
UtilPlayer.message(player, F.main("Carl", "Thanks for your response!"));
player.playSound(player.getEyeLocation(), Sound.LEVEL_UP, 1F, 0);
UtilPlayer.message(player, F.main("Carl", "You received " + F.elem(poll.getCoinReward() + "") + " Gems!"));
UtilPlayer.message(player, F.main("Carl", "You received " + F.elem(poll.getCoinReward() + "") + " Coins!"));
}
});
}
}
}, "Poll", name, accountId, poll.getCoinReward());
}
UtilPlayer.message(player, F.main("Carl", "You received " + F.elem(poll.getCoinReward() + "") + " Coins!"));
}
}, "Poll", name, uuid, poll.getCoinReward());
}
});
});
}
});
}

16
Plugins/Mineplex.Core/src/mineplex/core/poll/PollRepository.java
View File

@ -10,7 +10,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -30,20 +29,7 @@ public class PollRepository extends MinecraftRepository
public PollRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_POLL_TABLE);
//executeUpdate(CREATE_RELATION_TABLE);
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public List<Poll> retrievePolls()

4
Plugins/Mineplex.Core/src/mineplex/core/powerplayclub/PowerPlayClubRepository.java
View File

@ -106,12 +106,12 @@ public class PowerPlayClubRepository implements Listener {
PowerPlayData cached = getCachedData(player);
PowerPlayClubRewards.rewardsForMonths(cached.getUsableCosmeticMonths()).stream()
.map(PowerPlayClubRewards.PowerPlayClubItem::getPrize)
.forEach(_donationManager.Get(player)::AddUnknownSalesPackagesOwned);
.forEach(_donationManager.Get(player)::addOwnedUnknownSalesPackage);
// Gives Metal Man for anyone subscribed
if (cached.getUsableCosmeticMonths().size() > 0)
{
_donationManager.Get(player).AddUnknownSalesPackagesOwned("Metal Man Morph");
_donationManager.Get(player).addOwnedUnknownSalesPackage("Metal Man Morph");
}
}

12
Plugins/Mineplex.Core/src/mineplex/core/preferences/PreferencesRepository.java
View File

@ -19,20 +19,10 @@ public class PreferencesRepository extends MinecraftRepository
public PreferencesRepository(PreferencesManager plugin)
{
super(plugin.getPlugin(), DBPool.getAccount());
super(DBPool.getAccount());
_manager = plugin;
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
/**
* Save a player's preferences in SQL
*

12
Plugins/Mineplex.Core/src/mineplex/core/progression/KitProgressionRepository.java
View File

@ -33,20 +33,10 @@ public class KitProgressionRepository extends MinecraftRepository
public KitProgressionRepository(KitProgressionManager plugin)
{
super(plugin.getPlugin(), DBPool.getAccount());
super(DBPool.getAccount());
_kitProgressionManager = plugin;
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
/**
* Inserts data for a kit into the database
* This will update the info if the kit is already in there

40
Plugins/Mineplex.Core/src/mineplex/core/progression/data/KitUpgradeProcessor.java
View File

@ -1,6 +1,7 @@
package mineplex.core.progression.data;
import mineplex.core.server.util.TransactionResponse;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
@ -19,7 +20,7 @@ public class KitUpgradeProcessor implements ConfirmationProcessor
private Player _player;
private ProgressiveKit _kit;
private int _upgradeLevel;
public KitUpgradeProcessor(KitProgressionManager manager, Player player, ProgressiveKit kit, int upgradeLevel)
{
_manager = manager;
@ -39,25 +40,26 @@ public class KitUpgradeProcessor implements ConfirmationProcessor
String packageName = _kit.getInternalName() + "." + _upgradeLevel;
int cost = Calculations.getGemsCost(_upgradeLevel);
// Use UnknownPackages for this right now as it handles overspending gems properly
_manager.getDonationManager().purchaseUnknownSalesPackage(data ->
{
if (data == TransactionResponse.Success)
{
_kit.upgrade(_upgradeLevel, _player.getUniqueId());
_manager.getDonationManager().purchaseUnknownSalesPackage(_player, packageName, GlobalCurrency.GEM, cost, false,
data ->
{
if (data == TransactionResponse.Success)
{
_kit.upgrade(_upgradeLevel, _player.getUniqueId());
_player.playSound(_player.getLocation(), Sound.CAT_MEOW, 5.0f, 1.0f);
_player.sendMessage(F.main("Kit Progression", "Purchased upgrades for " + _kit.getDisplayName() + " level " + _upgradeLevel));
_player.playSound(_player.getLocation(), Sound.CAT_MEOW, 5.0f, 1.0f);
_player.sendMessage(F.main("Kit Progression", "Purchased upgrades for " + _kit.getDisplayName() + " level " + _upgradeLevel));
callback.resolve("Success! You now own this upgrade!");
}
else if (data == TransactionResponse.InsufficientFunds)
{
callback.reject("Insufficient funds!");
}
else
{
callback.reject("There was an error processing your transaction. Try again later");
}
}, _player, packageName, GlobalCurrency.GEM, cost, false);
callback.resolve("Success! You now own this upgrade!");
}
else if (data == TransactionResponse.InsufficientFunds)
{
callback.reject("Insufficient funds!");
}
else
{
callback.reject("There was an error processing your transaction. Try again later");
}
});
}
}

14
Plugins/Mineplex.Core/src/mineplex/core/rankGiveaway/titangiveaway/TitanGiveawayRepository.java
View File

@ -20,22 +20,10 @@ public class TitanGiveawayRepository extends MinecraftRepository
public TitanGiveawayRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_titanCount = 0;
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
public boolean addTitan(int accountId, Region region, String serverName)
{
return 1 == executeUpdate(ADD_TITAN, new ColumnInt("accountId", accountId), new ColumnVarChar("region", 10, region.name()), new ColumnVarChar("serverName", 64, serverName));

10
Plugins/Mineplex.Core/src/mineplex/core/reward/rewards/GemReward.java
View File

@ -6,6 +6,7 @@ import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.Callback;
import mineplex.core.donation.DonationManager;
import mineplex.core.reward.Reward;
@ -40,14 +41,7 @@ public class GemReward extends Reward
{
int GemsToReward = _random.nextInt(_maxGemCount - _minGemCount) + _minGemCount;
_donationManager.RewardGems(new Callback<Boolean>()
{
@Override
public void run(Boolean data)
{
}
}, "Treasure Chest", player.getName(), player.getUniqueId(), GemsToReward);
_donationManager.rewardCurrency(GlobalCurrency.GEM, player, "Treasure Chest", GemsToReward);
return new RewardData(null, getRarity().getColor() + GemsToReward + " Gems", new ItemStack(Material.EMERALD), getRarity());
}

4
Plugins/Mineplex.Core/src/mineplex/core/reward/rewards/TreasureShardReward.java
View File

@ -1,7 +1,9 @@
package mineplex.core.reward.rewards;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.UtilMath;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
@ -69,7 +71,7 @@ public class TreasureShardReward extends Reward
@Override
public void run()
{
_donationManager.rewardCoinsUntilSuccess(null, "Treasure", player.getName(), accountId, shards);
_donationManager.rewardCurrencyUntilSuccess(GlobalCurrency.TREASURE_SHARD, player, "Treasure", shards);
}
}, 100);

6
Plugins/Mineplex.Core/src/mineplex/core/reward/rewards/UnknownPackageReward.java
View File

@ -46,7 +46,7 @@ public class UnknownPackageReward extends Reward
@Override
protected RewardData giveRewardCustom(Player player, RewardType type)
{
_donationManager.PurchaseUnknownSalesPackage(null, player.getName(), _donationManager.getClientManager().Get(player).getAccountId(), _packageName, GlobalCurrency.TREASURE_SHARD, 0, true);
_donationManager.purchaseUnknownSalesPackage(player, _packageName, GlobalCurrency.TREASURE_SHARD, 0, true, null);
return new RewardData(getRarity().getDarkColor() + _header, getRarity().getColor() + _name, _itemStack, getRarity());
}
@ -60,7 +60,7 @@ public class UnknownPackageReward extends Reward
return false;
}
boolean hasItem = false;
if (_donationManager.Get(player).OwnsUnknownPackage(_packageName))
if (_donationManager.Get(player).ownsUnknownSalesPackage(_packageName))
{
hasItem = true;
}
@ -68,7 +68,7 @@ public class UnknownPackageReward extends Reward
{
for (String altName : _alternativeNames)
{
if (_donationManager.Get(player).OwnsUnknownPackage(altName))
if (_donationManager.Get(player).ownsUnknownSalesPackage(altName))
{
hasItem = true;
}

41
Plugins/Mineplex.Core/src/mineplex/core/shop/ShopBase.java
View File

@ -23,7 +23,11 @@ import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
public abstract class ShopBase<PluginType extends MiniPlugin> implements Listener
{
@ -34,9 +38,9 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
private CoreClientManager _clientManager;
private DonationManager _donationManager;
private String _name;
private NautHashMap<String, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> _playerPageMap;
private Map<String, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> _playerPageMap = new HashMap<>();
private HashSet<String> _openedShop = new HashSet<String>();
private Set<String> _openedShop = new HashSet<>();
public ShopBase(PluginType plugin, CoreClientManager clientManager, DonationManager donationManager, String name)
{
@ -44,8 +48,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
_clientManager = clientManager;
_donationManager = donationManager;
_name = name;
_playerPageMap = new NautHashMap<String, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>>();
_errorThrottling = new NautHashMap<String, Long>();
_purchaseBlock = new NautHashMap<String, Long>();
@ -83,17 +86,17 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
public boolean attemptShopOpen(Player player)
{
if (!_openedShop.contains(player.getName()))
if (!_openedShop.contains(player.getUniqueId()))
{
if (!canOpenShop(player))
return false;
_openedShop.add(player.getName());
_openedShop.add(player.getUniqueId());
openShopForPlayer(player);
if (!_playerPageMap.containsKey(player.getName()))
if (!_playerPageMap.containsKey(player.getUniqueId()))
{
_playerPageMap.put(player.getName(), buildPagesFor(player));
_playerPageMap.put(player.getUniqueId(), buildPagesFor(player));
}
openPageForPlayer(player, getOpeningPageForPlayer(player));
@ -106,7 +109,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
protected ShopPageBase<PluginType, ? extends ShopBase<PluginType>> getOpeningPageForPlayer(HumanEntity player)
{
return _playerPageMap.get(player.getName());
return _playerPageMap.get(player.getUniqueId());
}
@EventHandler
@ -145,7 +148,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
@EventHandler
public void onInventoryClose(InventoryCloseEvent event)
{
if (_playerPageMap.containsKey(event.getPlayer().getName()) && _playerPageMap.get(event.getPlayer().getName()).getTitle() != null && _playerPageMap.get(event.getPlayer().getName()).getTitle().equalsIgnoreCase(event.getInventory().getTitle()))
if (_playerPageMap.containsKey(event.getPlayer().getUniqueId()) && _playerPageMap.get(event.getPlayer().getUniqueId()).getTitle() != null && _playerPageMap.get(event.getPlayer().getUniqueId()).getTitle().equalsIgnoreCase(event.getInventory().getTitle()))
{
_playerPageMap.get(event.getPlayer().getName()).playerClosed();
_playerPageMap.get(event.getPlayer().getName()).dispose();
@ -164,7 +167,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
if (!event.isCancelled())
return;
if (_playerPageMap.containsKey(event.getPlayer().getName()) && _playerPageMap.get(event.getPlayer().getName()).getTitle() != null && _playerPageMap.get(event.getPlayer().getName()).getTitle().equalsIgnoreCase(event.getInventory().getTitle()))
if (_playerPageMap.containsKey(event.getPlayer().getUniqueId()) && _playerPageMap.get(event.getPlayer().getUniqueId()).getTitle() != null && _playerPageMap.get(event.getPlayer().getUniqueId()).getTitle().equalsIgnoreCase(event.getInventory().getTitle()))
{
_playerPageMap.get(event.getPlayer().getName()).playerClosed();
_playerPageMap.get(event.getPlayer().getName()).dispose();
@ -189,7 +192,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
@EventHandler
public void onPlayerQuit(PlayerQuitEvent event)
{
if (_playerPageMap.containsKey(event.getPlayer().getName()))
if (_playerPageMap.containsKey(event.getPlayer().getUniqueId()))
{
_playerPageMap.get(event.getPlayer().getName()).playerClosed();
_playerPageMap.get(event.getPlayer().getName()).dispose();
@ -205,9 +208,9 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
public void openPageForPlayer(Player player, ShopPageBase<PluginType, ? extends ShopBase<PluginType>> page)
{
if (_playerPageMap.containsKey(player.getName()))
if (_playerPageMap.containsKey(player.getUniqueId()))
{
_playerPageMap.get(player.getName()).playerClosed();
_playerPageMap.get(player.getUniqueId()).playerClosed();
}
setCurrentPageForPlayer(player, page);
@ -224,7 +227,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
public void setCurrentPageForPlayer(Player player, ShopPageBase<PluginType, ? extends ShopBase<PluginType>> page)
{
_playerPageMap.put(player.getName(), page);
_playerPageMap.put(player.getUniqueId(), page);
}
public void addPlayerProcessError(Player player)
@ -240,7 +243,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
return !_purchaseBlock.containsKey(player.getName()) || (System.currentTimeMillis() - _purchaseBlock.get(player.getName()) > 10000);
}
public NautHashMap<String, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> getPageMap()
public Map<UUID, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> getPageMap()
{
return _playerPageMap;
}
@ -249,7 +252,7 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
public boolean isPlayerInShop(HumanEntity player)
{
return _playerPageMap.containsKey(player.getName());
return _playerPageMap.containsKey(player.getUniqueId());
}
protected PluginType getPlugin()
@ -272,12 +275,12 @@ public abstract class ShopBase<PluginType extends MiniPlugin> implements Listene
return _name;
}
protected NautHashMap<String, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> getPlayerPageMap()
protected Map<UUID, ShopPageBase<PluginType, ? extends ShopBase<PluginType>>> getPlayerPageMap()
{
return _playerPageMap;
}
protected HashSet<String> getOpenedShop()
protected Set<UUID> getOpenedShop()
{
return _openedShop;
}

15
Plugins/Mineplex.Core/src/mineplex/core/shop/item/SalesPackageProcessor.java
View File

@ -1,5 +1,7 @@
package mineplex.core.shop.item;
import mineplex.core.account.CoreClient;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.donation.DonationManager;
@ -7,10 +9,16 @@ import mineplex.core.itemstack.ItemBuilder;
import mineplex.core.server.util.TransactionResponse;
import mineplex.core.shop.confirmation.ConfirmationCallback;
import mineplex.core.shop.confirmation.ConfirmationProcessor;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
public class SalesPackageProcessor implements ConfirmationProcessor {
import static mineplex.core.Managers.require;
public class SalesPackageProcessor implements ConfirmationProcessor
{
private final CoreClientManager _clientManager = require(CoreClientManager.class);
private final GlobalCurrency _currencyType;
private final SalesPackageBase _salesItem;
private final DonationManager _donationManager;
@ -35,13 +43,14 @@ public class SalesPackageProcessor implements ConfirmationProcessor {
@Override
public void process(ConfirmationCallback callback)
{
CoreClient client = _clientManager.Get(_player);
if (_salesItem.isKnown())
{
_donationManager.PurchaseKnownSalesPackage(response -> showResults(callback, response), _player.getName(), _player.getUniqueId(), _salesItem.getCost(_currencyType), _salesItem.getSalesPackageId());
_donationManager.purchaseKnownSalesPackage(client, _salesItem.getSalesPackageId(), response -> showResults(callback, response));
}
else
{
_donationManager.PurchaseUnknownSalesPackage(response -> showResults(callback, response), _player.getName(), _donationManager.getClientManager().Get(_player).getAccountId(), _salesItem.getName(), _currencyType, _salesItem.getCost(_currencyType), _salesItem.oneTimePurchase());
_donationManager.purchaseUnknownSalesPackage(client, _salesItem.getName(), _currencyType, _salesItem.getCost(_currencyType), _salesItem.oneTimePurchase(), response -> showResults(callback, response));
}
}

14
Plugins/Mineplex.Core/src/mineplex/core/spawn/SpawnRepository.java
View File

@ -9,7 +9,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -24,20 +23,9 @@ public class SpawnRepository extends MinecraftRepository
public SpawnRepository(JavaPlugin plugin, String serverName)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_serverName = serverName;
}
@Override
protected void initialize()
{
//executeUpdate(CREATE_SPAWN_TABLE);
}
@Override
protected void update()
{
}
public void addSpawn(String location)
{

9
Plugins/Mineplex.Core/src/mineplex/core/stats/StatsRepository.java
View File

@ -9,7 +9,6 @@ import java.util.List;
import mineplex.core.common.util.NautHashMap;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnVarChar;
import mineplex.database.Tables;
@ -32,14 +31,8 @@ public class StatsRepository extends MinecraftRepository
public StatsRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
@Override
protected void initialize() { }
@Override
protected void update() { }
public List<Stat> retrieveStats()
{

13
Plugins/Mineplex.Core/src/mineplex/core/task/repository/TaskRepository.java
View File

@ -9,7 +9,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -25,17 +24,7 @@ public class TaskRepository extends MinecraftRepository
public TaskRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public boolean addAccountTask(int accountId, int taskId)

16
Plugins/Mineplex.Core/src/mineplex/core/texttutorial/TextTutorialManager.java
View File

@ -13,6 +13,7 @@ import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.MiniPlugin;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
@ -104,19 +105,16 @@ public class TextTutorialManager extends MiniPlugin
{
public void run(Boolean completed)
{
_donationManager.RewardGems(new Callback<Boolean>()
_donationManager.rewardCurrency(GlobalCurrency.GEM, player, "Tutorial " + tut.getName(), tut.getGemReward(), success ->
{
public void run(Boolean completed)
if (completed)
{
if (completed)
{
UtilPlayer.message(player, F.main("Tutorial", "You received " + F.elem(C.cGreen + tut.getGemReward() + " Gems") + "."));
UtilPlayer.message(player, F.main("Tutorial", "You received " + F.elem(C.cGreen + tut.getGemReward() + " Gems") + "."));
//Sound
player.playSound(player.getLocation(), Sound.LEVEL_UP, 2f, 1.5f);
}
//Sound
player.playSound(player.getLocation(), Sound.LEVEL_UP, 2f, 1.5f);
}
}, "Tutorial " + tut.getName(), player.getName(), player.getUniqueId(), tut.getGemReward());
});
}
}, player, tut.getTaskId());
}

60
Plugins/Mineplex.Core/src/mineplex/core/thank/ThankManager.java
View File

@ -2,12 +2,14 @@ package mineplex.core.thank;
import mineplex.core.MiniDbClientPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.donation.DonationManager;
import mineplex.core.recharge.Recharge;
import mineplex.core.thank.command.ThankCommand;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
@ -46,13 +48,13 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
* Attempt to thank a player. This can be used to distribute rewards to players, give players rewards for using
* amplifiers, and allow players to thank anyone inside a game.
*
* @param receiver The player who is being thanked
* @param sender The player thanking receiver
* @param receiver The player who is being thanked
* @param sender The player thanking receiver
* @param receiverReward The Treasure Shard reward for the receiver
* @param senderReward The Treasure Shard reward for the sender
* @param reason The reason that player is being thanked
* @param senderReward The Treasure Shard reward for the sender
* @param reason The reason that player is being thanked
* @param ignoreCooldown Should we ignore all thank cooldowns
* @param callback Callback for processing the result
* @param callback Callback for processing the result
*/
public void thankPlayer(Player receiver, Player sender, int receiverReward, int senderReward, String reason, boolean ignoreCooldown, Callback<ThankResult> callback)
{
@ -63,18 +65,19 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
return;
}
int senderAccountId = ClientManager.getAccountId(sender);
int receiverAccountId = ClientManager.getAccountId(receiver);
thankPlayer(receiver.getName(), receiverAccountId, sender.getName(), senderAccountId, receiverReward, senderReward, reason, ignoreCooldown, result ->
thankPlayer(receiver.getName(), receiverAccountId, sender, receiverReward, senderReward, reason, ignoreCooldown, result ->
{
if (result == ThankResult.SUCCESS)
{
// Reload their thank data if the player is online!
runAsync(() -> {
runAsync(() ->
{
try
{
Set(receiver, _thankRepository.getThankData(receiverAccountId));
} catch (SQLException e)
}
catch (SQLException e)
{
e.printStackTrace();
}
@ -88,7 +91,7 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
/**
* Called when a player wants to "claim" all pending rewards that they haven't claimed yet
*
* @param player The player claiming their thank rewards
* @param player The player claiming their thank rewards
* @param callback Callback with the result of the claim
*/
public void claimThanks(Player player, Callback<ClaimThankResult> callback)
@ -102,15 +105,17 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
return;
}
runAsync(() -> {
runAsync(() ->
{
try
{
ClaimThankResult result = _thankRepository.claimThank(accountId);
runSync(() -> {
runSync(() ->
{
if (result != null && result.getClaimed() > 0)
{
Set(player, new ThankData(0));
_donationManager.rewardCoinsUntilSuccess(null, "Thank", player.getName(), accountId, result.getClaimed());
_donationManager.rewardCurrencyUntilSuccess(GlobalCurrency.TREASURE_SHARD, player, "Thank", result.getClaimed());
}
callback.run(result);
});
@ -127,18 +132,19 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
* Attempt to thank a player. This can be used to distribute rewards to players, give players rewards for using
* amplifiers, and allow players to thank anyone inside a game.
*
* @param receiverName Name of the player being thanked
* @param receiverName Name of the player being thanked
* @param receiverAccountId Account id of the player being thanked
* @param senderName Name of the player sending the thanks
* @param senderAccountId Account id of the player sending the thanks
* @param receiverReward The Treasure Shard reward for the receiver
* @param senderReward The Treasure Shard reward for the sender
* @param reason The reason that player is being thanked
* @param ignoreCooldown Should we ignore all thank cooldowns
* @param callback Callback for processing the result
* @param sender The player sending the thanks
* @param receiverReward The Treasure Shard reward for the receiver
* @param senderReward The Treasure Shard reward for the sender
* @param reason The reason that player is being thanked
* @param ignoreCooldown Should we ignore all thank cooldowns
* @param callback Callback for processing the result
*/
public void thankPlayer(String receiverName, int receiverAccountId, String senderName, int senderAccountId, int receiverReward, int senderReward, String reason, boolean ignoreCooldown, Callback<ThankResult> callback)
public void thankPlayer(String receiverName, int receiverAccountId, Player sender, int receiverReward, int senderReward, String reason, boolean ignoreCooldown, Callback<ThankResult> callback)
{
int senderAccountId = getClientManager().getAccountId(sender);
// Break out on bad account id
if (senderAccountId == -1 || receiverAccountId == -1)
{
@ -153,15 +159,17 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
return;
}
runAsync(() -> {
runAsync(() ->
{
try
{
boolean success = _thankRepository.thank(receiverAccountId, senderAccountId, receiverReward, reason, ignoreCooldown);
runSync(() -> {
runSync(() ->
{
if (success)
{
// Reward Shards for the sender now. The player being thanked can claim their shards at Carl.
_donationManager.rewardCoinsUntilSuccess(null, "Thank", senderName, senderAccountId, senderReward);
_donationManager.rewardCurrencyUntilSuccess(GlobalCurrency.TREASURE_SHARD, sender, "Thank", senderReward);
}
callback.run(success ? ThankResult.SUCCESS : ThankResult.COOLDOWN_DATABASE);
@ -182,7 +190,7 @@ public class ThankManager extends MiniDbClientPlugin<ThankData>
}
@Override
public void processLoginResultSet(String playerName, UUID playerUUID, int accountId, ResultSet resultSet) throws SQLException
public void processLoginResultSet(String playerName, UUID playerUUID, int accountId, ResultSet resultSet) throws SQLException
{
if (resultSet.next())
{

16
Plugins/Mineplex.Core/src/mineplex/core/thank/ThankRepository.java
View File

@ -4,12 +4,9 @@ import mineplex.core.database.MinecraftRepository;
import mineplex.database.routines.AddThank;
import mineplex.database.routines.ClaimThank;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnInt;
import org.bukkit.plugin.java.JavaPlugin;
import org.jooq.Configuration;
import java.sql.ResultSet;
import java.sql.SQLException;
public class ThankRepository extends MinecraftRepository
@ -18,18 +15,7 @@ public class ThankRepository extends MinecraftRepository
public ThankRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
super(DBPool.getAccount());
}
public boolean thank(int receiverAccountId, int senderAccountId, int thankAmount, String reason, boolean ignoreCooldown)

10
Plugins/Mineplex.Core/src/mineplex/core/thereallyoldscoreboardapiweshouldremove/elements/ScoreboardElementRank.java
View File

@ -19,11 +19,11 @@ public class ScoreboardElementRank implements ScoreboardElement
{
output.add(manager.getClients().Get(player).GetRank().Name);
}
else if (manager.getDonation().Get(player).OwnsUnknownPackage("SuperSmashMobs ULTRA") ||
manager.getDonation().Get(player).OwnsUnknownPackage("Survival Games ULTRA") ||
manager.getDonation().Get(player).OwnsUnknownPackage("Minigames ULTRA") ||
manager.getDonation().Get(player).OwnsUnknownPackage("CastleSiege ULTRA") ||
manager.getDonation().Get(player).OwnsUnknownPackage("Champions ULTRA"))
else if (manager.getDonation().Get(player).ownsUnknownSalesPackage("SuperSmashMobs ULTRA") ||
manager.getDonation().Get(player).ownsUnknownSalesPackage("Survival Games ULTRA") ||
manager.getDonation().Get(player).ownsUnknownSalesPackage("Minigames ULTRA") ||
manager.getDonation().Get(player).ownsUnknownSalesPackage("CastleSiege ULTRA") ||
manager.getDonation().Get(player).ownsUnknownSalesPackage("Champions ULTRA"))
{
output.add("Single Ultra");
}

8
Plugins/Mineplex.Core/src/mineplex/core/tournament/TournamentRepository.java
View File

@ -25,7 +25,7 @@ public class TournamentRepository extends MinecraftRepository
public TournamentRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public int registerForTournament(int accountId, int tournamentId)
@ -83,10 +83,4 @@ public class TournamentRepository extends MinecraftRepository
return tournaments;
}
@Override
protected void initialize() { }
@Override
protected void update() { }
}

15
Plugins/Mineplex.Core/src/mineplex/core/utils/UtilScheduler.java Normal file
View File

@ -0,0 +1,15 @@
package mineplex.core.utils;
import org.bukkit.plugin.Plugin;
import mineplex.core.common.util.UtilServer;
import mineplex.core.updater.UpdateType;
public class UtilScheduler
{
public static void runEvery(UpdateType speed, Runnable action)
{
Plugin plugin = UtilServer.getPlugin();
plugin.getServer().getScheduler().runTaskTimer(plugin, action, 0, (int) Math.ceil(speed.getMilliseconds() / 50.0));
}
}

14
Plugins/Mineplex.Core/src/mineplex/core/valentines/ValentinesGiftRepository.java
View File

@ -2,7 +2,6 @@ package mineplex.core.valentines;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnInt;
import org.bukkit.plugin.java.JavaPlugin;
@ -12,20 +11,9 @@ public class ValentinesGiftRepository extends MinecraftRepository
public ValentinesGiftRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
public boolean giveGift(int senderId, int targetId)
{

3
Plugins/Mineplex.Core/src/mineplex/core/youtube/YoutubeManager.java
View File

@ -2,6 +2,7 @@ package mineplex.core.youtube;
import mineplex.core.MiniDbClientPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.donation.DonationManager;
@ -55,7 +56,7 @@ public class YoutubeManager extends MiniDbClientPlugin<YoutubeClient>
client.setClickDate(ZonedDateTime.now(ZoneOffset.UTC).toLocalDate());
_repository.attemptYoutube(player, client, () ->
{
_donationManager.RewardCoinsLater("YouTube", player, 250);
_donationManager.rewardCurrency(GlobalCurrency.TREASURE_SHARD, player, "YouTube", 250);
Bukkit.getScheduler().runTaskLater(getClientManager().getPlugin(), () -> UtilPlayer.message(player, F.main("Carl", "Rewarded " + F.elem("250 Treasure Shards") + " for watching the YouTube video")), REWARD_MESSAGE_DELAY_SECONDS * 20L);
});
}

188
Plugins/Mineplex.EnjinTranslator/src/mineplex/enjinTranslator/Enjin.java
View File

@ -39,18 +39,18 @@ public class Enjin extends MiniPlugin implements CommandExecutor
private PurchaseManager _purchaseManager;
private PowerPlayClubRepository _powerPlayClubRepository;
private Punish _punish;
private NautHashMap<String, Entry<UUID, Long>> _cachedUUIDs = new NautHashMap<String, Entry<UUID, Long>>();
private static Object _commandLock = new Object();
public long _lastPoll = System.currentTimeMillis() - 120000;
private SimpleDateFormat _dateFormat = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss");
public Enjin(EnjinTranslator plugin, CoreClientManager clientManager, DonationManager donationManager, InventoryManager inventoryManager)
{
super("Enjin", plugin);
_clientManager = clientManager;
_donationManager = donationManager;
_inventoryManager = inventoryManager;
@ -58,21 +58,21 @@ public class Enjin extends MiniPlugin implements CommandExecutor
_purchaseManager = new PurchaseManager(plugin);
_powerPlayClubRepository = new PowerPlayClubRepository(plugin, clientManager, donationManager);
plugin.getCommand("enjin_mineplex").setExecutor(this);
plugin.getCommand("pull").setExecutor(this);
}
@EventHandler
public void expireCachedUUIDs(UpdateEvent event)
{
if (event.getType() != UpdateType.MIN_01)
return;
for (Iterator<Entry<String, Entry<UUID, Long>>> iterator = _cachedUUIDs.entrySet().iterator(); iterator.hasNext();)
for (Iterator<Entry<String, Entry<UUID, Long>>> iterator = _cachedUUIDs.entrySet().iterator(); iterator.hasNext(); )
{
Entry<String, Entry<UUID, Long>> entry = iterator.next();
if (System.currentTimeMillis() > entry.getValue().getValue())
iterator.remove();
}
@ -86,12 +86,12 @@ public class Enjin extends MiniPlugin implements CommandExecutor
try
{
if (sender instanceof Player)
((Player)sender).kickPlayer("Like bananas? I don't. Here take these and go have fun.");
((Player) sender).kickPlayer("Like bananas? I don't. Here take these and go have fun.");
if (label.equalsIgnoreCase("enjin_mineplex"))
{
final String name = args[1];
_clientManager.loadClientByName(name, client ->
{
if (client == null)
@ -119,14 +119,14 @@ public class Enjin extends MiniPlugin implements CommandExecutor
final UUID playerUUID = uuid;
_cachedUUIDs.put(name, new AbstractMap.SimpleEntry<UUID, Long>(playerUUID, System.currentTimeMillis() + 240000));
if (args[0].equalsIgnoreCase("chargeback"))
{
_punish.AddPunishment(name, Category.Other, "Chargeback", "Strutt20", 1, true, -1, true);
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " was banned for charging back!");
return;
}
if (!checkForClansPurchase(args, name, client))
{
if (!checkForBoosterPurchase(args, name, playerUUID, client))
@ -161,7 +161,7 @@ public class Enjin extends MiniPlugin implements CommandExecutor
{
exception.printStackTrace();
}
try
{
Thread.sleep(20);
@ -171,18 +171,18 @@ public class Enjin extends MiniPlugin implements CommandExecutor
e.printStackTrace();
}
}
return true;
}
protected boolean checkForRankPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
protected boolean checkForRankPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
{
if (args.length != 4 || !args[0].equalsIgnoreCase("rank"))
return false;
final Rank rank = mineplex.core.common.Rank.valueOf(args[2]);
final boolean perm = Boolean.parseBoolean(args[3]);
_clientManager.loadClientByName(name, loadedClient ->
{
if (rank == Rank.ALL || loadedClient.GetRank() == Rank.ALL || !loadedClient.GetRank().has(rank) || loadedClient.GetRank() == rank)
@ -197,102 +197,96 @@ public class Enjin extends MiniPlugin implements CommandExecutor
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), rank.Name + (perm ? " Permanent" : " Monthly"), 1, false);
}
});
return true;
}
protected boolean checkForPurchase(String[] args, final String name, final CoreClient client)
protected boolean checkForPurchase(String[] args, final String name, final CoreClient client)
{
if (args.length < 3 || !args[0].equalsIgnoreCase("purchase"))
return false;
final int amount = Integer.parseInt(args[2]);
String tempName = args[4];
for (int i = 5; i < args.length; i++)
{
tempName += " " + args[i];
}
final String packageName = tempName;
_donationManager.PurchaseUnknownSalesPackage(new Callback<TransactionResponse>()
_donationManager.purchaseUnknownSalesPackage(client, amount == 1 ? packageName : packageName + " " + amount, GlobalCurrency.GEM, 0, false, data ->
{
public void run(TransactionResponse data)
if (data == TransactionResponse.Success)
{
if (data == TransactionResponse.Success)
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
{
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
public void run(Boolean success)
{
public void run(Boolean success)
if (success)
{
if (success)
{
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, true);
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " " + packageName + ".");
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + packageName + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, false);
}
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, true);
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " " + packageName + ".");
}
}, client.getAccountId(), packageName, amount);
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + amount + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, data == TransactionResponse.Success);
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + packageName + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, false);
}
}
}, client.getAccountId(), packageName, amount);
}
}, name, client.getAccountId(), amount == 1 ? packageName : packageName + " " + amount, GlobalCurrency.GEM, 0, false);
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + amount + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, amount, false);
}
});
return true;
}
protected boolean checkForCoinPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
protected boolean checkForCoinPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
{
if (args.length != 3 || !args[0].equalsIgnoreCase("coin"))
return false;
final int amount = Integer.parseInt(args[2]);
_donationManager.RewardCoins(new Callback<Boolean>()
_donationManager.rewardCurrency(GlobalCurrency.TREASURE_SHARD, client, "purchase", amount, response ->
{
public void run (Boolean response)
{
if (response)
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " coins.");
else
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + amount + " coins. Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), "Coins", amount, response);
}
}, "purchase", name, client.getAccountId(), amount);
if (response)
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " coins.");
else
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + amount + " coins. Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), "Coins", amount, response);
});
return true;
}
protected boolean checkForBoosterPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
protected boolean checkForBoosterPurchase(String[] args, final String name, final UUID playerUUID, final CoreClient client)
{
if (args.length != 3 || !args[0].equalsIgnoreCase("booster"))
return false;
final int amount = Integer.parseInt(args[2]);
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
{
public void run (Boolean response)
public void run(Boolean response)
{
if (response)
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " gem boosters.");
else
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + amount + " gem boosters. Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), "Gem Boosters", amount, response);
}
}, client.getAccountId(), "Game Booster", amount);
return true;
}
@ -310,15 +304,16 @@ public class Enjin extends MiniPlugin implements CommandExecutor
_powerPlayClubRepository.addSubscription(client.getAccountId(), date, duration);
} else if (args[2].equalsIgnoreCase("cancel"))
}
else if (args[2].equalsIgnoreCase("cancel"))
{
// TODO: cancel it in our logs? I don't think this is necessary.
}
return false;
}
protected boolean checkForClansPurchase(String[] args, final String name, final CoreClient client)
protected boolean checkForClansPurchase(String[] args, final String name, final CoreClient client)
{
if (args.length >= 3 && args[0].equalsIgnoreCase("clansBanner"))
{
@ -328,37 +323,34 @@ public class Enjin extends MiniPlugin implements CommandExecutor
purchase = "Clan Banner Editor";
}
final String packageName = purchase;
_donationManager.PurchaseUnknownSalesPackage(new Callback<TransactionResponse>()
_donationManager.purchaseUnknownSalesPackage(client, packageName, GlobalCurrency.GEM, 0, false, data ->
{
public void run(TransactionResponse data)
if (data == TransactionResponse.Success)
{
if (data == TransactionResponse.Success)
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
{
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
public void run(Boolean success)
{
public void run(Boolean success)
if (success)
{
if (success)
{
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, true);
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received their " + packageName + " access.");
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + packageName + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, false);
}
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, true);
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received their " + packageName + " access.");
}
}, client.getAccountId(), packageName, 1);
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " 1" + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, data == TransactionResponse.Success);
}
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " " + packageName + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, false);
}
}
}, client.getAccountId(), packageName, 1);
}
}, name, client.getAccountId(), packageName, GlobalCurrency.GEM, 0, false);
else
{
System.out.println("[" + _dateFormat.format(new Date()) + "] ERROR processing " + name + " 1" + ". Queuing for run later.");
_purchaseManager.addAccountPurchaseToQueue(client.getAccountId(), packageName, 1, false);
}
});
//enjin_mineplex clansBanner AlexTheCoder true
return true;
}
@ -367,10 +359,10 @@ public class Enjin extends MiniPlugin implements CommandExecutor
//enjin_mineplex clansAmplifier AlexTheCoder 20 1
final String item = "Rune Amplifier " + args[2];
final int amount = Integer.parseInt(args[3]);
_inventoryManager.addItemToInventoryForOffline(new Callback<Boolean>()
{
public void run (Boolean response)
public void run(Boolean response)
{
if (response)
System.out.println("[" + _dateFormat.format(new Date()) + "] " + name + " received " + amount + " rune amplifiers.");
@ -381,7 +373,7 @@ public class Enjin extends MiniPlugin implements CommandExecutor
}
}, client.getAccountId(), item, amount);
}
return false;
}
}

4
Plugins/Mineplex.EnjinTranslator/src/mineplex/enjinTranslator/EnjinTranslator.java
View File

@ -7,6 +7,8 @@ import mineplex.core.inventory.InventoryManager;
import mineplex.core.updater.Updater;
import org.bukkit.plugin.java.JavaPlugin;
import static mineplex.core.Managers.require;
public class EnjinTranslator extends JavaPlugin
{
private String WEB_CONFIG = "webServer";
@ -25,7 +27,7 @@ public class EnjinTranslator extends JavaPlugin
CoreClientManager clientManager = new CoreClientManager(this, GetWebServerAddress());
CommandCenter.Instance.setClientManager(clientManager);
DonationManager donationManager = new DonationManager(this, clientManager, GetWebServerAddress());
DonationManager donationManager = require(DonationManager.class);
//Main Modules
new Enjin(this, clientManager, donationManager, new InventoryManager(this, clientManager));

13
Plugins/Mineplex.EnjinTranslator/src/mineplex/enjinTranslator/TempRepository.java
View File

@ -4,7 +4,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.column.ColumnInt;
import mineplex.serverdata.database.column.ColumnVarChar;
@ -14,21 +13,11 @@ public class TempRepository extends MinecraftRepository
public TempRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public void addGemBooster(String name, int amount)
{
executeUpdate(INSERT_CLIENT_INVENTORY, new ColumnInt("count", amount), new ColumnVarChar("name", 100, name));
}
@Override
protected void initialize()
{
}
@Override
protected void update()
{
}
}

9
Plugins/Mineplex.EnjinTranslator/src/mineplex/enjinTranslator/purchase/data/PurchaseRepository.java
View File

@ -9,7 +9,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnBoolean;
import mineplex.serverdata.database.column.ColumnInt;
@ -24,14 +23,8 @@ public class PurchaseRepository extends MinecraftRepository
public PurchaseRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
@Override
protected void initialize() { }
@Override
protected void update() { }
public void addPackage(String name, ResultSetCallable callable)
{

8
Plugins/Mineplex.Game.Clans.Core/src/mineplex/game/clans/core/repository/ClanRepository.java
View File

@ -13,7 +13,6 @@ import mineplex.core.common.util.Callback;
import mineplex.core.common.util.NautHashMap;
import mineplex.core.database.MinecraftRepository;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.Column;
import mineplex.serverdata.database.column.ColumnBoolean;
@ -88,7 +87,7 @@ public class ClanRepository extends MinecraftRepository
public ClanRepository(JavaPlugin plugin, String serverName, boolean isClansServer)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_serverName = serverName;
_serverId = -1;
@ -399,11 +398,6 @@ public class ClanRepository extends MinecraftRepository
System.out.println("Finished loading clans from database...");
return clans.values();
}
@Override
protected void update()
{
}
public boolean deleteClan(int clanId)
{

2
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/Clans.java
View File

@ -109,7 +109,7 @@ public class Clans extends JavaPlugin
VisibilityManager.Initialize(this);
// new ProfileCacheManager(this);
_donationManager = new DonationManager(this, _clientManager, webServerAddress);
_donationManager = require(DonationManager.class);
new FallingBlocks(this);

8
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/ban/ClansBanRepository.java
View File

@ -22,7 +22,7 @@ public class ClansBanRepository extends MinecraftRepository
public ClansBanRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public CompletableFuture<Optional<ClansBan>> ban(UUID uuid, String admin, long time, String reason)
@ -110,12 +110,6 @@ public class ClansBanRepository extends MinecraftRepository
}
});
}
@Override
protected void initialize() {}
@Override
protected void update() {}
public void removeBan(ClansBan ban)
{

4
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/banners/BannerManager.java
View File

@ -60,11 +60,11 @@ public class BannerManager extends MiniPlugin
public int getBannerUnlockLevel(Player player)
{
int level = 0;
if (ClansManager.getInstance().getDonationManager().Get(player).OwnsUnknownPackage("Clan Banner Usage"))
if (ClansManager.getInstance().getDonationManager().Get(player).ownsUnknownSalesPackage("Clan Banner Usage"))
{
level = 1;
}
if (ClansManager.getInstance().getDonationManager().Get(player).OwnsUnknownPackage("Clan Banner Editor"))
if (ClansManager.getInstance().getDonationManager().Get(player).ownsUnknownSalesPackage("Clan Banner Editor"))
{
level = 2;
}

11
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/banners/BannerRepository.java
View File

@ -35,7 +35,7 @@ public class BannerRepository extends MinecraftRepository
public BannerRepository(JavaPlugin plugin, BannerManager bannerManager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_bannerManager = bannerManager;
}
@ -162,13 +162,4 @@ public class BannerRepository extends MinecraftRepository
executeUpdate(DELETE_BANNER, new ColumnInt("clanId", clan.getId()));
});
}
@Override
protected void initialize()
{
//executeUpdate(CREATE);
}
@Override
protected void update() {}
}

7
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/nameblacklist/repository/ClanNameBlacklistRepository.java
View File

@ -29,7 +29,7 @@ public class ClanNameBlacklistRepository extends MinecraftRepository
public ClanNameBlacklistRepository(JavaPlugin plugin, ClansBlacklist blacklist)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_blacklist = blacklist;
}
@ -60,11 +60,6 @@ public class ClanNameBlacklistRepository extends MinecraftRepository
callback.run(list);
});
}
@Override
protected void initialize()
{
}
@Override
protected void update()

13
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/nether/PortalRepository.java
View File

@ -28,7 +28,7 @@ public class PortalRepository extends MinecraftRepository
public PortalRepository(JavaPlugin plugin, NetherManager portalManager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_nether = portalManager;
}
@ -95,15 +95,4 @@ public class PortalRepository extends MinecraftRepository
executeUpdate(DELETE_PORTAL, new ColumnInt("id", id));
});
}
@Override
protected void initialize()
{
executeUpdate(CREATE);
}
@Override
protected void update()
{
}
}

7
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/siege/repository/OutpostRepository.java
View File

@ -47,7 +47,7 @@ public class OutpostRepository extends MinecraftRepository
public OutpostRepository(JavaPlugin plugin, OutpostManager manager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_manager = manager;
}
@ -115,11 +115,6 @@ public class OutpostRepository extends MinecraftRepository
executeUpdate(CREATE);
}
@Override
protected void update()
{
}
public void updateOutpost(OutpostToken token)
{
executeUpdate(UPDATE_OUTPOST,

15
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/clans/siege/repository/SiegeWeaponRepository.java
View File

@ -3,9 +3,7 @@ package mineplex.game.clans.clans.siege.repository;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bukkit.plugin.java.JavaPlugin;
@ -48,7 +46,7 @@ public class SiegeWeaponRepository extends MinecraftRepository
public SiegeWeaponRepository(JavaPlugin plugin, SiegeManager siegeManager)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
_siegeManager = siegeManager;
}
@ -158,15 +156,4 @@ public class SiegeWeaponRepository extends MinecraftRepository
new ColumnTimestamp("lastFired", new Timestamp(token.LastFired)),
new ColumnVarChar("entities", 100, ""));
}
@Override
protected void initialize()
{
//executeUpdate(CREATE);
}
@Override
protected void update()
{
}
}

56
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/economy/GoldManager.java
View File

@ -12,6 +12,7 @@ import mineplex.game.clans.clans.ClansDataAccessLayer;
import mineplex.game.clans.clans.ClansManager;
import mineplex.game.clans.items.economy.GoldToken;
import mineplex.game.clans.shop.bank.BankShop;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
@ -33,14 +34,18 @@ import java.util.*;
public class GoldManager extends MiniDbClientPlugin<GoldData>
{
public static final double GEM_CONVERSION_RATE = 16; // The number of gold coins when converted from a single gem
public static final double DEATH_TAX = 0.04d; // Percentage of gold lost on death
public static final double GEM_CONVERSION_RATE = 16; // The number of gold coins when converted from a single gem
public static final double DEATH_TAX = 0.04d; // Percentage of gold lost on death
public static final String META_STRING = "clans.goldAmount";
private static GoldManager _instance;
public static GoldManager getInstance() { return _instance; }
public static GoldManager getInstance()
{
return _instance;
}
private DonationManager _donationManager;
private final int _serverId;
private TransferTracker _transferTracker;
@ -76,11 +81,11 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
{
final Player player = event.getEntity();
final Player killer = player.getKiller();
int gold = getGold(player);
final int droppedGold = (int) (gold * DEATH_TAX);
final Location deathLocation = player.getLocation();
if (droppedGold > 0)
{
deductGold(new Callback<Boolean>()
@ -106,7 +111,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
}, player, droppedGold);
}
}
@EventHandler
public void playerCmd(PlayerCommandPreprocessEvent event)
{
@ -117,7 +122,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
}
}
@EventHandler (ignoreCancelled = true)
@EventHandler(ignoreCancelled = true)
public void onPickup(PlayerPickupItemEvent event)
{
if (_itemSet.contains(event.getItem()))
@ -178,31 +183,31 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
}
}
}
public int getGold(Player player)
{
return Get(player).getBalance();
}
public int getGems(Player player)
{
return getDonor(player).getBalance(GlobalCurrency.GEM);
}
public void transferGemsToCoins(Player player, int gemAmount)
{
int gemCount = getGems(player);
int goldCount = (int) (((double) gemAmount) * GEM_CONVERSION_RATE);
if (gemCount >= gemAmount)
{
_donationManager.RewardGemsLater("GoldManager", player, -gemAmount);
_donationManager.rewardCurrency(GlobalCurrency.GEM, player, "GoldManager", -gemAmount);
addGold(player, goldCount);
notify(player, String.format("You have transferred %d gems into %d gold coins!", gemAmount, goldCount));
_transferTracker.insertTransfer(player);
}
}
/**
* @param player - the player to be checked for whether they can transfer gems into coins
* @return true, if the player has not converted gems into coins within the
@ -215,7 +220,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
public void cashIn(Player player, GoldToken token)
{
int value = token.getGoldValue();
int value = token.getGoldValue();
addGold(player, value);
notify(player, String.format("You have cashed in a gold token worth %dg!", value));
}
@ -228,7 +233,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
public void dropGold(Location location, int amount, double velMult)
{
int count = amount / 1000;
if (count > 75)
{
double x = Math.random() * 2 * Math.PI;
@ -236,7 +241,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
dropGold(location, amount, velocity, velMult, "Gold " + 0);
return;
}
int extraGold = amount % 1000;
for (int i = 0; i < count; i++)
@ -267,11 +272,11 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
item.setMetadata(META_STRING, new FixedMetadataValue(getPlugin(), amount));
_itemSet.add(item);
// Velocity
UtilAction.velocity(item, velocity, velMult, false, 0, 0.2, 0.2, false);
}
public void purchaseToken(final Player player, final int tokenValue)
{
final GoldToken token = new GoldToken(tokenValue);
@ -291,13 +296,13 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
}
}, player, tokenValue);
}
private Donor getDonor(Player player)
{
return _donationManager.Get(player);
}
public static void notify(Player player, String message)
{
UtilPlayer.message(player, F.main("Gold", message));
@ -409,7 +414,7 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
if (resultSet.next())
{
Get(playerUUID).setBalance(resultSet.getInt(1));
if (resultSet.getInt(1) < 0)
{
setGold(new Callback<Boolean>()
@ -431,7 +436,8 @@ public class GoldManager extends MiniDbClientPlugin<GoldData>
}
@Override
protected GoldData addPlayer(UUID uuid) {
protected GoldData addPlayer(UUID uuid)
{
return new GoldData();
}
}

9
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/fields/repository/FieldRepository.java
View File

@ -9,7 +9,6 @@ import mineplex.core.database.MinecraftRepository;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.serverdata.database.DBPool;
import mineplex.serverdata.database.RepositoryBase;
import mineplex.serverdata.database.ResultSetCallable;
import mineplex.serverdata.database.column.ColumnByte;
import mineplex.serverdata.database.column.ColumnDouble;
@ -35,7 +34,7 @@ public class FieldRepository extends MinecraftRepository
public FieldRepository(JavaPlugin plugin)
{
super(plugin, DBPool.getAccount());
super(DBPool.getAccount());
}
public List<FieldBlockToken> getFieldBlocks(String server)
@ -179,10 +178,4 @@ public class FieldRepository extends MinecraftRepository
executeUpdate(CREATE_FIELD_ORE_TABLE);
executeUpdate(CREATE_FIELD_MONSTER_TABLE);
}
@Override
protected void update()
{
}
}

Some files were not shown because too many files have changed in this diff Show More