[Tut] How to make super awesome player wrapper

Hey guys! I have noticed a growing need to add cool methods to player without having to write code to implement the player interface and the implicit issue of making sure the JVM realizes all those players are players on the server aswell. The player wrapper is a super awesome tool that when done right works amazingly.

A wrapper is an object that takes a type or object and then adds things to it. For example:

Code:java

class MyWrapper {
  private Player wrappedPlayer;
}

We need this player object so we know what player we are referring to later on down the road.

Let's add some functionality to this player. We are going to create a method say hi, we are going to keep the class above.

Code:java

//class and field declaration
public void myNewFunction() {
  player.say("hi");
  player.sendMessage("Haha! you have no choice but to say hi!!");
}

This is a very simple wrapper that adds a function that forces the player to say hi. You can do a lot more with this. You can add attributes to players like so:

Adding Attributes (open) Adding Attributes (close)

Code:java

//class and field declaration
private long timePlayed;
public long getTimePlayed() {
  return this.timePlayed;
}
//we are going to assume we are passing in a stored value from System.getCurrentMillis()
public long addTimePlayed(long loginTime, long logoutTime) {
this.timePlayed += (logoutTime - loginTime);
return timePlayed;
}

If you read you could tell we gave our player a time played attribute. If you wanted to get fancier you could also do custom quests and what not.

The last thing we need to do is allow the player to get garbage collected. We are going to do this by setting the player to null. (Thanks to Cirno for bringing this to my attention)

Final Class (open) Final Class (close)

Code:java

package me.beastman3226.example;
 
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.server.PluginEnableEvent;
 
public class WrappedPlayer {
 
private Player player;
private String playerName;
public static WrappedPlayer[] players;
public static Main plugin;
 
public Player getPlayer() {
return player;
}
 
public void setPlayer(Player player) {
this.player = player;
}
 
public WrappedPlayer(Player p) {
this.player = p;
players[findOpen()] = this;
}
 
public String getPlayerName() {
return playerName;
}
 
public void setPlayerName() {
this.playerName = this.getPlayer().getName();
}
 
private int findOpen() {
int i = 0;
while(players.length > i) {
if(players[i] == null) {
return i;
} else {
i++;
continue;
}
}
return 0;
}
 
public static class PlayerListener implements Listener {
@EventHandler
public void onJoin(PlayerJoinEvent e) {
if(!WrappedPlayer.contains(e.getPlayer())) new WrappedPlayer(e.getPlayer());
}
@EventHandler
public void onLeave(PlayerQuitEvent e) {
WrappedPlayer.getPlayer(e.getPlayer()).setPlayer(null);
}
@EventHandler
public void onStart(PluginEnableEvent e) {
if(e.getPlugin() == plugin) {
players = new WrappedPlayer[plugin.getMax()];
}
}
}
 
public static boolean contains(Player player) {
for(WrappedPlayer pw : players) {
if(pw.getPlayer() == player) {
return true;
}
}
return false;
}
 
public static WrappedPlayer getPlayer(Player player2) {
for(WrappedPlayer player : players) {
if(player.getPlayer() == player2) {
return player;
} else {
continue;
}
}
return null;
}
 
 
}[/i]

In summary, we refer to a player object so that we can still change things from the wrapper. We can add attributes by adding the field and adding the necessary functions. Please feel free to suggest things and ask questions.

 

It would be wise to make wrappedPlayer nonfinal and upon PlayerQuit, set wrappedPlayer to null to allow the JVM to GC wrappedPlayer.

 

Cirno
Thank you. I forgot to mention that.

 

Should improve getPlayer() function, consumes too much memory.

 

I have a full player wrapper that doesn't implement player lying around here somewhere.. give me a sec to find it.

 

SacredWaste
I was thinking about changing the get player from the actual player to a name. That way I wouldn't have to worry about the listeners. How does returning the stored value take up too much memory?

 

This isn't a very efficient way to create a player wrapper :/
You're storing the actual player object which can & will lead to issues; I suggest storing the players name; Have a method to get the name, along with a .getPlayer() method that calls Bukkit.getPlayer with the instanced name.

