public void refresh(Player player) {
if (player == playerA.getPlayer()) {
playerInfoHolder.updatePlayerComponent(playerA.getPlayer(), playerA.refreshComponentValue());
} else {
playerInfoHolder.updatePlayerComponent(playerB.getPlayer(), playerB.refreshComponentValue());
}
}
/** Load all informations from player who exists in folder players and who have a island. */
public void loadPlayerFiles() {
for (String f : new File(this.directoryPlayers.getAbsolutePath()).list()) {
if (new File(this.directoryPlayers, f).isFile()) {
PlayerInfo pi = null;
try {
pi = this.loadPlayerInfo(f.replace(".yml", ""));
} catch (Exception e) {
e.printStackTrace();
continue;
}
if (pi != null) {
// add player, if missing
String playerName = pi.getPlayerName();
Player playerOnline = this.getServer().getPlayer(playerName);
if (playerOnline == null) continue;
/*if (playerOnline == null || !playerOnline.isOnline() || pi.getIslandLocation() == null || !playerOnline.getWorld().getName().equalsIgnoreCase(settings.getWorldName())) {
continue;
}*/
settings.addPlayer(playerName, pi);
}
}
}
}
/**
* Comparing part of a player name with all players
*
* @param partName
* @return
*/
public String getFullPlayerName(PlayerInfo pi, String partName) {
int amount = 0;
String pName = "";
for (Player p : this.getServer().getOnlinePlayers()) {
if (p.getName().toLowerCase().startsWith(partName.toLowerCase())) {
amount++;
pName = p.getName();
}
}
if (amount == 1) return pName;
else if (amount > 1) return "0";
for (IslandInfo ii : pi.getBuiltPermissionList().values()) {
if (ii.getIslandOwner().toLowerCase().startsWith(partName.toLowerCase())) {
if (ii.containsFriend(pi.getPlayerName())) {
amount++;
pName = ii.getIslandOwner();
}
}
}
if (amount == 1) return pName;
else if (amount > 1) return "0";
return "-1";
}
/** @return The total number of dice (between all players) remaining in the game. */
public int getTotalDice() {
int totalDice = 0;
for (PlayerInfo p : playersInfo) {
totalDice += p.getNumDice();
}
return totalDice;
}
@Override
public List<PlayerInfo> getPlayersGames() {
List<PlayerInfo> result = new LinkedList<PlayerInfo>();
for (Player player : players) {
result.add(new PlayerInfo(player));
}
List<String> savedList = saver.getSavedList();
for (String name : savedList) {
boolean notFound = true;
for (PlayerInfo player : result) {
if (player.getName().equals(name)) {
player.setSaved(true);
notFound = false;
}
}
if (notFound) {
result.add(new PlayerInfo(name, true));
}
}
Collections.sort(
result,
new Comparator<PlayerInfo>() {
@Override
public int compare(PlayerInfo o1, PlayerInfo o2) {
return o1.getName().compareTo(o2.getName());
}
});
return result;
}
private static PlayerInfo parseFromString(int id, String playerString) throws FailedPlayer {
PlayerInfo playerInfo = new PlayerInfo();
String[] commaParts = playerString.split(", ");
if (commaParts.length != 2) {
throw new FailedPlayer(id, "Found player without exactly one comma.");
}
playerInfo.lastName = commaParts[0];
String remainingString = commaParts[1];
List<String> spaceParts = Lists.newArrayList(remainingString.split(" "));
int numParts = spaceParts.size();
if (numParts < 3) {
throw new FailedPlayer(
id,
"Found player with fewer than 3 symbols after the comma: '"
+ remainingString
+ "', Player "
+ playerString);
}
playerInfo.MLBTeam = Iterables.getLast(spaceParts);
spaceParts.remove(playerInfo.MLBTeam);
playerInfo.Position = Iterables.getLast(spaceParts);
spaceParts.remove(playerInfo.Position);
if (playerInfo.MLBTeam.length() < 2) {
throw new FailedPlayer(
id,
"Incorrect team name '"
+ playerInfo.MLBTeam
+ "', from remainder string '"
+ remainingString
+ "'");
}
if (playerInfo.Position.length() < 1) {
throw new FailedPlayer(
id,
"Incorrect position '"
+ playerInfo.Position
+ "', from remainder string '"
+ remainingString
+ "'");
}
if (spaceParts.size() < 1) {
throw new FailedPlayer(id, "Found no parts remaining in the first name piece.");
}
Joiner joiner = Joiner.on(" ");
playerInfo.firstName = joiner.join(spaceParts);
return playerInfo;
}
/**
* @return The ID of the winner of the game, or -1 if there is no winner (the game isn't over
* yet).
*/
public int getWinnerID() {
int winner = -1;
for (PlayerInfo p : playersInfo) {
if (p.getNumDice() > 0) {
if (winner != -1) return -1;
winner = p.getID();
}
}
return winner;
}
public void receivedPlayerUpdate(int lines, int points, int funds, PlayerInfo playerInfo)
throws NetworkException {
// Do not do anything if somehow we got called with ourself
if (!playerInfo.equals(this)) {
m_ac.playerUpdate(lines, points, funds, playerInfo);
}
}
// Update opponent on my changed stats
public void playerUpdate(int lines, int points, int funds, PlayerInfo playerInfo)
throws NetworkException {
// If PlayerInfo is not me, don't send- why would we update
// our opponent about herself?
if (playerInfo.getUsername() == this.m_info.getUsername()) {
// Only send here
// First param is ignored
m_netClient.playerUpdate(lines, points, funds, playerInfo);
}
}
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerJoin(final PlayerJoinEvent event) {
PlayerInfo pi = uSkyBlock.getInstance().readPlayerFile(event.getPlayer().getName());
if (pi == null) {
System.out.println(
"uSkyblock " + "Creating a new skyblock file for " + event.getPlayer().getName());
pi = new PlayerInfo(event.getPlayer().getName());
uSkyBlock.getInstance().writePlayerFile(event.getPlayer().getName(), pi);
}
if (pi.getHasParty() && pi.getPartyIslandLocation() == null) {
final PlayerInfo pi2 = uSkyBlock.getInstance().readPlayerFile(pi.getPartyLeader());
pi.setPartyIslandLocation(pi2.getIslandLocation());
uSkyBlock.getInstance().writePlayerFile(event.getPlayer().getName(), pi);
}
pi.buildChallengeList();
uSkyBlock.getInstance().addActivePlayer(event.getPlayer().getName(), pi);
System.out.println("uSkyblock " + "Loaded player file for " + event.getPlayer().getName());
}
@Override
public void onApplicationEvent(GravaEvent event) {
Player player = event.getPlayer();
if (event.getClass().equals(GravaEvent.OnMakingTurn.class)) {
Integer pitIndex = ((GravaEvent.OnMakingTurn) event).getPit();
if (player == playerA.getPlayer()) {
playerA.makeTurn(pitIndex);
} else {
playerB.makeTurn(pitIndex);
}
} else if (event.getClass().equals(GravaEvent.OnFinishTurn.class)) {
refresh(player);
playerInfoHolder.changeTurn(player, player.getOpposite());
Broadcaster.broadcast(new BroadcastEvent.OnFinishTurn(event.getPlayer()));
} else if (event.getClass().equals(GravaEvent.OnCapturingStone.class)) {
Integer targetPit = ((GravaEvent.OnCapturingStone) event).getIndex();
Integer pitIndex = Utils.getOpponentPitIndex(targetPit);
Integer stonesToGrab = 0;
if (player == playerA.getPlayer()) {
stonesToGrab = playerB.giveStones(pitIndex);
playerA.grabStones(stonesToGrab);
} else {
stonesToGrab = playerA.giveStones(pitIndex);
playerB.grabStones(stonesToGrab);
}
playerInfoHolder.updatePlayerComponent(playerA.getPlayer(), playerA.refreshComponentValue());
playerInfoHolder.updatePlayerComponent(playerB.getPlayer(), playerB.refreshComponentValue());
Broadcaster.broadcast(new BroadcastEvent.OnCapturing(player, stonesToGrab));
} else if (event.getClass().equals(GravaEvent.OnMakingOneMoreTurn.class)) {
refresh(player);
Broadcaster.broadcast(new BroadcastEvent.OnOneMoreTurn(player));
} else if (event.getClass().equals(GravaEvent.OnFinishingGame.class)) {
if (playerA.getStones() > playerB.getStones()) {
Broadcaster.broadcast(
new BroadcastEvent.OnFinishing(playerA.getPlayer(), playerA.getStones()));
} else if (playerB.getStones() > playerA.getStones()) {
Broadcaster.broadcast(
new BroadcastEvent.OnFinishing(playerB.getPlayer(), playerB.getStones()));
} else if (playerB.getStones() == playerA.getStones()) {
Broadcaster.broadcast(
new BroadcastEvent.OnFinishing(
player, playerB.getStones())); // wins the first who put all the stones to grava
}
}
}
public void savePlayerInfo(PlayerInfo pi) {
YamlConfiguration yamlPlayerInfo = new YamlConfiguration();
File filePlayerInfo = new File(this.directoryPlayers, pi.getPlayerName() + ".yml");
// island info
if (pi.getIslandInfo() != null) {
yamlPlayerInfo.set(
EnumPlayerConfig.ISLAND_NUMBER.getPath(), pi.getIslandInfo().getIslandNumber());
}
yamlPlayerInfo.set(EnumPlayerConfig.IS_PLAYING.getPath(), pi.isPlaying());
yamlPlayerInfo.set(EnumPlayerConfig.IS_DEAD.getPath(), pi.isDead());
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_FOOD.getPath(), "" + pi.getIslandFood());
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_HEALTH.getPath(), "" + pi.getIslandHealth());
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_EXP.getPath(), "" + pi.getIslandExp());
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_LEVEL.getPath(), "" + pi.getIslandLevel());
yamlPlayerInfo.set(
EnumPlayerConfig.ISLAND_INVENTORY.getPath(),
ItemParser.getListFromItemStackArray(pi.getIslandInventory()));
yamlPlayerInfo.set(
EnumPlayerConfig.ISLAND_ARMOR.getPath(),
ItemParser.getListFromItemStackArray(pi.getIslandArmor()));
yamlPlayerInfo.set(
EnumPlayerConfig.OLD_LOCATION.getPath(),
LocationParser.getStringFromLocation(pi.getOldLocation()));
yamlPlayerInfo.set(EnumPlayerConfig.OLD_FOOD.getPath(), "" + pi.getOldFood());
yamlPlayerInfo.set(EnumPlayerConfig.OLD_HEALTH.getPath(), "" + pi.getOldHealth());
yamlPlayerInfo.set(EnumPlayerConfig.OLD_EXP.getPath(), "" + pi.getOldExp());
yamlPlayerInfo.set(EnumPlayerConfig.OLD_LEVEL.getPath(), "" + pi.getOldLevel());
yamlPlayerInfo.set(
EnumPlayerConfig.OLD_INVENTORY.getPath(),
ItemParser.getListFromItemStackArray(pi.getOldInventory()));
yamlPlayerInfo.set(
EnumPlayerConfig.OLD_ARMOR.getPath(),
ItemParser.getListFromItemStackArray(pi.getOldArmor()));
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_BUILTLIST.getPath(), pi.getBuildListNumbers());
try {
yamlPlayerInfo.save(filePlayerInfo);
} catch (IOException e) {
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
public PlayerInfo loadPlayerInfo(String playerName) {
YamlConfiguration yamlPlayerInfo = new YamlConfiguration();
File filePlayerInfo = new File(this.directoryPlayers, playerName + ".yml");
if (!filePlayerInfo.exists()) {
return null;
}
try {
yamlPlayerInfo.load(filePlayerInfo);
} catch (Exception e) {
e.printStackTrace();
return null;
}
PlayerInfo pi = new PlayerInfo(playerName);
// Find own Island
int ownsIslandNr = -1;
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_NUMBER.getPath())) {
ownsIslandNr = yamlPlayerInfo.getInt(EnumPlayerConfig.ISLAND_NUMBER.getPath());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_NUMBER.getPath(), ownsIslandNr);
}
pi.setIslandInfo(settings.getIslandInfo(ownsIslandNr));
// Check consistency
if (pi.getHasIsland() && !pi.getIslandInfo().isIslandOwner(playerName)) {
pi.setIslandInfo(null);
}
// Find Buildpermissions
// buildPermissions = new HashMap<Integer, IslandInfo>();
ArrayList<Integer> builtlist = new ArrayList<Integer>();
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_BUILTLIST.getPath())) {
builtlist =
(ArrayList<Integer>) yamlPlayerInfo.getList(EnumPlayerConfig.ISLAND_BUILTLIST.getPath());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_BUILTLIST.getPath(), builtlist);
}
// Go through buildlist with Islandnr to get IslandInfos
for (int islandnr : builtlist) {
IslandInfo friend = settings.getIslandInfo(islandnr);
if (friend != null && friend.containsFriend(playerName)) {
pi.addBuildPermission(islandnr, friend);
}
}
boolean isPlaying = false;
if (yamlPlayerInfo.contains(EnumPlayerConfig.IS_PLAYING.getPath())) {
isPlaying =
Boolean.parseBoolean(
yamlPlayerInfo.get(EnumPlayerConfig.IS_PLAYING.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.IS_PLAYING.getPath(), false);
}
pi.setIsPlaying(isPlaying);
boolean isDead = false;
if (yamlPlayerInfo.contains(EnumPlayerConfig.IS_DEAD.getPath())) {
isDead =
Boolean.parseBoolean(yamlPlayerInfo.get(EnumPlayerConfig.IS_DEAD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.IS_DEAD.getPath(), false);
}
pi.setDead(isDead);
int islandFood = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_FOOD.getPath())) {
islandFood =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_FOOD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_FOOD.getPath(), 20);
}
} catch (Exception e) {
}
pi.setIslandFood(islandFood);
int islandHealth = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_HEALTH.getPath())) {
islandHealth =
Integer.parseInt(
yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_HEALTH.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_HEALTH.getPath(), 20);
}
} catch (Exception e) {
}
pi.setIslandHealth(islandHealth);
int islandExp = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_EXP.getPath())) {
islandExp =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_EXP.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_EXP.getPath(), 0);
}
} catch (Exception e) {
}
pi.setIslandExp(islandExp);
int islandLevel = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_LEVEL.getPath())) {
islandLevel =
Integer.parseInt(
yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_LEVEL.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_LEVEL.getPath(), 0);
}
} catch (Exception e) {
}
pi.setIslandLevel(islandLevel);
ItemStack[] islandInventory = new ItemStack[36];
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_INVENTORY.getPath())) {
ArrayList<String> listIslandInventory =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_INVENTORY.getPath());
islandInventory = ItemParser.getItemStackArrayFromList(listIslandInventory, 36);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_INVENTORY.getPath(), new ArrayList<String>());
}
pi.setIslandInventory(islandInventory);
ItemStack[] islandArmor = new ItemStack[4];
if (yamlPlayerInfo.contains(EnumPlayerConfig.ISLAND_ARMOR.getPath())) {
ArrayList<String> listIslandArmor =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.ISLAND_ARMOR.getPath());
islandArmor = ItemParser.getItemStackArrayFromList(listIslandArmor, 4);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.ISLAND_ARMOR.getPath(), new ArrayList<String>());
}
pi.setIslandArmor(islandArmor);
Location oldLocation = null;
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_LOCATION.getPath())) {
oldLocation =
LocationParser.parseStringToLocation(
yamlPlayerInfo.get(EnumPlayerConfig.OLD_LOCATION.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_LOCATION.getPath(), "");
}
pi.setOldLocation(oldLocation);
int oldFood = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_FOOD.getPath())) {
oldFood =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_FOOD.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_FOOD.getPath(), 20);
}
} catch (Exception e) {
}
pi.setOldFood(oldFood);
int oldHealth = 20;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_HEALTH.getPath())) {
oldHealth =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_HEALTH.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_HEALTH.getPath(), 20);
}
} catch (Exception e) {
}
pi.setOldHealth(oldHealth);
int oldExp = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_EXP.getPath())) {
oldExp =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_EXP.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_EXP.getPath(), 0);
}
} catch (Exception e) {
}
pi.setOldExp(oldExp);
int oldLevel = 0;
try {
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_LEVEL.getPath())) {
oldLevel =
Integer.parseInt(yamlPlayerInfo.get(EnumPlayerConfig.OLD_LEVEL.getPath()).toString());
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_LEVEL.getPath(), 0);
}
} catch (Exception e) {
}
pi.setOldLevel(oldLevel);
ItemStack[] oldInventory = new ItemStack[36];
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_INVENTORY.getPath())) {
ArrayList<String> listOldInventory =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.OLD_INVENTORY.getPath());
oldInventory = ItemParser.getItemStackArrayFromList(listOldInventory, 36);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_INVENTORY.getPath(), new ArrayList<String>());
}
pi.setOldInventory(oldInventory);
ItemStack[] oldArmor = new ItemStack[4];
if (yamlPlayerInfo.contains(EnumPlayerConfig.OLD_ARMOR.getPath())) {
ArrayList<String> listOldArmor =
(ArrayList<String>) yamlPlayerInfo.get(EnumPlayerConfig.OLD_ARMOR.getPath());
oldArmor = ItemParser.getItemStackArrayFromList(listOldArmor, 4);
} else {
yamlPlayerInfo.set(EnumPlayerConfig.OLD_ARMOR.getPath(), new ArrayList<String>());
}
pi.setOldArmor(oldArmor);
try {
yamlPlayerInfo.save(filePlayerInfo);
} catch (IOException e) {
e.printStackTrace();
return null;
}
return pi;
}
public void changeToIslandInventory(PlayerInfo pi) {
if (pi.isPlaying()) return;
if (this.settings.getAllowContent()) {
pi.setIsPlaying(true);
return;
}
// save old inventory
pi.setOldInventory(pi.getPlayer().getInventory().getContents());
pi.setOldArmor(pi.getPlayer().getInventory().getArmorContents());
pi.setOldHealth(pi.getPlayer().getHealth());
pi.setOldFood(pi.getPlayer().getFoodLevel());
pi.setOldLevel(pi.getPlayer().getLevel());
pi.setOldExp(pi.getPlayer().getExp());
// set island inventory
pi.getPlayer().getInventory().setContents(pi.getIslandInventory());
pi.getPlayer().getInventory().setArmorContents(pi.getIslandArmor());
if (pi.getIslandHealth() <= 0) {
pi.getPlayer().setHealth(pi.getPlayer().getMaxHealth());
} else {
pi.getPlayer().setHealth(pi.getIslandHealth());
}
if (pi.getIslandFood() <= 0) {
pi.getPlayer().setFoodLevel(20);
} else {
pi.getPlayer().setHealth(pi.getIslandFood());
}
pi.getPlayer().setLevel(pi.getIslandLevel());
pi.getPlayer().setExp(pi.getIslandExp());
pi.setIsPlaying(true);
}
