5dd897aaa9
Using spigot 1.8.8, utils.players() always returns empty due to usage of deprecated calls. This fixes it on my machine, but not tested on other 'bukkit' servers.
744 lines
22 KiB
JavaScript
744 lines
22 KiB
JavaScript
/*global require, __plugin, org, exports, server, setTimeout, Packages, setInterval, addUnloadHandler, clearInterval, events*/
|
|
'use strict';
|
|
var File = java.io.File;
|
|
|
|
if (__plugin.bukkit){
|
|
var bkBukkit = org.bukkit.Bukkit,
|
|
bkLocation = org.bukkit.Location,
|
|
bkBlockCommandSender = org.bukkit.command.BlockCommandSender;
|
|
}
|
|
if (__plugin.canary){
|
|
var Canary = Packages.net.canarymod.Canary;
|
|
}
|
|
/************************************************************************
|
|
## Utilities Module
|
|
|
|
The `utils` module is a storehouse for various useful utility
|
|
functions which can be used by plugin and module authors. It contains
|
|
miscellaneous utility functions and classes to help with programming.
|
|
|
|
### utils.player() function
|
|
|
|
The utils.player() function will return a [Player][cmpl] object
|
|
with the given name. This function takes a single parameter
|
|
`playerName` which can be either a String or a [Player][cmpl] object -
|
|
if it's a Player object, then the same object is returned. If it's a
|
|
String, then it tries to find the player with that name.
|
|
|
|
#### Parameters
|
|
|
|
* playerName : A String or Player object. If no parameter is provided
|
|
then player() will try to return the `self` variable . It is
|
|
strongly recommended to provide a parameter.
|
|
|
|
#### Example
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
var name = 'walterh';
|
|
var player = utils.player(name);
|
|
if ( player ) {
|
|
echo(player, 'Got ' + name);
|
|
} else {
|
|
console.log('No player named ' + name);
|
|
}
|
|
```
|
|
|
|
[bkpl]: http://jd.bukkit.org/dev/apidocs/org/bukkit/entity/Player.html
|
|
[cmpl]: https://ci.visualillusionsent.net/job/CanaryLib/javadoc/net/canarymod/api/entity/living/humanoid/Player.html
|
|
[cmloc]: https://ci.visualillusionsent.net/job/CanaryLib/javadoc/net/canarymod/api/world/position/Location.html
|
|
[bkloc]: http://jd.bukkit.org/dev/apidocs/org/bukkit/Location.html
|
|
|
|
***/
|
|
function _player( playerName ) {
|
|
if ( typeof playerName == 'undefined' ) {
|
|
if ( typeof self == 'undefined' ) {
|
|
return null;
|
|
} else {
|
|
return self;
|
|
}
|
|
} else {
|
|
if ( typeof playerName == 'string' )
|
|
if (__plugin.canary) {
|
|
return Canary.server.getPlayer( playerName );
|
|
} else {
|
|
return bkBukkit.getPlayer( playerName );
|
|
}
|
|
else
|
|
return playerName; // assumes it's a player object
|
|
}
|
|
};
|
|
/*************************************************************************
|
|
### utils.world( worldName ) function
|
|
|
|
Returns a World object matching the given name
|
|
|
|
***/
|
|
function _world( worldName ){
|
|
if (__plugin.canary){
|
|
if (worldName instanceof Packages.net.canarymod.api.world.World){
|
|
return worldName;
|
|
}
|
|
var worldMgr = Canary.server.worldManager;
|
|
try {
|
|
if (worldName === undefined){
|
|
var worldNames = worldMgr.getLoadedWorldsNames();
|
|
worldName = worldNames[0];
|
|
}
|
|
return worldMgr.getWorld( worldName, true );
|
|
} catch (error) {
|
|
console.error( 'utils.world() failed to load ' + worldName + ',Error:' + error );
|
|
}
|
|
}
|
|
if (__plugin.bukkit){
|
|
if (worldName instanceof org.bukkit.World){
|
|
return worldName;
|
|
}
|
|
if (worldName === undefined){
|
|
return bkBukkit.getWorlds().get(0);
|
|
}
|
|
return bkBukkit.getWorld( worldName );
|
|
}
|
|
return null;
|
|
}
|
|
exports.world = _world;
|
|
|
|
/*************************************************************************
|
|
### utils.blockAt( Location ) function
|
|
|
|
Returns the Block at the given location.
|
|
|
|
***/
|
|
function _blockAt( location ){
|
|
if (__plugin.canary){
|
|
return location.world.getBlockAt(location);
|
|
}
|
|
if (__plugin.bukkit){
|
|
return location.block;
|
|
}
|
|
return null;
|
|
}
|
|
exports.blockAt = _blockAt;
|
|
/*************************************************************************
|
|
### utils.locationToJSON() function
|
|
|
|
utils.locationToJSON() returns a [Location][cmloc] object in JSON form...
|
|
|
|
{ world: 'world5',
|
|
x: 56.9324,
|
|
y: 103.9954,
|
|
z: 43.1323,
|
|
yaw: 0.0,
|
|
pitch: 0.0
|
|
}
|
|
|
|
This can be useful if you write a plugin that needs to store location data since bukkit's Location object is a Java object which cannot be serialized to JSON by default.
|
|
|
|
#### Parameters
|
|
|
|
* location: An object of type [Location][cmloc]
|
|
|
|
#### Returns
|
|
|
|
A JSON object in the above form.
|
|
|
|
***/
|
|
function _locationToJSON( location ) {
|
|
var yaw = __plugin.bukkit ? location.yaw : (__plugin.canary ? location.rotation : 0);
|
|
return {
|
|
world: ''+location.world.name,
|
|
x: location.x,
|
|
y: location.y,
|
|
z: location.z,
|
|
yaw: yaw,
|
|
pitch: location.pitch
|
|
};
|
|
};
|
|
/*************************************************************************
|
|
### utils.locationToString() function
|
|
|
|
The utils.locationToString() function returns a
|
|
[Location][cmloc] object in string form...
|
|
|
|
'{"world":"world5",x:56.9324,y:103.9954,z:43.1323,yaw:0.0,pitch:0.0}'
|
|
|
|
... which can be useful if you write a plugin which uses Locations as
|
|
keys in a lookup table.
|
|
|
|
#### Example
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
...
|
|
var key = utils.locationToString(player.location);
|
|
lookupTable[key] = player.name;
|
|
```
|
|
|
|
***/
|
|
exports.locationToString = function locationToString( location ) {
|
|
return JSON.stringify( _locationToJSON( location ) );
|
|
};
|
|
exports.locationToJSON = _locationToJSON;
|
|
|
|
/*************************************************************************
|
|
### utils.locationFromJSON() function
|
|
|
|
This function reconstructs an [Location][cmloc] object from
|
|
a JSON representation. This is the counterpart to the
|
|
`locationToJSON()` function. It takes a JSON object of the form
|
|
returned by locationToJSON() and reconstructs and returns a bukkit
|
|
Location object.
|
|
|
|
***/
|
|
exports.locationFromJSON = function locationFromJSON( json ) {
|
|
var world;
|
|
if ( json.constructor == Array ) {
|
|
// for support of legacy format
|
|
world = _world( json[0] );
|
|
return new bkLocation( world, json[1], json[2] , json[3] );
|
|
} else {
|
|
if (__plugin.canary){
|
|
world = _world( json.world );
|
|
var cmLocation = Packages.net.canarymod.api.world.position.Location;
|
|
return new cmLocation(world, json.x, json.y, json.z, json.pitch?json.pitch:0, json.yaw?json.yaw:0);
|
|
} else {
|
|
world = _world( json.world );
|
|
return new bkLocation( world, json.x, json.y , json.z, json.yaw?json.yaw:0, json.pitch?json.pitch:0 );
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.player = _player;
|
|
|
|
exports.getPlayerObject = function getPlayerObject( player ) {
|
|
console.warn( 'utils.getPlayerObject() is deprecated. Use utils.player() instead.' );
|
|
return _player(player);
|
|
};
|
|
/*************************************************************************
|
|
### utils.getPlayerPos() function
|
|
|
|
This function returns the player's [Location][cmloc] (x, y, z, pitch
|
|
and yaw) for a named player. If the "player" is in fact a
|
|
[BlockCommand][bkbcs] then the attached Block's location is returned.
|
|
|
|
#### Parameters
|
|
|
|
* player : A [org.bukkit.command.CommandSender][bkbcs] (Player or BlockCommandSender) or player name (String).
|
|
|
|
#### Returns
|
|
|
|
A [Location][cmloc] object.
|
|
|
|
[bkbcs]: http://jd.bukkit.org/dev/apidocs/org/bukkit/command/BlockCommandSender.html
|
|
[bksndr]: http://jd.bukkit.org/dev/apidocs/index.html?org/bukkit/command/CommandSender.html
|
|
***/
|
|
function getPlayerPos( player ){
|
|
player = _player( player );
|
|
if ( player ) {
|
|
if (__plugin.bukkit){
|
|
if ( player instanceof bkBlockCommandSender )
|
|
return player.block.location;
|
|
else
|
|
return player.location;
|
|
}
|
|
if (__plugin.canary){
|
|
if ( player instanceof Packages.net.canarymod.api.world.blocks.CommandBlock)
|
|
return player.block.location;
|
|
else
|
|
return player.location;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
exports.getPlayerPos = getPlayerPos;
|
|
/************************************************************************
|
|
### utils.getMousePos() function
|
|
|
|
This function returns a [Location][cmloc] object (the
|
|
x,y,z) of the current block being targeted by the named player. This
|
|
is the location of the block the player is looking at (targeting).
|
|
|
|
#### Parameters
|
|
|
|
* player : The player whose targeted location you wish to get.
|
|
|
|
#### Example
|
|
|
|
The following code will strike lightning at the location the player is looking at...
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
var playerName = 'walterh';
|
|
var targetPos = utils.getMousePos(playerName);
|
|
if (targetPos){
|
|
if (__plugin.canary){
|
|
targetPos.world.makeLightningBolt(targetPos);
|
|
}
|
|
if (__plugin.bukkit){
|
|
targetPos.world.strikeLightning(targetPos);
|
|
}
|
|
}
|
|
```
|
|
|
|
***/
|
|
exports.getMousePos = function getMousePos( player ) {
|
|
|
|
player = _player(player);
|
|
if ( !player ) {
|
|
return null;
|
|
}
|
|
var targetedBlock ;
|
|
if ( __plugin.canary ) {
|
|
var cmLineTracer = Packages.net.canarymod.LineTracer;
|
|
var lineTracer = new cmLineTracer(player);
|
|
targetedBlock = lineTracer.getTargetBlock();
|
|
if (targetedBlock == null){
|
|
return null;
|
|
}
|
|
} else {
|
|
// player might be CONSOLE or a CommandBlock
|
|
if ( !player.getTargetBlock ) {
|
|
return null;
|
|
}
|
|
try {
|
|
targetedBlock = player.getTargetBlock( null, 5 );
|
|
}catch (e){
|
|
// spigot 1.8.7 adds new overload which causes problems with JDK 7
|
|
targetedBlock = player['getTargetBlock(java.util.Set,int)'](null, 5 );
|
|
}
|
|
if ( targetedBlock == null || targetedBlock.isEmpty() ) {
|
|
return null;
|
|
}
|
|
}
|
|
return targetedBlock.location;
|
|
};
|
|
/************************************************************************
|
|
### utils.foreach() function
|
|
|
|
The utils.foreach() function is a utility function for iterating over
|
|
an array of objects (or a java.util.Collection of objects) and
|
|
processing each object in turn. Where utils.foreach() differs from
|
|
other similar functions found in javascript libraries, is that
|
|
utils.foreach can process the array immediately or can process it
|
|
*nicely* by processing one item at a time then delaying processing of
|
|
the next item for a given number of server ticks (there are 20 ticks
|
|
per second on the minecraft main thread). This method relies on
|
|
Bukkit's [org.bukkit.scheduler][sched] package for scheduling
|
|
processing of arrays.
|
|
|
|
[sched]: http://jd.bukkit.org/beta/apidocs/org/bukkit/scheduler/package-summary.html
|
|
|
|
#### Parameters
|
|
|
|
* array : The array to be processed - It can be a javascript array, a java array or java.util.Collection
|
|
* callback : The function to be called to process each item in the
|
|
array. The callback function should have the following signature
|
|
`callback(item, index, object, array)`. That is the callback will
|
|
be called with the following parameters....
|
|
|
|
- item : The item in the array
|
|
- index : The index at which the item can be found in the array.
|
|
- object : Additional (optional) information passed into the foreach method.
|
|
- array : The entire array.
|
|
|
|
* context (optional) : An object which may be used by the callback.
|
|
* delayInMilliseconds (optional, numeric) : If a delay is specified then the processing will be scheduled so that
|
|
each item will be processed in turn with a delay between the completion of each
|
|
item and the start of the next. This is recommended for any CPU-intensive process.
|
|
* onDone (optional, function) : A function to be executed when all processing
|
|
is complete. This parameter is only used when the processing is delayed. (It's optional even if a
|
|
delay parameter is supplied).
|
|
|
|
If called with a delay parameter then foreach() will return
|
|
immediately after processing just the first item in the array (all
|
|
subsequent items are processed later). If your code relies on the
|
|
completion of the array processing, then provide an `onDone` parameter
|
|
and put the code there.
|
|
|
|
#### Example
|
|
|
|
The following example illustrates how to use foreach for immediate processing of an array...
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
var players = utils.players();
|
|
utils.foreach (players, function( player ) {
|
|
echo( player , 'Hi ' + player);
|
|
});
|
|
```
|
|
|
|
... The `utils.foreach()` function can work with Arrays or any
|
|
Java-style collection. This is important because many objects in the
|
|
CanaryMod and Bukkit APIs use Java-style collections.
|
|
***/
|
|
function _foreach( array, callback, context, delay, onCompletion ) {
|
|
if ( array instanceof java.util.Collection ) {
|
|
array = array.toArray();
|
|
}
|
|
var i = 0;
|
|
var len = array.length;
|
|
function next() {
|
|
callback(array[i], i, context, array);
|
|
i++;
|
|
}
|
|
function hasNext() {
|
|
return i < len;
|
|
}
|
|
if ( delay ) {
|
|
_nicely( next, hasNext, onCompletion, delay );
|
|
} else {
|
|
for ( ;i < len; i++ ) {
|
|
callback( array[i], i, context, array );
|
|
}
|
|
}
|
|
};
|
|
exports.foreach = _foreach;
|
|
/************************************************************************
|
|
### utils.nicely() function
|
|
|
|
The utils.nicely() function is for performing background processing. utils.nicely() lets you
|
|
process with a specified delay between the completion of each `next()`
|
|
function and the start of the next `next()` function.
|
|
`utils.nicely()` is a recursive function - that is - it calls itself
|
|
(schedules itself actually) repeatedly until `hasNext` returns false.
|
|
|
|
#### Parameters
|
|
|
|
* next : A function which will be called if processing is to be done.
|
|
* hasNext : A function which is called to determine if the `next`
|
|
callback should be invoked. This should return a boolean value -
|
|
true if the `next` function should be called (processing is not
|
|
complete), false otherwise.
|
|
* onDone : A function which is to be called when all processing is complete (hasNext returned false).
|
|
* delayInMilliseconds : The delay between each call.
|
|
|
|
#### Example
|
|
|
|
See the source code to utils.foreach for an example of how utils.nicely is used.
|
|
|
|
***/
|
|
function _nicely( next, hasNext, onDone, delay ) {
|
|
if ( hasNext() ){
|
|
next();
|
|
setTimeout( function() {
|
|
_nicely( next, hasNext, onDone, delay );
|
|
}, delay );
|
|
}else{
|
|
if ( onDone ) {
|
|
onDone();
|
|
}
|
|
}
|
|
};
|
|
exports.nicely = _nicely;
|
|
|
|
function _at( time24hr, callback, pWorlds, repeat ) {
|
|
console.warn("utils.at() is deprecated, use require('at') instead");
|
|
var at = require('at');
|
|
return at( time24hr, callback, pWorlds, repeat);
|
|
}
|
|
exports.at = _at;
|
|
/*************************************************************************
|
|
### utils.time( world ) function
|
|
|
|
Returns the timeofday (in minecraft ticks) for the given world. This function is necessary because
|
|
canarymod and bukkit differ in how the timeofday is calculated.
|
|
|
|
See http://minecraft.gamepedia.com/Day-night_cycle#Conversions
|
|
|
|
***/
|
|
function getTime(world){
|
|
world = _world(world);
|
|
|
|
if (__plugin.bukkit){
|
|
return world.time;
|
|
}
|
|
if (__plugin.canary){
|
|
// there's a bug in canary where if you call world.setTime() the world.totalTime
|
|
// becomes huge.
|
|
if (world.totalTime < world.rawTime){
|
|
return world.totalTime;
|
|
} else {
|
|
return ((world.totalTime % world.rawTime) + world.relativeTime) % 24000;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
exports.time = getTime;
|
|
|
|
/*************************************************************************
|
|
### utils.time24( world ) function
|
|
|
|
Returns the timeofday for the given world using 24 hour notation. (number of minutes)
|
|
|
|
See http://minecraft.gamepedia.com/Day-night_cycle#Conversions
|
|
|
|
#### Parameters
|
|
|
|
* world : the name of the world or world object for which you want to get time
|
|
|
|
***/
|
|
function getTime24( world ){
|
|
world = _world(world); // accept world name or object or undeifned
|
|
var mcTime = getTime(world);
|
|
var mins = Math.floor( ( (mcTime + 6000) % 24000) / 16.6667 );
|
|
return mins;
|
|
}
|
|
exports.time24 = getTime24;
|
|
|
|
/************************************************************************
|
|
### utils.find() function
|
|
|
|
The utils.find() function will return a list of all files starting at
|
|
a given directory and recursiving trawling all sub-directories.
|
|
|
|
#### Parameters
|
|
|
|
* dir : The starting path. Must be a string.
|
|
* filter : (optional) A [FilenameFilter][fnfltr] object to return only files matching a given pattern.
|
|
|
|
[fnfltr]: http://docs.oracle.com/javase/6/docs/api/java/io/FilenameFilter.html
|
|
|
|
#### Example
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
var jsFiles = utils.find('./', function(dir,name){
|
|
return name.match(/\.js$/);
|
|
});
|
|
```
|
|
***/
|
|
exports.find = function( path, filter){
|
|
console.warn("utils.find() is deprecated, use require('find') instead");
|
|
return require('find')(path, filter);
|
|
};
|
|
/************************************************************************
|
|
### utils.serverAddress() function
|
|
|
|
The utils.serverAddress() function returns the IP(v4) address of the server.
|
|
|
|
```javascript
|
|
var utils = require('utils');
|
|
var serverAddress = utils.serverAddress();
|
|
console.log(serverAddress);
|
|
```
|
|
***/
|
|
exports.serverAddress = function serverAddress() {
|
|
var interfaces = java.net.NetworkInterface.getNetworkInterfaces();
|
|
var current,
|
|
addresses,
|
|
current_addr;
|
|
while ( interfaces.hasMoreElements() ) {
|
|
current = interfaces.nextElement();
|
|
if ( ! current.isUp() || current.isLoopback() || current.isVirtual() ) {
|
|
continue;
|
|
}
|
|
addresses = current.getInetAddresses();
|
|
while (addresses.hasMoreElements()) {
|
|
current_addr = addresses.nextElement();
|
|
if ( current_addr.isLoopbackAddress() )
|
|
continue;
|
|
if ( current_addr instanceof java.net.Inet4Address)
|
|
return current_addr.getHostAddress();
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
/**************************************************************************
|
|
### utils.array() function
|
|
|
|
Converts Java collection objects to type Javascript array so they can avail of
|
|
all of Javascript's Array goodness.
|
|
|
|
#### Example
|
|
|
|
var utils = require('utils');
|
|
var worlds = utils.array(server.worldManager.getAllWorlds());
|
|
|
|
***/
|
|
function toArray( ){
|
|
var result = [],
|
|
javaArray = null,
|
|
i = 0;
|
|
if (arguments[0] instanceof java.util.Collection){
|
|
// it's a java collection
|
|
javaArray = arguments[0].toArray();
|
|
for ( ;i < javaArray.length; i++) {
|
|
result.push(javaArray[i]);
|
|
}
|
|
} else if (arguments[0].constructor === Array){
|
|
// it's a javascript array
|
|
return arguments[0];
|
|
} else if (arguments[0].length) {
|
|
// it's a java array
|
|
javaArray = arguments[0];
|
|
for ( ;i < javaArray.length; i++) {
|
|
result.push(javaArray[i]);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
exports.array = toArray;
|
|
|
|
function worlds(){
|
|
if (__plugin.canary){
|
|
return toArray(server.worldManager.allWorlds);
|
|
}
|
|
if (__plugin.bukkit){
|
|
return toArray(server.worlds);
|
|
}
|
|
}
|
|
exports.worlds = worlds;
|
|
|
|
/*************************************************************************
|
|
### utils.players() function
|
|
|
|
This function returns a javascript array of all online players on the
|
|
server. You can optionally provide a function which will be invoked
|
|
with each player as a parameter. For example, to give each player the
|
|
ability to shoot arrows which launch fireworks:
|
|
|
|
```javascript
|
|
require('utils').players( arrows.firework )
|
|
```
|
|
|
|
Any players with a bow will be able to launch fireworks by shooting.
|
|
|
|
### utils.playerNames() function
|
|
|
|
This function returns a javascript array of player names (as javascript strings)
|
|
|
|
***/
|
|
function getPlayersBukkit(){
|
|
var result = [];
|
|
var players = server.getOnlinePlayers();
|
|
for (var i = 0; i < players.size(); i++){
|
|
result.push(players.get(i));
|
|
}
|
|
return result;
|
|
}
|
|
function getPlayersCanary(){
|
|
var result = [];
|
|
var players = server.playerList;
|
|
for (var i = 0; i < players.size(); i++){
|
|
result.push(players.get(i));
|
|
}
|
|
return result;
|
|
}
|
|
var getPlayers = null;
|
|
if (__plugin.canary) {
|
|
getPlayers = getPlayersCanary;
|
|
} else {
|
|
getPlayers = getPlayersBukkit;
|
|
}
|
|
|
|
function getStatBukkit(){
|
|
if (arguments.length == 1){
|
|
var stat = arguments[1];
|
|
return org.bukkit.Statistic[stat.toUpperCase()];
|
|
} else {
|
|
var player = arguments[0];
|
|
var stat = arguments[1];
|
|
return player.getStatistic(org.bukkit.Statistic[stat.toUpperCase()]);
|
|
}
|
|
|
|
}
|
|
function getStatCanary(){
|
|
var cmStatistics = Packages.net.canarymod.api.statistics.Statistics;
|
|
if (arguments.length == 1){
|
|
var stat = arguments[0];
|
|
return cmStatistics[stat.toUpperCase()].instance;
|
|
} else {
|
|
var player = arguments[0];
|
|
var stat = arguments[1];
|
|
return player.getStat(cmStatistics[stat.toUpperCase()].instance);
|
|
}
|
|
}
|
|
if (__plugin.canary){
|
|
var cmStatistics = Packages.net.canarymod.api.statistics.Statistics;
|
|
var values = cmStatistics.values();
|
|
for (var i = 0;i < values.length; i++){
|
|
var value = values[i];
|
|
try {
|
|
var stat = value.instance;
|
|
getStatCanary[value.name()] = stat;
|
|
}catch (e){
|
|
// as of 20141018 some calls to getInstance() will generate an NPE
|
|
// see https://github.com/CanaryModTeam/CanaryMod/issues/84
|
|
}
|
|
}
|
|
}
|
|
|
|
function getPlayerNames(){
|
|
return getPlayers().map(function(p){ return p.name; });
|
|
}
|
|
exports.players = function players(fn){
|
|
var result = getPlayers();
|
|
if (fn){
|
|
result.forEach(fn);
|
|
}
|
|
return result;
|
|
};
|
|
exports.playerNames = getPlayerNames;
|
|
|
|
/*************************************************************************
|
|
### utils.stat() function
|
|
|
|
This function returns a numeric value for a given player statistic.
|
|
|
|
#### Parameters
|
|
|
|
* Player - The player object (optional - if only the statistic name parameter is provided then the statistic object is returned)
|
|
* Statistic - A string whose value should be one of the following (CanaryMod)
|
|
* ANIMALSBRED
|
|
* BOATONECM
|
|
* CLIMBONECM
|
|
* CROUCHONECM
|
|
* DAMAGEDEALT
|
|
* DAMAGETAKEN
|
|
* DEATHS
|
|
* DRIVEONECM
|
|
* DROP
|
|
* FALLONECM
|
|
* FISHCAUGHT
|
|
* FLYONECM
|
|
* HORSEONECM
|
|
* JUMP
|
|
* JUNKFISHED
|
|
* LEAVEGAME
|
|
* MINECARTONECM
|
|
* MOBKILLS
|
|
* PIGONECM
|
|
* PLAYERKILLS
|
|
* PLAYONEMINUTE
|
|
* SPRINTONECM
|
|
* SWIMONECM
|
|
* TALKEDTOVILLAGER
|
|
* TIMESINCEDEATH
|
|
* TRADEDWITHVILLAGER
|
|
* TREASUREFISHED
|
|
* WALKONECM
|
|
|
|
See [CanaryMod's Statistic][cmstat] class for an up-to-date list of possible stat values
|
|
|
|
[cmstat]: https://ci.visualillusionsent.net/job/CanaryLib/javadoc/net/canarymod/api/statistics/Statistics.html
|
|
|
|
#### Example 1 Getting stats for a player
|
|
|
|
var utils = require('utils');
|
|
var jumpCount = utils.stat( player, 'jump');
|
|
|
|
#### Example 2 Getting the JUMP statistic object (which can be used elsewhere)
|
|
|
|
var utils = require('utils');
|
|
var JUMPSTAT = utils.stat('jump');
|
|
var jumpCount = player.getStat( JUMPSTAT ); // canary-specific code
|
|
|
|
This function also contains values for each possible stat so you can get at stats like this...
|
|
|
|
var utils = require('utils');
|
|
var JUMPSTAT = utils.stat.JUMP; // Accessing the value
|
|
var jumpCount = player.getStat ( JUMPSTAT ); // canary-specific code
|
|
***/
|
|
exports.stat = __plugin.canary ? getStatCanary: getStatBukkit;
|
|
|