Great starting point though, I will say that!

Here's an example of a wrapper I wrote (for a minigame, still the same concept though):

Code:java

package TDMGame.Handlers.Fakeboard;
 
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
 
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
 
import TDMGame.TDMGame;
import TDMGame.TDMGame.LoadoutSlot;
import TDMGame.Handlers.FileHandlers.DataHandler;
import TDMGame.Handlers.Gunhandlers.GunWrap;
import TDMGame.Handlers.Loadout.Loadout;
import TDMGame.Handlers.Perks.*;
import TDMGame.Handlers.Perks.Perks.Nothing;
import TDMGame.Handlers.Scoreboard.PlayerScoreboard;
 
public class fPlayer
{
    private String Name = "";
    private String TeamName = "";
 
    private int Score = 0;
    private int TeamKills = 0;
    private int KillStreak = 0;
    private int Deaths = 0;
 
    private String PrimaryGunID = "AK-47";
    private String SecondaryGunID = "USP45";
 
    private PlayerScoreboard Scoreboard;
 
    private Perk Perk;
 
    private boolean IsAfk = false;
 
    private List<Perk> Perks = new ArrayList<Perk>();
 
    private int SelectedLoadout = 1;
 
    //private List<LoadoutConfig> Loadouts = new ArrayList<LoadoutConfig>();
    private HashMap<Integer, Loadout> Loadouts = new HashMap<Integer, Loadout>();
 
    private List<String> UnlockedGuns = new ArrayList<String>();
 
    private List<ItemStack> DeathRestoration = new ArrayList<ItemStack>();
    private ItemStack[] DeathInventory = new ItemStack[] { };
 
    /**
    * Initiates a new fPlayer Instance
    * @param Player Players Name
    */
    public fPlayer(String Player)
    {
        this.Name = Player;
        this.Perk = new Nothing();
        Defaults();
        Setup();
    }
 
    /**
    * Initiates a new fPlayer Instance
    * @param Player Player to make new fPlayer of
    */
    public fPlayer(Player Player)
    {
        this.Name = Player.getName();
        this.Perk = new Nothing();
        Defaults();
        Setup();
    }
 
    public void Defaults()
    {
        if (TDMGame.LoadoutSQL.getLoadouts(this.Name).size() <= 0 || TDMGame.LoadoutSQL.getLoadouts(this.Name).size() < this.getLoadoutLimit())
        {
            for(int I = 0; I < this.getLoadoutLimit(); I++)
            {
                TDMGame.LoadoutSQL.InsertLoadout(this.Name, (I + 1), this.PrimaryGunID, this.SecondaryGunID, this.Perk.getName());
            }
        }
 
        if (TDMGame.GunsSQL.getGuns(this.Name).size() < TDMGame.GunHandler.getDefaultGuns().size())
        {
            for(GunWrap Gun : TDMGame.GunHandler.getDefaultGuns())
            {
                TDMGame.GunsSQL.InsertGun(this.Name, Gun.getName());
            }
        }
 
        if (TDMGame.PerkSQL.getPerks(this.Name).size() <= 0)
        {
            TDMGame.PerkSQL.InsertPerk(new Nothing(), this.Name);
        }
    }
 
    public void Setup()
    {
        for(Loadout Loadout : TDMGame.LoadoutSQL.getLoadouts(this.Name))
        {
            this.Loadouts.put(Loadout.getNumber(), Loadout);
        }
 
        for(Perk Perk : TDMGame.PerkSQL.getPerks(this.Name))
        {
            this.Perks.add(Perk);
        }
 
        for(String Gun : TDMGame.GunsSQL.getGuns(this.Name))
        {
            this.UnlockedGuns.add(Gun);
        }
        this.Scoreboard = new PlayerScoreboard();
        if (Bukkit.getPlayer(this.Name) != null)
        {
            Bukkit.getPlayer(this.Name).setScoreboard(this.getScoreboard().getScoreboard());
        }
    }
 
 
    public PlayerScoreboard getScoreboard()
    {
        return this.Scoreboard;
    }
 
