use of org.lanternpowered.server.game.LanternGame in project LanternServer by LanternPowered.
the class DataRegistrar method setupRegistrations.
public static void setupRegistrations(LanternGame game) {
Copyable.register(ImmutableMap.class, map -> map);
Copyable.register(ImmutableList.class, list -> list);
Copyable.register(ImmutableSet.class, set -> set);
Copyable.register(List.class, ArrayList::new);
Copyable.register(Set.class, HashSet::new);
Copyable.register(Map.class, HashMap::new);
final PropertyRegistry propertyRegistry = game.getPropertyRegistry();
// Block property stores
propertyRegistry.register(SkyLuminanceProperty.class, new SkyLuminancePropertyStore());
propertyRegistry.register(GroundLuminanceProperty.class, new GroundLuminancePropertyStore());
// Entity property stores
propertyRegistry.register(DominantHandProperty.class, new DominantHandPropertyStore());
// Item property stores
propertyRegistry.register(SmeltableProperty.class, new SmeltablePropertyStore());
propertyRegistry.register(BurningFuelProperty.class, new BurningFuelPropertyStore());
final LanternDataManager dataManager = game.getDataManager();
// Register the data type serializers
DataTypeSerializers.registerSerializers(dataManager);
// Register the data serializers
DataTranslators.registerSerializers(dataManager);
// Register the data builders
dataManager.registerBuilder(PatternLayer.class, new LanternPatternLayer.Builder(game));
dataManager.registerBuilder(Text.class, new TextConfigSerializer());
dataManager.registerBuilder(BookView.class, new BookViewDataBuilder());
dataManager.registerBuilder(PotionEffect.class, new LanternPotionEffectBuilder());
dataManager.registerBuilder(RespawnLocation.class, new RespawnLocation.Builder());
dataManager.registerBuilder(Enchantment.class, new LanternEnchantmentBuilder());
final LanternValueFactory valueFactory = LanternValueFactory.get();
valueFactory.registerKey(Keys.CONNECTED_DIRECTIONS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.CONNECTED_WEST) || valueContainer.supports(Keys.CONNECTED_EAST) || valueContainer.supports(Keys.CONNECTED_NORTH) || valueContainer.supports(Keys.CONNECTED_SOUTH)).retrieveHandler((valueContainer, key) -> {
final Set<Direction> directions = new HashSet<>();
if (valueContainer.get(Keys.CONNECTED_WEST).orElse(false)) {
directions.add(Direction.WEST);
}
if (valueContainer.get(Keys.CONNECTED_EAST).orElse(false)) {
directions.add(Direction.EAST);
}
if (valueContainer.get(Keys.CONNECTED_SOUTH).orElse(false)) {
directions.add(Direction.SOUTH);
}
if (valueContainer.get(Keys.CONNECTED_NORTH).orElse(false)) {
directions.add(Direction.NORTH);
}
return Optional.of(directions);
}).offerHandler((valueContainer, key, directions) -> {
if (valueContainer instanceof ICompositeValueStore) {
final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_WEST, directions.contains(Direction.WEST)));
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_EAST, directions.contains(Direction.EAST)));
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_SOUTH, directions.contains(Direction.SOUTH)));
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_NORTH, directions.contains(Direction.NORTH)));
return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
}
return DataTransactionResult.successNoData();
}).failAlwaysRemoveHandler());
valueFactory.registerKey(Keys.WIRE_ATTACHMENTS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.WIRE_ATTACHMENT_WEST) || valueContainer.supports(Keys.WIRE_ATTACHMENT_EAST) || valueContainer.supports(Keys.WIRE_ATTACHMENT_NORTH) || valueContainer.supports(Keys.WIRE_ATTACHMENT_SOUTH)).retrieveHandler((valueContainer, key) -> {
final Map<Direction, WireAttachmentType> attachments = new HashMap<>();
valueContainer.get(Keys.WIRE_ATTACHMENT_WEST).ifPresent(type -> attachments.put(Direction.WEST, type));
valueContainer.get(Keys.WIRE_ATTACHMENT_EAST).ifPresent(type -> attachments.put(Direction.EAST, type));
valueContainer.get(Keys.WIRE_ATTACHMENT_SOUTH).ifPresent(type -> attachments.put(Direction.SOUTH, type));
valueContainer.get(Keys.WIRE_ATTACHMENT_NORTH).ifPresent(type -> attachments.put(Direction.NORTH, type));
return Optional.of(attachments);
}).offerHandler((key, valueContainer, attachments) -> {
if (valueContainer instanceof ICompositeValueStore) {
final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
WireAttachmentType type = attachments.get(Direction.WEST);
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_WEST, type == null ? WireAttachmentTypes.NONE : type));
type = attachments.get(Direction.EAST);
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_EAST, type == null ? WireAttachmentTypes.NONE : type));
type = attachments.get(Direction.SOUTH);
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_SOUTH, type == null ? WireAttachmentTypes.NONE : type));
type = attachments.get(Direction.NORTH);
resultBuilder.absorbResult(store.offerNoEvents(Keys.CONNECTED_NORTH, type == null ? WireAttachmentTypes.NONE : type));
return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
}
return DataTransactionResult.successNoData();
}).failAlwaysRemoveHandler());
valueFactory.registerKey(Keys.BODY_ROTATIONS).add(builder -> builder.applicableTester(valueContainer -> valueContainer.supports(Keys.RIGHT_ARM_ROTATION) || valueContainer.supports(Keys.LEFT_ARM_ROTATION) || valueContainer.supports(Keys.RIGHT_LEG_ROTATION) || valueContainer.supports(Keys.LEFT_LEG_ROTATION) || valueContainer.supports(Keys.HEAD_ROTATION) || valueContainer.supports(Keys.CHEST_ROTATION)).retrieveHandler((valueContainer, key) -> {
final Map<BodyPart, Vector3d> rotations = new HashMap<>();
valueContainer.get(Keys.RIGHT_ARM_ROTATION).ifPresent(type -> rotations.put(BodyParts.RIGHT_ARM, type));
valueContainer.get(Keys.RIGHT_LEG_ROTATION).ifPresent(type -> rotations.put(BodyParts.RIGHT_LEG, type));
valueContainer.get(Keys.LEFT_ARM_ROTATION).ifPresent(type -> rotations.put(BodyParts.LEFT_ARM, type));
valueContainer.get(Keys.LEFT_LEG_ROTATION).ifPresent(type -> rotations.put(BodyParts.LEFT_LEG, type));
valueContainer.get(Keys.HEAD_ROTATION).ifPresent(type -> rotations.put(BodyParts.HEAD, type));
valueContainer.get(Keys.CHEST_ROTATION).ifPresent(type -> rotations.put(BodyParts.CHEST, type));
return Optional.of(rotations);
}).offerHandler((key, valueContainer, rotations) -> {
if (valueContainer instanceof CompositeValueStore) {
final ICompositeValueStore store = (ICompositeValueStore) valueContainer;
final DataTransactionResult.Builder resultBuilder = DataTransactionResult.builder();
Vector3d rot;
if ((rot = rotations.get(BodyParts.RIGHT_ARM)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.RIGHT_ARM_ROTATION, rot));
}
if ((rot = rotations.get(BodyParts.RIGHT_LEG)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.RIGHT_LEG_ROTATION, rot));
}
if ((rot = rotations.get(BodyParts.LEFT_ARM)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.LEFT_ARM_ROTATION, rot));
}
if ((rot = rotations.get(BodyParts.LEFT_LEG)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.LEFT_LEG_ROTATION, rot));
}
if ((rot = rotations.get(BodyParts.HEAD)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.HEAD_ROTATION, rot));
}
if ((rot = rotations.get(BodyParts.CHEST)) != null) {
resultBuilder.absorbResult(store.offerNoEvents(Keys.CHEST_ROTATION, rot));
}
return resultBuilder.result(DataTransactionResult.Type.SUCCESS).build();
}
return DataTransactionResult.successNoData();
}).failAlwaysRemoveHandler());
DataManipulatorRegistry.get();
}
use of org.lanternpowered.server.game.LanternGame in project LanternServer by LanternPowered.
the class QueryHandler method handleFullStats.
private void handleFullStats(ChannelHandlerContext ctx, DatagramPacket packet, int sessionId) {
final LanternGame game = this.queryServer.getGame();
final LanternServer server = game.getServer();
final Platform platform = game.getPlatform();
final PluginContainer api = platform.getContainer(Platform.Component.API);
final PluginContainer impl = platform.getContainer(Platform.Component.IMPLEMENTATION);
final PluginContainer mc = platform.getContainer(Platform.Component.GAME);
final StringBuilder plugins = new StringBuilder().append(impl.getName()).append(" ").append(impl.getVersion()).append(" on ").append(api.getName()).append(" ").append(api.getVersion());
if (this.showPlugins) {
final List<PluginContainer> containers = new ArrayList<>(game.getPluginManager().getPlugins());
containers.remove(api);
containers.remove(impl);
containers.remove(mc);
char delim = ':';
for (PluginContainer plugin : containers) {
plugins.append(delim).append(' ').append(plugin.getName());
delim = ';';
}
}
final List<String> playerNames = server.getOnlinePlayers().stream().map(CommandSource::getName).collect(Collectors.toList());
final Cause cause = Cause.of(EventContext.empty(), new SimpleRemoteConnection((InetSocketAddress) ctx.channel().remoteAddress(), null));
final QueryServerEvent.Full event = SpongeEventFactory.createQueryServerEventFull(cause, (InetSocketAddress) ctx.channel().localAddress(), new HashMap<>(), "MINECRAFT", "SMP", getWorldName(), server.getMotd().toPlain(), playerNames, plugins.toString(), mc.getVersion().orElse("unknown"), server.getMaxPlayers(), Integer.MAX_VALUE, playerNames.size(), 0);
final InetSocketAddress address = event.getAddress();
final Map<String, Object> data = new LinkedHashMap<>();
data.put("hostname", event.getMotd());
data.put("gametype", event.getGameType());
data.put("game_id", event.getGameId());
data.put("version", event.getVersion());
data.put("plugins", event.getPlugins());
data.put("map", event.getMap());
data.put("numplayers", event.getPlayerCount());
data.put("maxplayers", event.getMaxPlayerCount());
data.put("hostport", address.getPort());
data.put("hostip", address.getHostString());
event.getCustomValuesMap().entrySet().stream().filter(entry -> !data.containsKey(entry.getKey())).forEach(entry -> data.put(entry.getKey(), entry.getValue()));
final ByteBuf buf = ctx.alloc().buffer();
buf.writeByte(ACTION_STATS);
buf.writeInt(sessionId);
// constant: splitnum\x00\x80\x00
buf.writeBytes(new byte[] { 0x73, 0x70, 0x6C, 0x69, 0x74, 0x6E, 0x75, 0x6D, 0x00, (byte) 0x80, 0x00 });
for (Entry<String, Object> e : data.entrySet()) {
writeString(buf, e.getKey());
writeString(buf, String.valueOf(e.getValue()));
}
buf.writeByte(0);
// constant: \x01player_\x00\x00
buf.writeBytes(new byte[] { 0x01, 0x70, 0x6C, 0x61, 0x79, 0x65, 0x72, 0x5F, 0x00, 0x00 });
for (Player player : game.getServer().getOnlinePlayers()) {
writeString(buf, player.getName());
}
buf.writeByte(0);
ctx.write(new DatagramPacket(buf, packet.sender()));
}
Aggregations