forked from MagicBane/Server
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1275 lines
41 KiB
1275 lines
41 KiB
// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ . |
|
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌· |
|
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀ |
|
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌ |
|
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀ |
|
// Magicbane Emulator Project © 2013 - 2022 |
|
// www.magicbane.com |
|
|
|
|
|
// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ . |
|
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌· |
|
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀ |
|
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌ |
|
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀ |
|
// Magicbane Emulator Project © 2013 - 2022 |
|
// www.magicbane.com |
|
|
|
|
|
package engine.objects; |
|
|
|
import engine.Enum; |
|
import engine.Enum.*; |
|
import engine.db.archive.DataWarehouse; |
|
import engine.db.archive.GuildRecord; |
|
import engine.db.handlers.dbGuildHandler; |
|
import engine.gameManager.*; |
|
import engine.net.ByteBufferWriter; |
|
import engine.net.Dispatch; |
|
import engine.net.DispatchMessage; |
|
import engine.net.client.msg.AllianceChangeMsg; |
|
import engine.net.client.msg.ErrorPopupMsg; |
|
import engine.net.client.msg.UpdateClientAlliancesMsg; |
|
import engine.net.client.msg.guild.GuildInfoMsg; |
|
import engine.server.world.WorldServer; |
|
import org.joda.time.DateTime; |
|
import org.pmw.tinylog.Logger; |
|
|
|
import java.sql.ResultSet; |
|
import java.sql.SQLException; |
|
import java.util.ArrayList; |
|
import java.util.HashMap; |
|
import java.util.concurrent.ConcurrentHashMap; |
|
|
|
public class Guild extends AbstractWorldObject { |
|
|
|
private final String name; |
|
private Guild nation; |
|
private final GuildTag guildTag; |
|
// TODO add these to database |
|
private String motto = ""; |
|
private String motd = ""; |
|
private String icmotd = ""; |
|
private String nmotd = ""; |
|
private int guildLeaderUUID; |
|
private int realmsOwned; |
|
private final int charter; |
|
private int cityUUID = 0; |
|
private final String leadershipType; // Have to see how this is sent to the client |
|
private final int repledgeMin; |
|
private final int repledgeMax; |
|
private final int repledgeKick; |
|
private final int teleportMin; |
|
private final int teleportMax; |
|
private int mineTime; |
|
private ArrayList<PlayerCharacter> banishList; |
|
private ArrayList<PlayerCharacter> characterKOSList; |
|
private ArrayList<Guild> guildKOSList; |
|
private ArrayList<Guild> allyList = new ArrayList<>(); |
|
private ArrayList<Guild> enemyList = new ArrayList<>(); |
|
private ArrayList<Guild> recommendList = new ArrayList<>(); |
|
private ArrayList<Guild> subGuildList; |
|
private int nationUUID = 0; |
|
private GuildState guildState = GuildState.Errant; |
|
private final ConcurrentHashMap<Integer, Condemned> guildCondemned = new ConcurrentHashMap<>(); |
|
private String hash; |
|
private boolean ownerIsNPC; |
|
|
|
private static Guild errantGuild; |
|
private static Guild errantNation; |
|
|
|
public boolean wooWasModified; |
|
public HashMap<Integer, GuildAlliances> guildAlliances = new HashMap<>(); |
|
|
|
/** |
|
* No Id Constructor |
|
*/ |
|
public Guild(String name, Guild nat, int charter, |
|
String leadershipType, GuildTag gt, String motto) { |
|
super(); |
|
this.name = name; |
|
this.nation = nat; |
|
this.charter = charter; |
|
this.realmsOwned = 0; |
|
this.leadershipType = leadershipType; |
|
|
|
this.banishList = new ArrayList<>(); |
|
this.characterKOSList = new ArrayList<>(); |
|
this.guildKOSList = new ArrayList<>(); |
|
this.allyList = new ArrayList<>(); |
|
this.enemyList = new ArrayList<>(); |
|
this.subGuildList = new ArrayList<>(); |
|
|
|
this.guildTag = gt; |
|
|
|
//set for player city |
|
this.repledgeMin = 1; |
|
this.repledgeMax = 100; |
|
this.repledgeKick = 100; |
|
this.teleportMin = 1; |
|
this.teleportMax = 100; |
|
this.mineTime = 0; |
|
this.motto = motto; |
|
} |
|
|
|
/** |
|
* Normal Constructor |
|
*/ |
|
public Guild(String name, Guild nat, int charter, |
|
String leadershipType, GuildTag gt, int newUUID) { |
|
super(newUUID); |
|
this.name = name; |
|
this.nation = nat; |
|
|
|
this.charter = charter; |
|
this.realmsOwned = 0; |
|
this.leadershipType = leadershipType; |
|
|
|
this.banishList = new ArrayList<>(); |
|
this.characterKOSList = new ArrayList<>(); |
|
this.guildKOSList = new ArrayList<>(); |
|
this.allyList = new ArrayList<>(); |
|
this.enemyList = new ArrayList<>(); |
|
this.subGuildList = new ArrayList<>(); |
|
this.guildTag = gt; |
|
|
|
//set for player city |
|
this.repledgeMin = 1; |
|
this.repledgeMax = 100; |
|
this.repledgeKick = 100; |
|
this.teleportMin = 1; |
|
this.teleportMax = 100; |
|
this.mineTime = 0; |
|
this.hash = "ERRANT"; |
|
} |
|
|
|
/** |
|
* ResultSet Constructor |
|
*/ |
|
public Guild(ResultSet rs) throws SQLException { |
|
super(rs); |
|
DbObjectType objectType; |
|
|
|
this.name = rs.getString("name"); |
|
this.charter = rs.getInt("charter"); |
|
this.leadershipType = rs.getString("leadershipType"); |
|
|
|
this.guildTag = new GuildTag(rs.getInt("backgroundColor01"), |
|
rs.getInt("backgroundColor02"), |
|
rs.getInt("symbolColor"), |
|
rs.getInt("symbol"), |
|
rs.getInt("backgroundDesign")); |
|
|
|
//Declare Nations and Subguilds |
|
this.nationUUID = rs.getInt("parent"); |
|
this.cityUUID = rs.getInt("ownedCity"); |
|
this.guildLeaderUUID = rs.getInt("leaderUID"); |
|
this.motto = rs.getString("motto"); |
|
this.motd = rs.getString("motd"); |
|
this.icmotd = rs.getString("icMotd"); |
|
this.nmotd = rs.getString("nationMotd"); |
|
|
|
this.repledgeMin = rs.getInt("repledgeMin"); |
|
this.repledgeMax = rs.getInt("repledgeMax"); |
|
this.repledgeKick = rs.getInt("repledgeKick"); |
|
this.teleportMin = rs.getInt("teleportMin"); |
|
this.teleportMax = rs.getInt("teleportMax"); |
|
|
|
this.mineTime = rs.getInt("mineTime"); |
|
this.wooWasModified = false; |
|
|
|
this.hash = rs.getString("hash"); |
|
} |
|
|
|
public void setNation(Guild nation) { |
|
if (nation == null) |
|
this.nation = Guild.getErrantGuild(); |
|
else |
|
this.nation = nation; |
|
} |
|
|
|
/* |
|
* Getters |
|
*/ |
|
@Override |
|
public String getName() { |
|
return name; |
|
} |
|
|
|
public String getLeadershipType() { |
|
return leadershipType; |
|
} |
|
|
|
public Guild getNation() { |
|
|
|
if (this.nation == null) |
|
return Guild.getErrantGuild(); |
|
return this.nation; |
|
} |
|
|
|
public boolean isNation() { |
|
return this.nation != null && this.cityUUID != 0 && this.nation == this; |
|
} |
|
|
|
public City getOwnedCity() { |
|
|
|
return City.getCity(this.cityUUID); |
|
} |
|
|
|
public void setCityUUID(int cityUUID) { |
|
this.cityUUID = cityUUID; |
|
} |
|
|
|
public ArrayList<PlayerCharacter> getBanishList() { |
|
if (banishList == null) |
|
return new ArrayList<>(); |
|
return banishList; |
|
} |
|
|
|
public ArrayList<PlayerCharacter> getCharacterKOSList() { |
|
return characterKOSList; |
|
} |
|
|
|
public ArrayList<Guild> getGuildKOSList() { |
|
return guildKOSList; |
|
} |
|
|
|
public ArrayList<Guild> getAllyList() { |
|
return allyList; |
|
} |
|
|
|
public ArrayList<Guild> getEnemyList() { |
|
return enemyList; |
|
} |
|
|
|
public ArrayList<Guild> getSubGuildList() { |
|
|
|
return subGuildList; |
|
} |
|
|
|
public GuildTag getGuildTag() { |
|
return this.guildTag; |
|
} |
|
|
|
public int getCharter() { |
|
return charter; |
|
} |
|
|
|
public int getGuildLeaderUUID() { |
|
return this.guildLeaderUUID; |
|
} |
|
|
|
public static AbstractCharacter GetGL(Guild guild) { |
|
if (guild == null) |
|
return null; |
|
|
|
if (guild.guildLeaderUUID == 0) |
|
return null; |
|
|
|
if (guild.ownerIsNPC) |
|
return NPC.getFromCache(guild.guildLeaderUUID); |
|
|
|
return PlayerCharacter.getFromCache(guild.guildLeaderUUID); |
|
} |
|
|
|
public String getMOTD() { |
|
return this.motd; |
|
} |
|
|
|
public String getICMOTD() { |
|
return this.icmotd; |
|
} |
|
|
|
public boolean isNPCGuild() { |
|
|
|
return this.ownerIsNPC; |
|
} |
|
|
|
public int getRepledgeMin() { |
|
return this.repledgeMin; |
|
} |
|
|
|
public int getRepledgeMax() { |
|
return this.repledgeMax; |
|
} |
|
|
|
public int getRepledgeKick() { |
|
return this.repledgeKick; |
|
} |
|
|
|
public int getTeleportMin() { |
|
return this.teleportMin; |
|
} |
|
|
|
public int getTeleportMax() { |
|
return this.teleportMax; |
|
} |
|
|
|
public int getMineTime() { |
|
return this.mineTime; |
|
} |
|
|
|
/* |
|
* Setters |
|
*/ |
|
public void setGuildLeaderUUID(int value) { |
|
this.guildLeaderUUID = value; |
|
} |
|
|
|
public boolean setGuildLeader(AbstractCharacter ac) { |
|
if (ac == null) |
|
return false; |
|
// errant guilds cant be guild leader. |
|
if (this.isEmptyGuild()) |
|
return false; |
|
|
|
if (!DbManager.GuildQueries.SET_GUILD_LEADER(ac.getObjectUUID(), this.getObjectUUID())) { |
|
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)) |
|
ChatManager.chatGuildError((PlayerCharacter) ac, "Failed to change guild leader!"); |
|
return false; |
|
} |
|
|
|
PlayerCharacter oldGuildLeader = PlayerCharacter.getFromCache(this.guildLeaderUUID); |
|
|
|
//old guildLeader no longer has guildLeadership stauts. |
|
if (oldGuildLeader != null) |
|
oldGuildLeader.setGuildLeader(false); |
|
|
|
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)) |
|
((PlayerCharacter) ac).setGuildLeader(true); |
|
this.guildLeaderUUID = ac.getObjectUUID(); |
|
|
|
return true; |
|
} |
|
|
|
public boolean setGuildLeaderForCreate(AbstractCharacter ac) { |
|
if (ac == null) |
|
return false; |
|
// errant guilds cant be guild leader. |
|
if (this.isEmptyGuild()) |
|
return false; |
|
|
|
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)) |
|
((PlayerCharacter) ac).setGuildLeader(true); |
|
this.guildLeaderUUID = ac.getObjectUUID(); |
|
|
|
return true; |
|
} |
|
|
|
public void setMOTD(String value) { |
|
this.motd = value; |
|
} |
|
|
|
public void setICMOTD(String value) { |
|
this.icmotd = value; |
|
} |
|
|
|
public int getBgc1() { |
|
if (this.guildTag != null) |
|
return this.guildTag.backgroundColor01; |
|
return 16; |
|
} |
|
|
|
public int getBgc2() { |
|
if (this.guildTag != null) |
|
return this.guildTag.backgroundColor02; |
|
else |
|
return 16; |
|
} |
|
|
|
public int getBgDesign() { |
|
if (this.guildTag != null) |
|
return this.guildTag.backgroundDesign; |
|
return 0; |
|
} |
|
|
|
public int getSc() { |
|
if (this.guildTag != null) |
|
return this.guildTag.symbolColor; |
|
return 16; |
|
} |
|
|
|
public int getSymbol() { |
|
if (this.guildTag != null) |
|
return this.guildTag.symbol; |
|
return 0; |
|
} |
|
|
|
/* |
|
* Utils |
|
*/ |
|
|
|
public boolean isEmptyGuild() { |
|
return this.getObjectUUID() == Guild.errantGuild.getObjectUUID(); |
|
|
|
} |
|
|
|
public static boolean sameGuild(Guild a, Guild b) { |
|
if (a == null || b == null) |
|
return false; |
|
return a.getObjectUUID() == b.getObjectUUID(); |
|
} |
|
|
|
public static boolean sameGuildExcludeErrant(Guild a, Guild b) { |
|
if (a == null || b == null) |
|
return false; |
|
if (a.isEmptyGuild() || b.isEmptyGuild()) |
|
return false; |
|
return a.getObjectUUID() == b.getObjectUUID(); |
|
} |
|
|
|
public static boolean sameGuildIncludeErrant(Guild a, Guild b) { |
|
if (a == null || b == null) |
|
return false; |
|
if (a.isEmptyGuild() || b.isEmptyGuild()) |
|
return true; |
|
return a.getObjectUUID() == b.getObjectUUID(); |
|
} |
|
|
|
public static boolean sameNation(Guild a, Guild b) { |
|
if (a == null || b == null) |
|
return false; |
|
if (a.getObjectUUID() == b.getObjectUUID()) |
|
return true; |
|
if (a.nation == null || b.nation == null) |
|
return false; |
|
return a.nation.getObjectUUID() == b.nation.getObjectUUID(); |
|
} |
|
|
|
public static boolean sameNationExcludeErrant(Guild a, Guild b) { |
|
if (a == null || b == null) |
|
return false; |
|
if (a.getObjectUUID() == b.getObjectUUID()) |
|
return true; |
|
if (a.nation == null || b.nation == null) |
|
return false; |
|
return a.nation.getObjectUUID() == b.nation.getObjectUUID() && !a.nation.isEmptyGuild(); |
|
} |
|
|
|
public boolean isGuildLeader(int uuid) { |
|
|
|
return (this.guildLeaderUUID == uuid); |
|
} |
|
|
|
public static boolean isTaxCollector(int uuid) { |
|
//TODO add the handling for this later |
|
return false; |
|
} |
|
|
|
/** |
|
* Removes a PlayerCharacter from this (non-Errant) Guild. |
|
* |
|
* @param pc PlayerCharacter to be removed |
|
*/ |
|
public void removePlayer(PlayerCharacter pc, GuildHistoryType historyType) { |
|
|
|
if (this.isEmptyGuild()) { |
|
Logger.warn("Attempted to remove a PlayerCharacter (" + pc.getObjectUUID() + ") from an errant guild."); |
|
return; |
|
} |
|
|
|
//Add to Guild History |
|
if (pc.getGuild() != null) { |
|
if (DbManager.GuildQueries.ADD_TO_GUILDHISTORY(pc.getGuildUUID(), pc, DateTime.now(), historyType)) { |
|
GuildHistory guildHistory = new GuildHistory(pc.getGuildUUID(), pc.getGuild().name, DateTime.now(), historyType); |
|
pc.getGuildHistory().add(guildHistory); |
|
} |
|
} |
|
|
|
// Clear Guild Ranks |
|
pc.resetGuildStatuses(); |
|
pc.setGuild(Guild.getErrantGuild()); |
|
|
|
pc.incVer(); |
|
DispatchMessage.sendToAllInRange(pc, new GuildInfoMsg(pc, Guild.getErrantGuild(), 2)); |
|
|
|
} |
|
|
|
public void upgradeGuildState(boolean nation) { |
|
if (nation) { |
|
this.guildState = GuildState.Nation; |
|
return; |
|
} |
|
switch (this.guildState) { |
|
|
|
case Errant: |
|
this.guildState = GuildState.Petitioner; |
|
break; |
|
case Sworn: |
|
//Can't upgrade |
|
break; |
|
case Protectorate: |
|
this.guildState = GuildState.Province; |
|
break; |
|
case Petitioner: |
|
this.guildState = GuildState.Sworn; |
|
break; |
|
case Province: |
|
//Can't upgrade |
|
break; |
|
case Nation: |
|
//Can't upgrade |
|
break; |
|
case Sovereign: |
|
this.guildState = GuildState.Protectorate; |
|
break; |
|
} |
|
|
|
} |
|
|
|
public void downgradeGuildState() { |
|
|
|
switch (this.guildState) { |
|
case Errant: |
|
break; |
|
case Sworn: |
|
this.guildState = GuildState.Errant; |
|
break; |
|
case Protectorate: |
|
this.guildState = GuildState.Sovereign; |
|
break; |
|
case Petitioner: |
|
this.guildState = GuildState.Errant; |
|
break; |
|
case Province: |
|
this.guildState = GuildState.Sovereign; |
|
break; |
|
case Nation: |
|
this.guildState = GuildState.Sovereign; |
|
break; |
|
case Sovereign: |
|
this.guildState = GuildState.Errant; |
|
break; |
|
} |
|
|
|
} |
|
|
|
public boolean canSubAGuild(Guild toSub) { |
|
|
|
boolean canSub; |
|
|
|
if (this.equals(toSub)) |
|
return false; |
|
switch (this.guildState) { |
|
case Nation: |
|
case Sovereign: |
|
canSub = true; |
|
break; |
|
default: |
|
canSub = false; |
|
} |
|
|
|
switch (toSub.guildState) { |
|
case Errant: |
|
case Sovereign: |
|
canSub = true; |
|
break; |
|
default: |
|
canSub = false; |
|
} |
|
City nationCap = City.getCity(nation.cityUUID); |
|
if (nation.getSubGuildList().size() >= nationCap.getRank()) { |
|
canSub = false; |
|
} |
|
return canSub; |
|
} |
|
|
|
public static boolean canSwearIn(Guild toSub) { |
|
|
|
boolean canSwear = false; |
|
|
|
switch (toSub.guildState) { |
|
|
|
case Protectorate: |
|
case Petitioner: |
|
canSwear = true; |
|
break; |
|
default: |
|
canSwear = false; |
|
} |
|
|
|
return canSwear; |
|
} |
|
|
|
/* |
|
* Serialization |
|
*/ |
|
|
|
public static void _serializeForClientMsg(Guild guild, ByteBufferWriter writer) { |
|
Guild.serializeForClientMsg(guild, writer, null, false); |
|
} |
|
|
|
public static void serializeForClientMsg(Guild guild, ByteBufferWriter writer, PlayerCharacter pc, boolean reshowGuild) { |
|
writer.putInt(guild.getObjectType().ordinal()); |
|
writer.putInt(guild.getObjectUUID()); |
|
writer.putInt(guild.nation.getObjectType().ordinal()); |
|
writer.putInt(guild.nation.getObjectUUID()); |
|
|
|
if (pc == null) { |
|
writer.putInt(0); |
|
writer.putInt(0); |
|
writer.putInt(0); // Defaults |
|
writer.putInt(0); // Defaults |
|
} else { |
|
writer.putString(guild.name); |
|
writer.putString(guild.nation.name); |
|
writer.putInt(GuildStatusController.getTitle(pc.getGuildStatus())); // TODO Double check this is |
|
// title and rank |
|
if (GuildStatusController.isGuildLeader(pc.getGuildStatus())) |
|
writer.putInt(PlayerCharacter.GetPlayerRealmTitle(pc)); |
|
else |
|
writer.putInt(GuildStatusController.getRank(pc.getGuildStatus())); |
|
//writer.putInt(GuildStatusController.getRank(pc.getGuildStatus())); |
|
} |
|
|
|
City ownedCity = guild.getOwnedCity(); |
|
|
|
if (ownedCity != null) { |
|
Realm realm = guild.getOwnedCity().getRealm(); |
|
if (realm != null && realm.getRulingCity() != null) { |
|
if (realm.getRulingCity().equals(ownedCity)) { |
|
writer.putInt(realm.getCharterType()); |
|
} else |
|
writer.putInt(0); |
|
} else { |
|
writer.putInt(0); |
|
} |
|
} else |
|
writer.putInt(0); |
|
|
|
writer.putFloat(200); |
|
writer.putFloat(200); // Pad |
|
|
|
GuildTag._serializeForDisplay(guild.guildTag, writer); |
|
GuildTag._serializeForDisplay(guild.nation.guildTag, writer); |
|
if (reshowGuild) { |
|
writer.putInt(1); |
|
writer.putInt(guild.getObjectType().ordinal()); |
|
writer.putInt(guild.getObjectUUID()); |
|
|
|
} else |
|
writer.putInt(0); // Pad |
|
} |
|
|
|
public static void serializeForTrack(Guild guild, ByteBufferWriter writer) { |
|
Guild.serializeGuildForTrack(guild, writer); |
|
if (guild.nation != null) |
|
Guild.serializeGuildForTrack(guild.nation, writer); |
|
else |
|
Guild.addErrantForTrack(writer); |
|
} |
|
|
|
public static void serializeGuildForTrack(Guild guild, ByteBufferWriter writer) { |
|
writer.putInt(guild.getObjectType().ordinal()); |
|
writer.putInt(guild.getObjectUUID()); |
|
writer.put((byte) 1); |
|
GuildTag._serializeForDisplay(guild.guildTag, writer); |
|
} |
|
|
|
public static void serializeErrantForTrack(ByteBufferWriter writer) { |
|
addErrantForTrack(writer); //Guild |
|
addErrantForTrack(writer); //Nation |
|
} |
|
|
|
public int getRealmsOwnedFlag() { |
|
int flag = 0; |
|
switch (realmsOwned) { |
|
case 0: |
|
flag = 0; |
|
case 1: |
|
case 2: |
|
flag = 1; |
|
break; |
|
case 3: |
|
case 4: |
|
flag = 2; |
|
break; |
|
case 5: |
|
flag = 3; |
|
break; |
|
default: |
|
flag = 3; |
|
break; |
|
} |
|
return flag; |
|
} |
|
|
|
private static void addErrantForTrack(ByteBufferWriter writer) { |
|
writer.putInt(0); //type |
|
writer.putInt(0); //ID |
|
writer.put((byte) 1); |
|
writer.putInt(16); //Tags |
|
writer.putInt(16); |
|
writer.putInt(16); |
|
writer.putInt(0); |
|
writer.putInt(0); |
|
} |
|
|
|
public void serializeForPlayer(ByteBufferWriter writer) { |
|
writer.putInt(this.getObjectType().ordinal()); |
|
writer.putInt(this.getObjectUUID()); |
|
writer.putInt(this.nation.getObjectType().ordinal()); |
|
writer.putInt(this.nation.getObjectUUID()); |
|
|
|
} |
|
|
|
public static Guild getErrantGuild() { |
|
|
|
if (Guild.errantGuild == null) |
|
Guild.errantGuild = new Guild("None", Guild.getErrantNation(), 0, |
|
"Anarchy", GuildTag.ERRANT, 0); |
|
|
|
return Guild.errantGuild; |
|
} |
|
|
|
public static Guild getErrantNation() { |
|
if (Guild.errantNation == null) |
|
Guild.errantNation = new Guild("None", null, 10, "Despot Rule", GuildTag.ERRANT, 0); |
|
return Guild.errantNation; |
|
} |
|
|
|
public static Guild getGuild(final int objectUUID) { |
|
|
|
if (objectUUID == 0) |
|
return Guild.getErrantGuild(); |
|
Guild guild = (Guild) DbManager.getFromCache(Enum.GameObjectType.Guild, objectUUID); |
|
if (guild != null) |
|
return guild; |
|
|
|
Guild dbGuild = DbManager.GuildQueries.GET_GUILD(objectUUID); |
|
|
|
if (dbGuild == null) |
|
return Guild.getErrantGuild(); |
|
else |
|
return dbGuild; |
|
} |
|
|
|
|
|
@Override |
|
public void updateDatabase() { |
|
DbManager.GuildQueries.updateDatabase(this); |
|
} |
|
|
|
public boolean isRealmRuler() { |
|
|
|
City ownedCity; |
|
Building tol; |
|
|
|
ownedCity = this.getOwnedCity(); |
|
|
|
if (ownedCity == null) |
|
return false; |
|
|
|
tol = ownedCity.getTOL(); |
|
|
|
if (tol == null) |
|
return false; |
|
|
|
return tol.getRank() == 8; |
|
|
|
} |
|
|
|
@Override |
|
public void runAfterLoad() { |
|
|
|
try { |
|
DbObjectType objectType = DbManager.BuildingQueries.GET_UID_ENUM(this.guildLeaderUUID); |
|
this.ownerIsNPC = (objectType == DbObjectType.NPC); |
|
} catch (Exception e) { |
|
this.ownerIsNPC = false; |
|
Logger.error("Failed to find Object Type for owner " + this.guildLeaderUUID); |
|
} |
|
|
|
|
|
//LOad Owners in Cache so we do not have to continuely look in the db for owner. |
|
if (this.ownerIsNPC) { |
|
if (NPC.getNPC(this.guildLeaderUUID) == null) |
|
Logger.info("Guild UID " + this.getObjectUUID() + " Failed to Load NPC Owner with ID " + this.guildLeaderUUID); |
|
|
|
} else if (this.guildLeaderUUID != 0) { |
|
if (PlayerCharacter.getPlayerCharacter(this.guildLeaderUUID) == null) |
|
Logger.info("Guild UID " + this.getObjectUUID() + " Failed to Load Player Owner with ID " + this.guildLeaderUUID); |
|
} |
|
|
|
// If loading this guild for the first time write it's character record to disk |
|
|
|
if (ConfigManager.serverType.equals(ServerType.WORLDSERVER) |
|
&& (hash == null)) { |
|
|
|
this.setHash(); |
|
|
|
if (DataWarehouse.recordExists(Enum.DataRecordType.GUILD, this.getObjectUUID()) == false) { |
|
GuildRecord guildRecord = GuildRecord.borrow(this, Enum.RecordEventType.CREATE); |
|
DataWarehouse.pushToWarehouse(guildRecord); |
|
} |
|
|
|
} |
|
|
|
if (WorldServer.worldUUID == nationUUID && this.cityUUID != 0) |
|
this.nation = this; |
|
else if (nationUUID == 0 || (WorldServer.worldUUID == nationUUID && this.cityUUID == 0)) { |
|
this.nation = Guild.getErrantGuild(); |
|
this.nmotd = ""; |
|
} else |
|
this.nation = Guild.getGuild(nationUUID); |
|
|
|
if (this.nation == null) |
|
this.nation = Guild.getErrantGuild(); |
|
//Get guild states. |
|
try { |
|
this.subGuildList = DbManager.GuildQueries.GET_SUB_GUILDS(this.getObjectUUID()); |
|
} catch (Exception e) { |
|
|
|
this.subGuildList = new ArrayList<>(); |
|
Logger.error("FAILED TO LOAD SUB GUILDS FOR UUID " + this.getObjectUUID()); |
|
} |
|
|
|
if (this.nation == this && subGuildList.size() > 0) |
|
this.guildState = GuildState.Nation; |
|
else if (this.nation.equals(this)) |
|
this.guildState = GuildState.Sovereign; |
|
else if (!this.nation.isEmptyGuild() && this.cityUUID != 0) |
|
this.guildState = GuildState.Province; |
|
else if (!this.nation.isEmptyGuild()) |
|
this.guildState = GuildState.Sworn; |
|
else |
|
this.guildState = GuildState.Errant; |
|
|
|
if (this.cityUUID == 0) |
|
return; |
|
|
|
|
|
// Calculate number of realms this guild controls |
|
// Only do this on the game server to avoid loading a TOL/City/Zone needlessly |
|
|
|
if ((ConfigManager.serverType.equals(ServerType.WORLDSERVER)) && |
|
(this.isRealmRuler() == true)) { |
|
this.realmsOwned++; |
|
if (!this.nation.equals(this)) { |
|
this.nation.realmsOwned++; |
|
} |
|
} |
|
|
|
if (ConfigManager.serverType.equals(ServerType.WORLDSERVER)) { |
|
|
|
//add alliance list, clear all lists as there seems to be a bug where alliances are doubled, need to find where. |
|
//possible runAfterLoad being called twice?!?! |
|
this.banishList = dbGuildHandler.GET_GUILD_BANISHED(this.getObjectUUID()); |
|
this.characterKOSList = DbManager.GuildQueries.GET_GUILD_KOS_CHARACTER(this.getObjectUUID()); |
|
this.guildKOSList = DbManager.GuildQueries.GET_GUILD_KOS_GUILD(this.getObjectUUID()); |
|
|
|
this.allyList.clear(); |
|
this.enemyList.clear(); |
|
this.recommendList.clear(); |
|
|
|
try { |
|
DbManager.GuildQueries.LOAD_ALL_ALLIANCES_FOR_GUILD(this); |
|
for (GuildAlliances guildAlliance : this.guildAlliances.values()) { |
|
if (guildAlliance.isRecommended()) { |
|
Guild recommendedGuild = Guild.getGuild(guildAlliance.getAllianceGuild()); |
|
if (recommendedGuild != null) |
|
this.recommendList.add(recommendedGuild); |
|
} else if (guildAlliance.isAlly()) { |
|
Guild alliedGuild = Guild.getGuild(guildAlliance.getAllianceGuild()); |
|
if (alliedGuild != null) |
|
this.allyList.add(alliedGuild); |
|
} else { |
|
Guild enemyGuild = Guild.getGuild(guildAlliance.getAllianceGuild()); |
|
if (enemyGuild != null) |
|
this.enemyList.add(enemyGuild); |
|
} |
|
|
|
} |
|
} catch (Exception e) { |
|
Logger.error(this.getObjectUUID() + e.getMessage()); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* @return the motto |
|
*/ |
|
public String getMotto() { |
|
return motto; |
|
} |
|
|
|
public GuildState getGuildState() { |
|
return guildState; |
|
} |
|
|
|
public void setGuildState(GuildState guildState) { |
|
this.guildState = guildState; |
|
} |
|
|
|
/** |
|
* @return the realmsOwned |
|
*/ |
|
public int getRealmsOwned() { |
|
return realmsOwned; |
|
} |
|
|
|
/** |
|
* @param realmsOwned the realmsOwned to set |
|
*/ |
|
public void setRealmsOwned(int realmsOwned) { |
|
this.realmsOwned = realmsOwned; |
|
} |
|
|
|
public void removeSubGuild(Guild subGuild) { |
|
|
|
// Update database |
|
|
|
if (!DbManager.GuildQueries.UPDATE_PARENT(subGuild.getObjectUUID(), WorldServer.worldUUID)) |
|
Logger.debug("Failed to set Nation Guild for Guild with UID " + subGuild.getObjectUUID()); |
|
|
|
// Guild without any subs is no longer a nation |
|
|
|
if (subGuild.getOwnedCity() == null) { |
|
subGuild.nation = null; |
|
} else { |
|
subGuild.nation = subGuild; |
|
} |
|
|
|
// Downgrade guild |
|
|
|
subGuild.downgradeGuildState(); |
|
|
|
// Remove from collection |
|
|
|
subGuildList.remove(subGuild); |
|
|
|
GuildManager.updateAllGuildTags(subGuild); |
|
GuildManager.updateAllGuildBinds(subGuild, subGuild.getOwnedCity()); |
|
|
|
} |
|
|
|
public void setMineTime(int mineTime) { |
|
this.mineTime = mineTime; |
|
} |
|
|
|
public ConcurrentHashMap<Integer, Condemned> getGuildCondemned() { |
|
return guildCondemned; |
|
} |
|
|
|
|
|
public String getHash() { |
|
return hash; |
|
} |
|
|
|
public void setHash() { |
|
this.hash = DataWarehouse.hasher.encrypt(this.getObjectUUID()); |
|
|
|
DataWarehouse.writeHash(Enum.DataRecordType.GUILD, this.getObjectUUID()); |
|
} |
|
|
|
public Enum.GuildType getGuildType() { |
|
try { |
|
return Enum.GuildType.values()[this.charter]; |
|
} catch (Exception e) { |
|
Logger.error(e); |
|
return Enum.GuildType.NONE; |
|
} |
|
|
|
} |
|
|
|
public ArrayList<Guild> getRecommendList() { |
|
return recommendList; |
|
} |
|
|
|
public void setRecommendList(ArrayList<Guild> recommendList) { |
|
this.recommendList = recommendList; |
|
} |
|
|
|
public synchronized boolean addGuildToAlliance(AllianceChangeMsg msg, final AllianceType allianceType, Guild toGuild, PlayerCharacter player) { |
|
|
|
Dispatch dispatch; |
|
|
|
// Member variable assignment |
|
|
|
|
|
if (toGuild == null) |
|
return false; |
|
|
|
if (!Guild.sameGuild(player.getGuild(), this)) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_NOT_SAME_GUILD); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (allianceType == AllianceType.Ally || allianceType == AllianceType.Enemy) |
|
if (!GuildStatusController.isInnerCouncil(player.getGuildStatus()) && !GuildStatusController.isGuildLeader(player.getGuildStatus())) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_NOT_AUTHORIZED); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (allianceType == AllianceType.RecommendedAlly || allianceType == AllianceType.RecommendedEnemy) { |
|
if (!GuildStatusController.isFullMember(player.getGuildStatus())) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_NOT_AUTHORIZED); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
} |
|
|
|
// if (this.getGuildType() != toGuild.getGuildType()){ |
|
// msg.setMsgType(AllianceChangeMsg.ERROR_NOT_SAME_FACTION); |
|
// dispatch = Dispatch.borrow(player, msg); |
|
// DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
// return false; |
|
// } |
|
|
|
|
|
switch (allianceType) { |
|
case RecommendedAlly: |
|
if (recommendList.size() == 10) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_TOO_MANY); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (recommendList.contains(toGuild)) { |
|
ErrorPopupMsg.sendErrorMsg(player, "This guild is already recommonded!"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (!DbManager.GuildQueries.ADD_TO_ALLIANCE_LIST(this.getObjectUUID(), toGuild.getObjectUUID(), true, true, player.getFirstName())) { |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
return false; |
|
} |
|
|
|
GuildAlliances guildAlliance = new GuildAlliances(this.getObjectUUID(), toGuild.getObjectUUID(), true, true, player.getFirstName()); |
|
this.guildAlliances.put(toGuild.getObjectUUID(), guildAlliance); |
|
this.removeGuildFromEnemy(toGuild); |
|
this.removeGuildFromAlliance(toGuild); |
|
this.recommendList.add(toGuild); |
|
|
|
|
|
return true; |
|
|
|
case RecommendedEnemy: |
|
if (recommendList.size() == 10) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_TOO_MANY); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (recommendList.contains(toGuild)) { |
|
ErrorPopupMsg.sendErrorMsg(player, "This guild is already recommonded!"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (!DbManager.GuildQueries.ADD_TO_ALLIANCE_LIST(this.getObjectUUID(), toGuild.getObjectUUID(), true, false, player.getFirstName())) { |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
return false; |
|
} |
|
|
|
GuildAlliances enemyAlliance = new GuildAlliances(this.getObjectUUID(), toGuild.getObjectUUID(), true, false, player.getFirstName()); |
|
this.guildAlliances.put(toGuild.getObjectUUID(), enemyAlliance); |
|
this.removeGuildFromEnemy(toGuild); |
|
this.removeGuildFromAlliance(toGuild); |
|
this.recommendList.add(toGuild); |
|
|
|
return true; |
|
|
|
case Ally: |
|
if (allyList.size() == 10) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_TOO_MANY); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (allyList.contains(toGuild)) { |
|
ErrorPopupMsg.sendErrorMsg(player, "This guild is already an Ally!"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (!this.guildAlliances.containsKey(toGuild.getObjectUUID())) { |
|
ErrorPopupMsg.sendErrorMsg(player, "A Serious error has Occured. Please contact CCR!"); |
|
Logger.error(this.getObjectUUID() + " Could not find alliance Guild"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
GuildAlliances ally = this.guildAlliances.get(toGuild.getObjectUUID()); |
|
if (!ally.UpdateAlliance(AllianceType.Ally, this.recommendList.contains(toGuild))) { |
|
ErrorPopupMsg.sendErrorMsg(player, "A Serious error has Occured. Please contact CCR!"); |
|
Logger.error(this.getObjectUUID() + " failed to update alliance Database"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
|
|
} |
|
|
|
this.removeGuildFromEnemy(toGuild); |
|
this.removeGuildFromRecommended(toGuild); |
|
|
|
this.allyList.add(toGuild); |
|
Guild.UpdateClientAlliances(this); |
|
|
|
|
|
break; |
|
case Enemy: |
|
if (enemyList.size() == 10) { |
|
msg.setMsgType(AllianceChangeMsg.ERROR_TOO_MANY); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (enemyList.contains(toGuild)) { |
|
ErrorPopupMsg.sendErrorMsg(player, "This guild is already an Enemy!"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
if (!this.guildAlliances.containsKey(toGuild.getObjectUUID())) { |
|
ErrorPopupMsg.sendErrorMsg(player, "A Serious error has Occured. Please contact CCR!"); |
|
Logger.error(this.getObjectUUID() + " Could not find alliance Guild"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
} |
|
|
|
GuildAlliances enemy = this.guildAlliances.get(toGuild.getObjectUUID()); |
|
if (!enemy.UpdateAlliance(AllianceType.Enemy, this.recommendList.contains(toGuild))) { |
|
ErrorPopupMsg.sendErrorMsg(player, "A Serious error has Occured. Please contact CCR!"); |
|
Logger.error(this.getObjectUUID() + " failed to update alliance Database"); |
|
msg.setMsgType((byte) 15); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return false; |
|
|
|
} |
|
|
|
//remove from other allied lists. |
|
this.removeGuildFromAlliance(toGuild); |
|
this.removeGuildFromRecommended(toGuild); |
|
|
|
this.enemyList.add(toGuild); |
|
|
|
Guild.UpdateClientAlliances(this); |
|
break; |
|
} |
|
|
|
// once here everything passed, send successMsg; |
|
msg.setMsgType(AllianceChangeMsg.INFO_SUCCESS); |
|
dispatch = Dispatch.borrow(player, msg); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
return true; |
|
} |
|
|
|
public synchronized boolean removeGuildFromAlliance(Guild toRemove) { |
|
this.allyList.remove(toRemove); |
|
return true; |
|
} |
|
|
|
public synchronized boolean removeGuildFromEnemy(Guild toRemove) { |
|
this.enemyList.remove(toRemove); |
|
return true; |
|
} |
|
|
|
public synchronized boolean removeGuildFromRecommended(Guild toRemove) { |
|
this.recommendList.remove(toRemove); |
|
return true; |
|
} |
|
|
|
public synchronized boolean removeGuildFromAllAlliances(Guild toRemove) { |
|
|
|
if (!this.guildAlliances.containsKey(toRemove.getObjectUUID())) { |
|
return false; |
|
} |
|
|
|
if (!DbManager.GuildQueries.REMOVE_FROM_ALLIANCE_LIST(this.getObjectUUID(), toRemove.getObjectUUID())) |
|
return false; |
|
|
|
|
|
this.guildAlliances.remove(toRemove.getObjectUUID()); |
|
|
|
this.removeGuildFromAlliance(toRemove); |
|
this.removeGuildFromEnemy(toRemove); |
|
this.removeGuildFromRecommended(toRemove); |
|
|
|
Guild.UpdateClientAlliances(this); |
|
|
|
|
|
return true; |
|
|
|
} |
|
|
|
public static void UpdateClientAlliances(Guild toUpdate) { |
|
UpdateClientAlliancesMsg ucam = new UpdateClientAlliancesMsg(toUpdate); |
|
|
|
|
|
for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) { |
|
|
|
if (Guild.sameGuild(player.getGuild(), toUpdate)) { |
|
Dispatch dispatch = Dispatch.borrow(player, ucam); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
} |
|
|
|
|
|
} |
|
} |
|
|
|
public static void UpdateClientAlliancesForPlayer(PlayerCharacter toUpdate) { |
|
UpdateClientAlliancesMsg ucam = new UpdateClientAlliancesMsg(toUpdate.getGuild()); |
|
Dispatch dispatch = Dispatch.borrow(toUpdate, ucam); |
|
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY); |
|
|
|
|
|
} |
|
|
|
public static Guild getFromCache(int id) { |
|
return (Guild) DbManager.getFromCache(GameObjectType.Guild, id); |
|
} |
|
|
|
public static ArrayList<PlayerCharacter> GuildRoster(Guild guild) { |
|
ArrayList<PlayerCharacter> roster = new ArrayList<>(); |
|
if (guild == null) |
|
return roster; |
|
|
|
if (guild.isEmptyGuild()) |
|
return roster; |
|
|
|
if (DbManager.getList(GameObjectType.PlayerCharacter) == null) |
|
return roster; |
|
for (AbstractGameObject ago : DbManager.getList(GameObjectType.PlayerCharacter)) { |
|
PlayerCharacter toAdd = (PlayerCharacter) ago; |
|
|
|
if (!toAdd.getGuild().equals(guild)) |
|
continue; |
|
|
|
if (toAdd.isDeleted()) |
|
continue; |
|
|
|
roster.add(toAdd); |
|
|
|
} |
|
return roster; |
|
} |
|
|
|
|
|
}
|
|
|