    public void UpdateScoreboard()
    {
        this.Scoreboard.UpdateData(this);
    }
 
    public void ClearScoreboard()
    {
        this.Scoreboard.ClearBoard();
    }
 
    public List<String> getUnlockedGuns()
    {
        return this.UnlockedGuns;
    }
 
    public boolean hasGun(String ID)
    {
        return this.UnlockedGuns.contains(ID);
    }
 
    public boolean hasGun(GunWrap Gun)
    {
        return this.UnlockedGuns.contains(Gun.getName());
    }
 
    public void UnlockGun(String ID)
    {
        if (!this.UnlockedGuns.contains(ID))
        {
            this.UnlockedGuns.add(ID);
            TDMGame.GunsSQL.InsertGun(this.Name, ID);
            TDMGame.Console("Unlocked gun [" + ID + "] in SQL for " + this.Name);
        }
    }
 
 
    public int getLoadoutLimit()
    {
        if (this.getPlayer().isWhitelisted())
        {
            return 9;
        }
        else
        {
            return 3;
        }
    }
 
    public List<Perk> getPerks()
    {
        return this.Perks;
    }
 
    public boolean hasPerk(Perk Perk)
    {
        return this.Perks.contains(Perk);
    }
 
    public void addPerk(Perk Perk)
    {
        if (!this.Perks.contains(Perk))
        {
            this.Perks.add(Perk);
            TDMGame.PerkSQL.InsertPerk(Perk, this.Name);
            TDMGame.Console("Unlocked Perk [" + Perk.getName() + "] in SQL for " + this.Name);
        }
    }
 
    /**
    * Gets the fPlayers Name
    * @return
    */
    public String getName()
    {
        return this.Name;
    }
 
    /**
    * Set the name of the fPlayer
    * @param Name
    */
    public void setName(String Name)
    {
        this.Name = Name;
    }
 
    /**
    * Gets the Player for the fPlayer in this instance; Uses Bukkit.getPlayer
    * @return
    */
    public Player getPlayer()
    {
        if (Bukkit.getPlayer(this.Name) != null)
        {
            return Bukkit.getPlayer(this.Name);
        }
        return null;
    }
 
    /**
    * Gets this fPlayers Score
    * @return
    */
    public int getScore()
    {
        return this.Score;
    }
 
    /**
    * Sets the score for this fPlayer
    * @param Score
    */
    public void setScore(int Score)
    {
        this.Score = Score;
    }
 
    /**
    * Add more to the fPlayers Score
    * @param Amount
    */
    public void addScore(int Amount)
    {
        this.Score += Amount;
    }
 
    /**
    * Set the team this fPlayer is on
    * @param Name
    */
    public void setTeam(String Name)
    {
        this.TeamName = Name;
    }
 
    /**
    * Gets the name of the team this fPlayer is on
    * @return
    */
    public String getTeam()
    {
        return this.TeamName;
    }
 
    /**
    * Gets how many Team-Kills this fPlayer has
    * @return
    */
    public int getTeamKills()
    {
        return this.TeamKills;
    }
 
    /**
    * Adds to the Team-Kills this player has
    * @param Amount
    */
    public void addTeamKills(int Amount)
    {
        this.TeamKills += Amount;
    }
 
    /**
    * Gets how many kills this fPlayer has on their current Killstreak
    * @return
    */
    public int getKillStreak()
    {
        return this.KillStreak;
    }
 
    /**
    * Sets the players Killstreak to 0
    */
    public void ResetKillstreak()
    {
        this.KillStreak = 0;
    }
 
    /**
    * Adds the Amount to this players Killstreak
    * @param Amount
    */
    public void AddKillStreak(int Amount)
    {
        this.KillStreak += Amount;
    }
 
    /**
    * Gets this players Chosen gun
    * @return
    */
    public String getPrimaryGunID()
    {
        return this.PrimaryGunID;
    }
 
    /**
    * Returns the secondary gun in the players selected loadout
    * @return
    */
    public String getSecondaryGunID()
    {
        return this.SecondaryGunID;
    }
 
