Saber-Factions/src/main/java/com/massivecraft/factions/integration/Econ.java

374 lines
14 KiB
Java
Raw Normal View History

package com.massivecraft.factions.integration;
2014-04-04 20:55:21 +02:00
import com.massivecraft.factions.*;
2011-10-12 17:25:01 +02:00
import com.massivecraft.factions.iface.EconomyParticipator;
import com.massivecraft.factions.struct.Permission;
2011-10-12 17:25:01 +02:00
import com.massivecraft.factions.struct.Role;
import com.massivecraft.factions.util.RelationUtil;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.economy.EconomyResponse;
2014-04-04 20:55:21 +02:00
import org.bukkit.Bukkit;
import org.bukkit.plugin.RegisteredServiceProvider;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;
public class Econ {
private static Economy econ = null;
public static void setup() {
2014-07-01 22:10:18 +02:00
if (isSetup()) {
return;
}
2014-04-04 20:55:21 +02:00
String integrationFail = "Economy integration is " + (Conf.econEnabled ? "enabled, but" : "disabled, and") + " the plugin \"Vault\" ";
if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
2014-07-01 22:10:18 +02:00
P.p.log(integrationFail + "is not installed.");
return;
2014-04-04 20:55:21 +02:00
}
RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
if (rsp == null) {
2014-07-01 22:10:18 +02:00
P.p.log(integrationFail + "is not hooked into an economy plugin.");
return;
}
econ = rsp.getProvider();
2014-04-04 20:55:21 +02:00
P.p.log("Economy integration through Vault plugin successful.");
2014-07-01 21:49:42 +02:00
if (!Conf.econEnabled) {
2014-04-04 20:55:21 +02:00
P.p.log("NOTE: Economy is disabled. You can enable it with the command: f config econEnabled true");
2014-07-01 21:49:42 +02:00
}
2014-04-04 20:55:21 +02:00
P.p.cmdBase.cmdHelp.updateHelp();
oldMoneyDoTransfer();
}
public static boolean shouldBeUsed() {
return Conf.econEnabled && econ != null && econ.isEnabled();
}
public static boolean isSetup() {
return econ != null;
}
public static void modifyUniverseMoney(double delta) {
2014-07-01 22:10:18 +02:00
if (!shouldBeUsed()) {
return;
}
2014-04-04 20:55:21 +02:00
2014-07-01 22:10:18 +02:00
if (Conf.econUniverseAccount == null) {
return;
}
if (Conf.econUniverseAccount.length() == 0) {
return;
}
if (!econ.hasAccount(Conf.econUniverseAccount)) {
return;
}
2014-04-04 20:55:21 +02:00
modifyBalance(Conf.econUniverseAccount, delta);
}
public static void sendBalanceInfo(FPlayer to, EconomyParticipator about) {
if (!shouldBeUsed()) {
2014-07-01 22:10:18 +02:00
P.p.log(Level.WARNING, "Vault does not appear to be hooked into an economy plugin.");
return;
2014-04-04 20:55:21 +02:00
}
to.msg("<a>%s's<i> balance is <h>%s<i>.", about.describeTo(to, true), Econ.moneyString(econ.getBalance(about.getAccountId())));
}
2014-04-04 20:55:21 +02:00
public static boolean canIControllYou(EconomyParticipator i, EconomyParticipator you) {
2014-07-01 22:10:18 +02:00
Faction fI = RelationUtil.getFaction(i);
Faction fYou = RelationUtil.getFaction(you);
2014-04-04 20:55:21 +02:00
// This is a system invoker. Accept it.
2014-07-01 22:10:18 +02:00
if (fI == null) {
return true;
}
2014-04-04 20:55:21 +02:00
// Bypassing players can do any kind of transaction
2014-07-01 22:10:18 +02:00
if (i instanceof FPlayer && ((FPlayer) i).isAdminBypassing()) {
return true;
}
2014-04-04 20:55:21 +02:00
// Players with the any withdraw can do.
2014-07-01 22:10:18 +02:00
if (i instanceof FPlayer && Permission.MONEY_WITHDRAW_ANY.has(((FPlayer) i).getPlayer())) {
return true;
}
2014-04-04 20:55:21 +02:00
// You can deposit to anywhere you feel like. It's your loss if you can't withdraw it again.
2014-07-01 22:10:18 +02:00
if (i == you) {
return true;
}
2014-04-04 20:55:21 +02:00
// A faction can always transfer away the money of it's members and its own money...
// This will however probably never happen as a faction does not have free will.
// Ohh by the way... Yes it could. For daily rent to the faction.
2014-07-01 22:10:18 +02:00
if (i == fI && fI == fYou) {
return true;
}
2014-04-04 20:55:21 +02:00
// Factions can be controlled by members that are moderators... or any member if any member can withdraw.
2014-07-01 21:49:42 +02:00
if (you instanceof Faction && fI == fYou && (Conf.bankMembersCanWithdraw || ((FPlayer) i).getRole().value >= Role.MODERATOR.value)) {
2014-04-04 20:55:21 +02:00
return true;
2014-07-01 21:49:42 +02:00
}
2014-04-04 20:55:21 +02:00
// Otherwise you may not! ;,,;
i.msg("<h>%s<i> lacks permission to control <h>%s's<i> money.", i.describeTo(i, true), you.describeTo(i));
return false;
}
public static boolean transferMoney(EconomyParticipator invoker, EconomyParticipator from, EconomyParticipator to, double amount) {
return transferMoney(invoker, from, to, amount, true);
}
public static boolean transferMoney(EconomyParticipator invoker, EconomyParticipator from, EconomyParticipator to, double amount, boolean notify) {
2014-07-01 22:10:18 +02:00
if (!shouldBeUsed()) {
return false;
}
2014-04-04 20:55:21 +02:00
// The amount must be positive.
// If the amount is negative we must flip and multiply amount with -1.
if (amount < 0) {
2014-07-01 22:10:18 +02:00
amount *= -1;
EconomyParticipator temp = from;
from = to;
to = temp;
2014-04-04 20:55:21 +02:00
}
// Check the rights
2014-07-01 22:10:18 +02:00
if (!canIControllYou(invoker, from)) {
return false;
}
2014-04-04 20:55:21 +02:00
// Is there enough money for the transaction to happen?
if (!econ.has(from.getAccountId(), amount)) {
// There was not enough money to pay
2014-07-01 21:49:42 +02:00
if (invoker != null && notify) {
2014-04-04 20:55:21 +02:00
invoker.msg("<h>%s<b> can't afford to transfer <h>%s<b> to %s<b>.", from.describeTo(invoker, true), moneyString(amount), to.describeTo(invoker));
2014-07-01 21:49:42 +02:00
}
2014-04-04 20:55:21 +02:00
return false;
}
// Transfer money
EconomyResponse erw = econ.withdrawPlayer(from.getAccountId(), amount);
if (erw.transactionSuccess()) {
2014-07-01 22:10:18 +02:00
EconomyResponse erd = econ.depositPlayer(to.getAccountId(), amount);
if (erd.transactionSuccess()) {
if (notify) {
sendTransferInfo(invoker, from, to, amount);
}
return true;
2014-07-01 21:52:40 +02:00
} else {
2014-04-04 20:55:21 +02:00
// transaction failed, refund account
econ.depositPlayer(from.getAccountId(), amount);
}
}
// if we get here something with the transaction failed
2014-07-01 21:49:42 +02:00
if (notify) {
2014-04-04 20:55:21 +02:00
invoker.msg("Unable to transfer %s<b> to <h>%s<b> from <h>%s<b>.", moneyString(amount), to.describeTo(invoker), from.describeTo(invoker, true));
2014-07-01 21:49:42 +02:00
}
2014-04-04 20:55:21 +02:00
return false;
}
public static Set<FPlayer> getFplayers(EconomyParticipator ep) {
Set<FPlayer> fplayers = new HashSet<FPlayer>();
if (ep == null) {
// Add nothing
2014-07-01 21:52:40 +02:00
} else if (ep instanceof FPlayer) {
2014-04-04 20:55:21 +02:00
fplayers.add((FPlayer) ep);
2014-07-01 21:52:40 +02:00
} else if (ep instanceof Faction) {
2014-04-04 20:55:21 +02:00
fplayers.addAll(((Faction) ep).getFPlayers());
}
return fplayers;
}
public static void sendTransferInfo(EconomyParticipator invoker, EconomyParticipator from, EconomyParticipator to, double amount) {
2014-07-01 22:10:18 +02:00
Set<FPlayer> recipients = new HashSet<FPlayer>();
recipients.addAll(getFplayers(invoker));
recipients.addAll(getFplayers(from));
recipients.addAll(getFplayers(to));
2014-04-04 20:55:21 +02:00
if (invoker == null) {
for (FPlayer recipient : recipients) {
recipient.msg("<h>%s<i> was transfered from <h>%s<i> to <h>%s<i>.", moneyString(amount), from.describeTo(recipient), to.describeTo(recipient));
}
2014-07-01 21:52:40 +02:00
} else if (invoker == from) {
2014-04-04 20:55:21 +02:00
for (FPlayer recipient : recipients) {
recipient.msg("<h>%s<i> <h>gave %s<i> to <h>%s<i>.", from.describeTo(recipient, true), moneyString(amount), to.describeTo(recipient));
}
2014-07-01 21:52:40 +02:00
} else if (invoker == to) {
2014-04-04 20:55:21 +02:00
for (FPlayer recipient : recipients) {
recipient.msg("<h>%s<i> <h>took %s<i> from <h>%s<i>.", to.describeTo(recipient, true), moneyString(amount), from.describeTo(recipient));
}
2014-07-01 21:52:40 +02:00
} else {
2014-04-04 20:55:21 +02:00
for (FPlayer recipient : recipients) {
recipient.msg("<h>%s<i> transfered <h>%s<i> from <h>%s<i> to <h>%s<i>.", invoker.describeTo(recipient, true), moneyString(amount), from.describeTo(recipient), to.describeTo(recipient));
}
}
}
public static boolean hasAtLeast(EconomyParticipator ep, double delta, String toDoThis) {
2014-07-01 22:10:18 +02:00
if (!shouldBeUsed()) {
return true;
}
2014-04-04 20:55:21 +02:00
if (!econ.has(ep.getAccountId(), delta)) {
2014-07-01 21:49:42 +02:00
if (toDoThis != null && !toDoThis.isEmpty()) {
2014-04-04 20:55:21 +02:00
ep.msg("<h>%s<i> can't afford <h>%s<i> %s.", ep.describeTo(ep, true), moneyString(delta), toDoThis);
2014-07-01 22:10:18 +02:00
}
return false;
}
return true;
2014-04-04 20:55:21 +02:00
}
public static boolean modifyMoney(EconomyParticipator ep, double delta, String toDoThis, String forDoingThis) {
2014-07-01 22:10:18 +02:00
if (!shouldBeUsed()) {
return false;
}
2014-04-04 20:55:21 +02:00
2014-07-01 22:10:18 +02:00
String acc = ep.getAccountId();
String You = ep.describeTo(ep, true);
2014-04-04 20:55:21 +02:00
if (delta == 0) {
// no money actually transferred?
// ep.msg("<h>%s<i> didn't have to pay anything %s.", You, forDoingThis); // might be for gains, might be for losses
2014-04-04 20:55:21 +02:00
return true;
}
if (delta > 0) {
// The player should gain money
// The account might not have enough space
2014-07-01 22:10:18 +02:00
EconomyResponse er = econ.depositPlayer(acc, delta);
if (er.transactionSuccess()) {
modifyUniverseMoney(-delta);
if (forDoingThis != null && !forDoingThis.isEmpty()) {
2014-04-04 20:55:21 +02:00
ep.msg("<h>%s<i> gained <h>%s<i> %s.", You, moneyString(delta), forDoingThis);
2014-07-01 22:10:18 +02:00
}
return true;
2014-07-01 21:52:40 +02:00
} else {
2014-04-04 20:55:21 +02:00
// transfer to account failed
2014-07-01 21:49:42 +02:00
if (forDoingThis != null && !forDoingThis.isEmpty()) {
2014-04-04 20:55:21 +02:00
ep.msg("<h>%s<i> would have gained <h>%s<i> %s, but the deposit failed.", You, moneyString(delta), forDoingThis);
2014-07-01 22:10:18 +02:00
}
return false;
2014-04-04 20:55:21 +02:00
}
2014-07-01 21:52:40 +02:00
} else {
2014-04-04 20:55:21 +02:00
// The player should loose money
// The player might not have enough.
if (econ.has(acc, -delta) && econ.withdrawPlayer(acc, -delta).transactionSuccess()) {
// There is enough money to pay
2014-07-01 22:10:18 +02:00
modifyUniverseMoney(-delta);
if (forDoingThis != null && !forDoingThis.isEmpty()) {
2014-04-04 20:55:21 +02:00
ep.msg("<h>%s<i> lost <h>%s<i> %s.", You, moneyString(-delta), forDoingThis);
2014-07-01 22:10:18 +02:00
}
return true;
2014-07-01 21:52:40 +02:00
} else {
2014-04-04 20:55:21 +02:00
// There was not enough money to pay
2014-07-01 21:49:42 +02:00
if (toDoThis != null && !toDoThis.isEmpty()) {
2014-04-04 20:55:21 +02:00
ep.msg("<h>%s<i> can't afford <h>%s<i> %s.", You, moneyString(-delta), toDoThis);
2014-07-01 22:10:18 +02:00
}
return false;
2014-04-04 20:55:21 +02:00
}
}
}
// format money string based on server's set currency type, like "24 gold" or "$24.50"
public static String moneyString(double amount) {
return econ.format(amount);
}
public static void oldMoneyDoTransfer() {
2014-07-01 22:10:18 +02:00
if (!shouldBeUsed()) {
return;
}
2014-04-04 20:55:21 +02:00
for (Faction faction : Factions.i.get()) {
if (faction.money > 0) {
2014-07-01 22:10:18 +02:00
econ.depositPlayer(faction.getAccountId(), faction.money);
faction.money = 0;
2014-04-04 20:55:21 +02:00
}
}
}
// calculate the cost for claiming land
public static double calculateClaimCost(int ownedLand, boolean takingFromAnotherFaction) {
if (!shouldBeUsed()) {
return 0d;
}
// basic claim cost, plus land inflation cost, minus the potential bonus given for claiming from another faction
2014-07-01 21:52:40 +02:00
return Conf.econCostClaimWilderness + (Conf.econCostClaimWilderness * Conf.econClaimAdditionalMultiplier * ownedLand) - (takingFromAnotherFaction ? Conf.econCostClaimFromFactionBonus : 0);
2014-04-04 20:55:21 +02:00
}
// calculate refund amount for unclaiming land
public static double calculateClaimRefund(int ownedLand) {
return calculateClaimCost(ownedLand - 1, false) * Conf.econClaimRefundMultiplier;
}
// calculate value of all owned land
public static double calculateTotalLandValue(int ownedLand) {
2014-07-01 22:10:18 +02:00
double amount = 0;
for (int x = 0; x < ownedLand; x++) {
2014-04-04 20:55:21 +02:00
amount += calculateClaimCost(x, false);
2014-07-01 22:10:18 +02:00
}
return amount;
2014-04-04 20:55:21 +02:00
}
// calculate refund amount for all owned land
public static double calculateTotalLandRefund(int ownedLand) {
return calculateTotalLandValue(ownedLand) * Conf.econClaimRefundMultiplier;
}
// -------------------------------------------- //
// Standard account management methods
// -------------------------------------------- //
public static boolean hasAccount(String name) {
return econ.hasAccount(name);
}
public static double getBalance(String account) {
return econ.getBalance(account);
}
public static boolean setBalance(String account, double amount) {
double current = econ.getBalance(account);
2014-07-01 22:10:18 +02:00
if (current > amount) {
return econ.withdrawPlayer(account, current - amount).transactionSuccess();
} else {
2014-07-01 21:52:40 +02:00
return econ.depositPlayer(account, amount - current).transactionSuccess();
}
2014-04-04 20:55:21 +02:00
}
public static boolean modifyBalance(String account, double amount) {
2014-07-01 22:10:18 +02:00
if (amount < 0) {
return econ.withdrawPlayer(account, -amount).transactionSuccess();
} else {
2014-07-01 21:52:40 +02:00
return econ.depositPlayer(account, amount).transactionSuccess();
}
2014-04-04 20:55:21 +02:00
}
public static boolean deposit(String account, double amount) {
return econ.depositPlayer(account, amount).transactionSuccess();
}
public static boolean withdraw(String account, double amount) {
return econ.withdrawPlayer(account, amount).transactionSuccess();
}
}