@Command(
aliases = {"gamemode", "gm"},
usage =
"[player] <0|1|2|survival|creative|adventure> (0 = SURVIVAL, 1 = CREATIVE, 2 = ADVENTURE)",
desc = "Change a player's game mode",
min = 1,
max = 2)
@CommandPermissions("vanilla.command.gamemode")
public void gamemode(CommandContext args, CommandSource source) throws CommandException {
int index = 0;
Player player;
if (args.length() == 2) {
if (Spout.getEngine() instanceof Client) {
throw new CommandException("You cannot search for players unless you are in server mode.");
}
player = Spout.getEngine().getPlayer(args.getString(index++), true);
if (player == null) {
throw new CommandException(args.getString(0) + " is not online.");
}
} else {
if (!(source instanceof Player)) {
throw new CommandException("You must be a player to toggle your game mode.");
}
player = (Player) source;
}
if (!player.has(Human.class)) {
throw new CommandException("Invalid player!");
}
GameMode mode;
try {
if (args.isInteger(index)) {
mode = GameMode.get(args.getInteger(index));
} else {
mode = GameMode.get(args.getString(index));
}
} catch (Exception e) {
throw new CommandException(
"A game mode must be either a number between 0 and 2, 'CREATIVE', 'SURVIVAL' or 'ADVENTURE'");
}
player.get(Human.class).setGamemode(mode);
if (!player.equals(source)) {
source.sendMessage(
plugin.getPrefix(),
ChatStyle.WHITE,
player.getName(),
"'s ",
ChatStyle.BRIGHT_GREEN,
"gamemode has been changed to ",
ChatStyle.WHITE,
mode.name(),
ChatStyle.BRIGHT_GREEN,
".");
}
}
private void readObject(java.io.ObjectInputStream in) throws IOException {
float x = in.readFloat();
float y = in.readFloat();
float z = in.readFloat();
String world = in.readUTF();
World w = Spout.getEngine().getWorld(world);
try {
Field field;
field = Vector3.class.getDeclaredField("x");
field.setAccessible(true);
field.set(this, x);
field = Vector3.class.getDeclaredField("y");
field.setAccessible(true);
field.set(this, y);
field = Vector3.class.getDeclaredField("z");
field.setAccessible(true);
field.set(this, z);
field = Point.class.getDeclaredField("world");
field.setAccessible(true);
field.set(this, w);
} catch (Exception e) {
if (Spout.debugMode()) {
e.printStackTrace();
}
}
}
@Override
public void ban(boolean kick, Object... reason) {
if (Spout.getPlatform() != Platform.SERVER) {
throw new IllegalStateException("Banning is only available in server mode.");
}
((Server) Spout.getEngine()).getAccessManager().ban(BanType.PLAYER, name, kick, reason);
}
@Override
public byte[] compress() {
Serializable value = data.get();
if (value instanceof ByteArrayWrapper) {
return ((ByteArrayWrapper) value).getArray();
}
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
try {
ObjectOutputStream objOut = new ObjectOutputStream(byteOut);
objOut.writeObject(value);
objOut.flush();
objOut.close();
} catch (IOException e) {
if (Spout.debugMode()) {
Spout.getLogger()
.log(
Level.SEVERE,
"Unable to serialize "
+ value
+ " (type: "
+ (value != null ? value.getClass().getSimpleName() : "null")
+ ")",
e);
}
return null;
}
return byteOut.toByteArray();
}
private void onKeyPressed(Player player, Keyboard key, boolean pressed, char ch) {
final PlayerKeyEvent event =
Spout.getEventManager().callEvent(new PlayerKeyEvent(player, key, pressed, ch));
if (event.isCancelled()) {
return;
}
if (Spout.debugMode()) {
Spout.log("Key " + key + " was " + (pressed ? "pressed" : "released"));
}
// SHIFT + TAB changes the focus index
Screen in = getInputScreen();
if (key == FOCUS_KEY && pressed) {
if (in != null) {
if (org.lwjgl.input.Keyboard.isKeyDown(Keyboard.KEY_LSHIFT.getId())
|| org.lwjgl.input.Keyboard.isKeyDown(Keyboard.KEY_RSHIFT.getId())) {
in.previousFocus(FocusReason.KEYBOARD_TAB);
} else {
in.nextFocus(FocusReason.KEYBOARD_TAB);
}
}
}
// send event to the focused widget
if (in != null) {
Widget w = in.getFocusedWidget();
if (w != null) {
w.onKey(event);
}
}
executeBindings(getKeyBindingsFor(key), player, pressed);
}
private void onMouseClicked(Player player, Mouse button, boolean pressed, int x, int y) {
PlayerClickEvent event =
Spout.getEventManager()
.callEvent(new PlayerClickEvent(player, button, pressed, new IntVector2(x, y)));
if (event.isCancelled()) {
return;
}
if (Spout.debugMode()) {
Spout.log("Mouse clicked at {" + x + "," + y + "} was " + (pressed ? "pressed" : "released"));
}
Screen s = getInputScreen();
if (s != null) {
Widget w = s.getWidgetAt(x, y);
if (w != null) {
Widget fw = s.getFocusedWidget();
if (fw != null && !fw.equals(w)) {
s.setFocus(w, FocusReason.CLICKED);
}
w.onClicked(event);
}
}
executeBindings(getMouseBindingsFor(button), player, pressed);
}
@Command(
aliases = "xp",
usage = "[player] <amount>",
desc = "Give/take experience from a player",
min = 1,
max = 2)
@CommandPermissions("vanilla.command.xp")
public void xp(CommandContext args, CommandSource source) throws CommandException {
// If source is player
if (args.length() == 1) {
if (source instanceof Player) {
@SuppressWarnings("unused")
Player sender = (Player) source;
int amount = args.getInteger(0);
source.sendMessage(
plugin.getPrefix(),
ChatStyle.BRIGHT_GREEN,
"You have been given ",
ChatStyle.WHITE,
amount,
ChatStyle.BRIGHT_GREEN,
" xp.");
// TODO: Give player 'amount' of xp.
} else {
throw new CommandException("You must be a player to give yourself xp.");
}
} else {
if (Spout.getEngine() instanceof Client) {
throw new CommandException("You cannot search for players unless you are in server mode.");
}
Player player = ((Server) Spout.getEngine()).getPlayer(args.getString(0), true);
if (player != null) {
short amount = (short) args.getInteger(1);
LevelComponent level = player.get(LevelComponent.class);
if (level == null) {
return;
}
if (amount > 0) {
level.addExperience(amount);
} else {
level.removeExperience(amount);
}
player.sendMessage(
plugin.getPrefix(),
ChatStyle.BRIGHT_GREEN,
"Your experience has been set to ",
ChatStyle.WHITE,
amount,
ChatStyle.BRIGHT_GREEN,
".");
} else {
throw new CommandException(args.getString(0) + " is not online.");
}
}
}
public FullScreen() {
if (Spout.getPlatform() == Platform.CLIENT) {
try {
((Client) Spout.getEngine())
.getScreenStack()
.subscribe(ScreenStack.SIGNAL_RESIZED, this, "onScreenResized");
} catch (SecurityException e) {
} catch (NoSuchMethodException e) {
}
}
}
@Override
public void onAttached() {
if (!(getOwner() instanceof Player)) {
throw new IllegalStateException("PlayerListComponent may only be attached to a player.");
}
if (!(Spout.getEngine() instanceof Server)) {
throw new IllegalStateException("Player list components may only be attached server side");
}
server = (Server) Spout.getEngine();
player = (Player) getOwner();
}
static {
if (Spout.getPlatform() == Platform.CLIENT) {
DEFAULT_FONT =
(Font) Spout.getFileSystem().getResource("font://Spout/fonts/ubuntu/Ubuntu-M.ttf");
GUI_COLOR =
(RenderMaterial)
FILE_SYSTEM.getResource("material://Spout/materials/GUIColorMaterial.smt");
} else {
DEFAULT_FONT = null;
GUI_COLOR = null;
}
}
/**
* Sets a property of the window
*
* @param id of the property
* @param value value of property
*/
public void setProperty(int id, int value) {
properties.put(id, value);
switch (Spout.getPlatform()) {
case PROXY:
case SERVER:
callProtocolEvent(new WindowPropertyEvent(this, id, value));
break;
case CLIENT:
// TODO: Window properties
break;
default:
throw new IllegalStateException("Unknown platform: " + Spout.getPlatform());
}
}
@Override
public void finalizeRun() {
if (Spout.getEngine().getPlatform() != Platform.CLIENT && !this.isOnlineLive()) {
remove();
}
super.finalizeRun();
if (this.isOnline()) {
this.getNetworkSynchronizer().finalizeTick();
}
if (isRemoved()) {
getNetworkSynchronizer().onRemoved();
((SpoutEngine) Spout.getEngine()).removePlayer(this);
sessionLive.set(null);
}
}
@Override
public void run() {
HttpURLConnection connection = null;
String response = "";
try {
URL url = new URL(URL);
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty(
"Content-Length", Integer.toString(urlParameters.getBytes().length));
connection.setRequestProperty("Content-Language", "en-US");
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
DataOutputStream e = new DataOutputStream(connection.getOutputStream());
e.writeBytes(urlParameters);
e.flush();
e.close();
InputStream is = connection.getInputStream();
BufferedReader rd = new BufferedReader(new InputStreamReader(is));
StringBuffer responseBuffer = new StringBuffer();
String line;
while ((line = rd.readLine()) != null) {
responseBuffer.append(line);
responseBuffer.append('\r');
}
rd.close();
response = responseBuffer.toString();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
connection.disconnect();
}
}
if (VanillaPlugin.getInstance().getEngine().debugMode()) {
Spout.getLogger().info("Authentification: " + response);
}
if (response.contains(":")) {
String[] infos = response.split(":");
VanillaPlugin.getInstance().setClientAuthInfos(infos[2], infos[3]);
} else {
Spout.getLogger().info("Authentification failed: " + response);
}
}
@Override
public void onTick(float dt) {
final Random random = GenericMath.getRandom();
float secondsUntilWeatherChange = sky.getData().get(VanillaData.WEATHER_CHANGE_TIME);
secondsUntilWeatherChange -= dt;
if (forceWeatherUpdate.compareAndSet(true, false) || secondsUntilWeatherChange <= 0) {
this.sky.updateWeather(getCurrent(), getForecast());
sky.getData().put(VanillaData.WORLD_WEATHER, getForecast());
final Weather current = getCurrent();
Weather forecast = current;
while (forecast == current) {
// When Rain/Snow or Thunderstorms occur, always go to Clear after.
if (current == Weather.RAIN || current == Weather.THUNDERSTORM) {
forecast = Weather.CLEAR;
} else {
forecast = Weather.get(random.nextInt(3));
}
setForecast(forecast);
}
setForecast(forecast);
secondsUntilWeatherChange =
current.getBaseWeatherTime() + random.nextInt(current.getRandomWeatherTime());
if (Spout.debugMode()) {
Spout.getLogger()
.info(
"Weather changed to: "
+ current
+ ", next change in "
+ secondsUntilWeatherChange / 1000F
+ "s");
}
}
float currentRainStrength = sky.getData().get(VanillaData.CURRENT_RAIN_STRENGTH);
sky.getData().put(VanillaData.PREVIOUS_RAIN_STRENGTH, currentRainStrength);
if (this.isRaining()) {
currentRainStrength = Math.min(1.0f, currentRainStrength + 0.01f);
} else {
currentRainStrength = Math.max(0.0f, currentRainStrength - 0.01f);
}
sky.getData().put(VanillaData.CURRENT_RAIN_STRENGTH, currentRainStrength);
if (hasLightning()) {
lightning.onTick(dt);
}
if (getCurrent().isRaining()) {
snowfall.onTick(dt);
}
sky.getData().put(VanillaData.WEATHER_CHANGE_TIME, secondsUntilWeatherChange);
}
public static Renderer constructNewBatch(int renderMode) {
List<Renderer> list = POOL.get(renderMode);
if (list == null) {
// If we're using a POOL, it should already be intialized
throw new IllegalStateException("Pool uninitialized!");
}
if (!list.isEmpty()) {
Renderer batch = list.remove(0);
((BatchVertexRenderer) batch).used++;
return batch;
}
Client client = (Client) Spout.getEngine();
switch (client.getRenderMode()) {
case GL20:
return new GL20BatchVertexRenderer(renderMode);
case GL30:
return new GL30BatchVertexRenderer(renderMode);
case GL40:
return new GL30BatchVertexRenderer(renderMode);
case GLES20:
return new GLES20BatchVertexRenderer(renderMode);
default:
throw new IllegalArgumentException("GL Mode:" + client.getRenderMode() + " Not recognized");
}
}
public void execute(float dt) {
for (InputExecutor executor : inputExecutors) {
SpoutSceneComponent sc =
(SpoutSceneComponent) ((Client) Spout.getEngine()).getActivePlayer().getScene();
executor.execute(dt, sc.getLiveTransform());
}
}
private Screen getInputScreen() {
Engine engine = Spout.getEngine();
if (!(engine instanceof Client)) {
throw new IllegalStateException("Cannot access ScreenStack in server mode.");
}
return ((Client) engine).getScreenStack().getInputScreen();
}
public SSAOPostProcessEffect() {
kernel = new Vector3[kernelSize];
Random rng = new Random();
for (int i = 0; i < kernelSize; i++) {
// Create a set of random vectors along the surface of a hemisphere.
kernel[i] =
new Vector3((rng.nextFloat() * 2) - 1, (rng.nextFloat() * 2) - 1, rng.nextFloat());
// Normalize the vector
kernel[i] = kernel[i].normalize();
// Scale it into the hemisphere so the vectors aren't all along the surface.
// We want the distance from the origin to fall off as we generate more points.
float scale = (float) i / (float) kernelSize;
scale = GenericMath.lerp(0.1f, 1.0f, scale * scale);
kernel[i] = kernel[i].multiply(scale);
}
// Generate the noise texture.
int[] texture = new int[noiseSize * noiseSize];
for (int i = 0; i < noiseSize * noiseSize; i++) {
Color c = new Color(rng.nextFloat(), rng.nextFloat(), 0);
texture[i] = c.getRGB();
}
Vector2 resolution = ((Client) Spout.getEngine()).getResolution();
noiseScale = new Vector2(resolution.getX() / noiseSize, resolution.getY() / noiseSize);
noise = new ClientTexture(texture, noiseSize, noiseSize);
}
@EventHandler(order = Order.LATEST)
public void entityDeath(EntityDeathEvent event) {
Entity entity = event.getEntity();
Engine engine = Spout.getEngine();
// kill count criteria
Object lastDamager = event.getLastDamager();
if (lastDamager instanceof Player) {
Player killer = (Player) lastDamager;
String killerName = killer.getName();
String[] criteria = {
Objective.CRITERIA_TOTAL_KILL_COUNT, Objective.CRITERIA_PLAYER_KILL_COUNT
};
if (entity instanceof Player) {
// killed a player? update total and player kill count
evaluateCriteria(killerName, 1, true, criteria);
} else {
// just an entity? only update total kill count
evaluateCriteria(killerName, 1, true, criteria[0]);
}
}
if (!(entity instanceof Player) || !(engine instanceof Server)) {
return;
}
// player death criteria
Player player = (Player) entity;
evaluateCriteria(player.getName(), 1, true, Objective.CRITERIA_DEATH_COUNT);
}
@Override
public void onAttached() {
if (Spout.getPlatform() != Platform.CLIENT) {
throw new UnsupportedOperationException(
"SpoutFallbackMovementComponent can only be attached client side!");
}
}
/**
* Called when a player interacts
*
* @param event Relevant event details
*/
@EventHandler(event = PlayerInteractEvent.class)
public void onPlayerInteract(PlayerInteractEvent event) {
final LocalPlayer player = plugin.wrapPlayer(event.getPlayer());
final LocalWorld world = player.getWorld();
final WorldEdit we = plugin.getWorldEdit();
PlayerInteractEvent.Action action = event.getAction();
if (action == Action.LEFT_CLICK) {
if (event.isAir() && ignoreLeftClickAir) {
return;
}
if (!event.isAir()) {
final Point clickedBlock = event.getInteractedPoint();
final WorldVector pos =
new WorldVector(world, clickedBlock.getX(), clickedBlock.getY(), clickedBlock.getZ());
if (we.handleBlockLeftClick(player, pos)) {
event.setCancelled(true);
}
}
if (we.handleArmSwing(player)) {
event.setCancelled(true);
}
if (!event.isAir() && !ignoreLeftClickAir) {
final int taskId =
Spout.getGame()
.getScheduler()
.scheduleSyncDelayedTask(
plugin,
new Runnable() {
public void run() {
ignoreLeftClickAir = false;
}
},
2);
if (taskId != -1) {
ignoreLeftClickAir = true;
}
}
} else if (action == Action.RIGHT_CLICK) {
if (!event.isAir()) {
final Point clickedBlock = event.getInteractedPoint();
final WorldVector pos =
new WorldVector(world, clickedBlock.getX(), clickedBlock.getY(), clickedBlock.getZ());
if (we.handleBlockRightClick(player, pos)) {
event.setCancelled(true);
}
}
if (we.handleRightClick(player)) {
event.setCancelled(true);
}
}
}
private boolean shouldForce(int entityId) {
int hash = HASH_SEED;
hash += (hash << 5) + entityId;
hash += (hash << 5) + tickCounter;
return (hash & FORCE_MASK) == 0
|| (Spout.debugMode() && getPlayer().has(ForceMessagesComponent.class));
}
public static void initPool(int renderMode, int number) {
List<Renderer> list = POOL.get(renderMode);
if (list == null) {
list = new LinkedList<>();
POOL.put(renderMode, list);
}
Client client = (Client) Spout.getEngine();
switch (client.getRenderMode()) {
case GL20:
for (int i = 0; i < number; i++) {
list.add(new GL20BatchVertexRenderer(renderMode));
}
return;
case GL30:
for (int i = 0; i < number; i++) {
list.add(new GL30BatchVertexRenderer(renderMode));
}
return;
case GL40:
for (int i = 0; i < number; i++) {
list.add(new GL30BatchVertexRenderer(renderMode));
}
return;
case GLES20:
for (int i = 0; i < number; i++) {
list.add(new GLES20BatchVertexRenderer(renderMode));
}
return;
default:
throw new IllegalArgumentException("GL Mode:" + client.getRenderMode() + " Not recognized");
}
}
@Override
public void save(Writer writer) {
Yaml yaml = new Yaml();
LinkedHashMap<String, Object> dump = new LinkedHashMap<>();
dump.put("nextId", nextId);
LinkedHashMap<Integer, LinkedHashMap<String, String>> ids = new LinkedHashMap<>();
for (Entry<String, HashMap<String, Integer>> e1 : classes.entrySet()) {
for (Entry<String, Integer> e2 : e1.getValue().entrySet()) {
String clazz = e1.getKey();
String source = e2.getKey();
int key = e2.getValue();
LinkedHashMap<String, String> v = new LinkedHashMap<>(2);
v.put("class", clazz);
v.put("string", source);
ids.put(key, v);
}
}
dump.put("ids", ids);
String toWrite = yaml.dumpAs(dump, Tag.MAP, FlowStyle.BLOCK);
try {
writer.write(toWrite);
} catch (IOException e) {
Spout.getLogger().log(Level.SEVERE, "unable to save dictionary", e);
} finally {
IOUtils.closeQuietly(writer);
}
}
public <T extends Event> T callEvent(T event) {
HandlerList handlers = event.getHandlers();
ListenerRegistration[] listeners = handlers.getRegisteredListeners();
if (listeners != null) {
for (ListenerRegistration listener : listeners) {
try {
if (!event.isCancelled() || listener.getOrder().ignoresCancelled()) {
listener.getExecutor().execute(event);
}
} catch (Throwable ex) {
Spout.getEngine()
.getLogger()
.log(
Level.SEVERE,
"Could not pass event "
+ event.getEventName()
+ " to "
+ listener.getOwner().getClass().getName(),
ex);
}
}
event.setHasBeenCalled(true);
}
return event;
}
private SecureRandom getSecureRandom(String RNGAlgorithm, String RNGProvider) {
try {
SecureRandom r;
if (RNGProvider != null) {
r = SecureRandom.getInstance(RNGAlgorithm, RNGProvider);
} else {
r = SecureRandom.getInstance(RNGAlgorithm);
}
r.nextBytes(new byte[1]);
return r;
} catch (NoSuchProviderException e) {
// Fallback to any provider for the algorithm
return getSecureRandom(RNGAlgorithm, null);
} catch (NoSuchAlgorithmException e) {
if (RNGProvider != null) {
return getSecureRandom(RNGAlgorithm, null);
}
Spout.getLogger()
.severe(
"Unable to find algorithm to generate random number generator for key pair creation ("
+ RNGAlgorithm
+ ", "
+ RNGProvider
+ ")");
return null;
}
}
public byte[] processAll(AsymmetricBlockCipher cipher, byte[] input) {
int outputSize = 0;
int blockSize = cipher.getInputBlockSize();
List<byte[]> outputBlocks = new LinkedList<>();
int pos = 0;
while (pos < input.length) {
int length = Math.min(input.length - pos, blockSize);
byte[] result;
try {
result = cipher.processBlock(input, pos, length);
} catch (InvalidCipherTextException e) {
Spout.getLogger().info("Error processing encrypted data");
return null;
}
outputSize += result.length;
outputBlocks.add(result);
pos += length;
}
byte[] output = new byte[outputSize];
pos = 0;
for (byte[] block : outputBlocks) {
System.arraycopy(block, 0, output, pos, block.length);
pos += block.length;
}
return output;
}
@Override
protected void worldChanged(World world) {
GameMode gamemode = world.getComponentHolder().getData().get(VanillaData.GAMEMODE);
// The world the player is entering has a different gamemode...
if (gamemode != null) {
if (gamemode != getPlayer().getData().get(VanillaData.GAMEMODE)) {
PlayerGameModeChangedEvent event =
Spout.getEngine()
.getEventManager()
.callEvent(new PlayerGameModeChangedEvent(player, gamemode));
if (!event.isCancelled()) {
gamemode = event.getMode();
}
}
} else {
// The world has no gamemode setting in its map so default to the Player's GameMode.
gamemode = getPlayer().getData().get(VanillaData.GAMEMODE);
}
Difficulty difficulty = world.getComponentHolder().getData().get(VanillaData.DIFFICULTY);
Dimension dimension = world.getComponentHolder().getData().get(VanillaData.DIMENSION);
WorldType worldType = world.getComponentHolder().getData().get(VanillaData.WORLD_TYPE);
// TODO Handle infinite height
if (first) {
first = false;
int entityId = player.getId();
Server server = (Server) session.getEngine();
PlayerLoginRequestMessage idMsg =
new PlayerLoginRequestMessage(
entityId,
worldType.toString(),
gamemode.getId(),
(byte) dimension.getId(),
difficulty.getId(),
(byte) server.getMaxPlayers());
player.getSession().send(false, true, idMsg);
player.getSession().setState(State.GAME);
for (int slot = 0; slot < 4; slot++) {
ItemStack slotItem = owner.get(Human.class).getInventory().getArmor().get(slot);
player.getSession().send(false, new EntityEquipmentMessage(entityId, slot, slotItem));
}
} else {
player
.getSession()
.send(
false,
new PlayerRespawnMessage(
dimension.getId(),
difficulty.getId(),
gamemode.getId(),
256,
worldType.toString()));
}
Point pos = world.getSpawnPoint().getPosition();
PlayerSpawnPositionMessage SPMsg =
new PlayerSpawnPositionMessage((int) pos.getX(), (int) pos.getY(), (int) pos.getZ());
player.getSession().send(false, SPMsg);
}
public AsymmetricCipherKeyPairGenerator getGenerator(String algorithm) {
if (algorithm.equals("RSA")) {
return new RSAKeyPairGenerator();
}
Spout.getLogger().info("Unable to find key generator " + algorithm);
return null;
}
public WeatherSimulator(Sky sky) {
if (Spout.getPlatform() != Platform.SERVER) {
throw new UnsupportedOperationException("Weather simulation can only happen on the server");
}
this.sky = sky;
this.lightning = new LightningSimulator(this);
this.snowfall = new SnowSimulator(this);
}