    public String getPrimaryGunID(int Loadout)
    {
        return this.getLoadout(Loadout).getPrimary();
    }
 
    public String getSecondaryGunID(int Loadout)
    {
        return this.getLoadout(Loadout).getSecondary();
    }
 
    public Perk getPerk(int Loadout)
    {
        return this.getLoadout(Loadout).getPerk();
    }
 
    public void setActiveLoadout(int LoadoutNumber)
    {
        if (this.getLoadout(LoadoutNumber) != null)
        {
            this.SelectedLoadout = LoadoutNumber;
            this.PrimaryGunID = this.getLoadout(LoadoutNumber).getPrimary();
            this.SecondaryGunID = this.getLoadout(LoadoutNumber).getSecondary();
            this.Perk = this.getLoadout(LoadoutNumber).getPerk();
        }
    }
 
    /**
    * Gets this players inventory to restore after death
    * @return
    */
    public List<ItemStack> getDeathInventoryAsList()
    {
        return this.DeathRestoration;
    }
 
    /**
    * Gets this players inventory to restore after death in an ItemStack[]
    * @return
    */
    public ItemStack[] getDeathInventory()
    {
        return this.DeathInventory;
    }
 
    /**
    * Sets the items that this player will get after death
    * @param ItemsDiedWith
    */
    public void setDeathInventory(List<ItemStack> ItemsDiedWith)
    {
        this.DeathRestoration = ItemsDiedWith;
    }
 
    /**
    * Sets the items that this player will get after death
    * @param ItemsDiedWith
    */
    public void setDeathInventory(ItemStack[] ItemsDiedWith)
    {
        this.DeathRestoration = Arrays.asList(ItemsDiedWith);
        this.DeathInventory = ItemsDiedWith;
    }
 
    /**
    * Clears the inventory data for this player
    */
    public void clearDeathInventory()
    {
        this.DeathRestoration.clear();
        this.DeathInventory = new ItemStack[] { };
    }
 
    public Loadout getLoadout(int Number)
    {
        if (this.Loadouts.containsKey(Number))
        {
            return this.Loadouts.get(Number);
        }
        else
        {
            return null;
        }
    }
 
    public void setAfk(boolean IsAFK)
    {
        if (IsAFK == true)
        {
            this.getPlayer().addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY,(20 * 60) * 10, 1));
        }
        else
        {
            this.getPlayer().removePotionEffect(PotionEffectType.INVISIBILITY);
        }
        this.IsAfk = IsAFK;
        this.getPlayer().sendMessage(ChatColor.GRAY + "You are" + (this.isAfk() ? " now afk" : " no longer afk"));
    }
 
    public boolean isAfk()
    {
        return this.IsAfk;
    }
 
    public Perk getPerk()
    {
        return this.Perk;
    }
 
    public int getDeaths()
    {
        return this.Deaths;
    }
 
    public void ResetDeaths()
    {
        this.Deaths = 0;
    }
 
    public void AddDeath()
    {
        this.Deaths += 1;
    }
 
}
 

I know that the formatting isn't lowerCamelCasing, but the concept of the wrapper is still there: It holds wraps data for the player.

 

I know, I started making an example project on Github and will post later once I am finished.

 

Using Player like that in a wrapper has many bugs, the main one being a memory leak.

 

SacredWaste
I understand. You could use Player, cast to OnlinePlayer when online and cast to OfflinePlayer when he quits. Or I can store the name. Either way it goes I am editing the topic and creating an example project.

 

The best way to prevent the memory leaks is to store String's instead, and use a getPlayer() method to retrieve the actual Player class by using the Bukkit.getPlayer() function.

 

SacredWaste
Again, I completely agree and I understand why it is a bad practice. It is why I made this: https://github.com/beastman3226/PlayerWrapper-Example/tree/master

 

getPlayer is slow, use getPlayerExact. There is absolutely nothing wrong with storing a reference to the player object as long as you remove it when the player leaves the server. Even if you don't use the player object, if you still don't remove this wrapper when the player leaves, you'll still have a memory leak regardless.