@Listener public void onServerStarting(GameStartingServerEvent event) { GlobalCommands globalCommands = new GlobalCommands(this); CommandSpec map = CommandSpec.builder() .description(Text.of("All commands related to the chunk protection")) .executor(globalCommands::map) .build(); CommandSpec claim = CommandSpec.builder() .description(Text.of("Claims the chunk that you are standing")) .executor(globalCommands::claim) .build(); CommandSpec chunk = CommandSpec.builder() .description(Text.of("Commands related to chunk protection")) .child(map, "map") .child(claim, "claim") .build(); CommandSpec mychunk = CommandSpec.builder() .description(Text.of("All mychunk commands")) .child(chunk, "chunk", "c") .build(); Sponge.getCommandManager().register(this, chunk, "chunk"); Sponge.getCommandManager().register(this, mychunk, "mychunk"); }
@Listener public void onPlayerRespawn(RespawnPlayerEvent event) { Player player = event.getTargetEntity(); if (this.teamA.contains(player)) { event.setToTransform( event.getToTransform().setLocation(this.arena.getTeamASpawn().getLocation())); Sponge.getScheduler() .createTaskBuilder() .execute( () -> { if (this.arena.getTeamALoadout() != null) UltimateGames.game .getCommandManager() .process( Sponge.getServer().getConsole(), "kit " + this.arena.getTeamALoadout() + " " + player.getName()); }) .delayTicks(10) .name("UltimateGames - Give Player Loadout") .submit( UltimateGames.game .getPluginManager() .getPlugin("io.github.hsyyid.ultimategames") .get() .getInstance() .get()); } else if (this.teamB.contains(player)) { event.setToTransform( event.getToTransform().setLocation(this.arena.getTeamBSpawn().getLocation())); Sponge.getScheduler() .createTaskBuilder() .execute( () -> { if (this.arena.getTeamBLoadout() != null) UltimateGames.game .getCommandManager() .process( Sponge.getServer().getConsole(), "kit " + this.arena.getTeamBLoadout() + " " + player.getName()); }) .delayTicks(10) .name("UltimateGames - Give Player Loadout") .submit( UltimateGames.game .getPluginManager() .getPlugin("io.github.hsyyid.ultimategames") .get() .getInstance() .get()); } }
@Override public CommandResult executeCommand(final CommandSource src, CommandContext args) throws Exception { if (service == null) { service = Sponge.getServiceManager().provideUnchecked(NucleusWarpService.class); } PaginationService ps = Sponge.getServiceManager().provideUnchecked(PaginationService.class); // Get the warp list. Set<String> ws = service.getWarpNames(); if (ws.isEmpty()) { src.sendMessage(Util.getTextMessageWithFormat("command.warps.list.nowarps")); return CommandResult.empty(); } List<Text> lt = ws.stream() .filter(s -> canView(src, s.toLowerCase())) .map( s -> { if (service.getWarp(s).isPresent()) { return Text.builder(s) .color(TextColors.GREEN) .style(TextStyles.UNDERLINE) .onClick(TextActions.runCommand("/warp " + s)) .onHover( TextActions.showText( Util.getTextMessageWithFormat("command.warps.warpprompt", s))) .build(); } else { return Text.builder(s) .color(TextColors.RED) .onHover( TextActions.showText( Util.getTextMessageWithFormat("command.warps.unavailable"))) .build(); } }) .collect(Collectors.toList()); PaginationList.Builder pb = ps.builder() .title(Util.getTextMessageWithFormat("command.warps.list.header")) .padding(Text.of(TextColors.GREEN, "-")) .contents(lt); if (!(src instanceof Player)) { pb.linesPerPage(-1); } pb.sendTo(src); return CommandResult.success(); }
private Optional<Player> validPlayer(Cause cause) { Optional<EntityDamageSource> optionalSrc = cause.first(EntityDamageSource.class); if (optionalSrc.isPresent()) { Entity src = optionalSrc.get().getSource(); if (src instanceof Player) { return Optional.of((Player) src); } else if (src instanceof Projectile) { Projectile projectile = (Projectile) src; Optional<UUID> optionalUUID = projectile.getCreator(); if (!optionalUUID.isPresent()) { return Optional.empty(); } Optional<Player> optionalPlayer = Sponge.getServer().getPlayer(optionalUUID.get()); if (!optionalPlayer.isPresent()) { return Optional.empty(); } return Optional.of(optionalPlayer.get()); } } return Optional.empty(); }
@Inject( method = "onUpdate", at = @At( value = "INVOKE", target = "Lnet/minecraft/entity/effect/EntityLightningBolt;setDead()V")) public void onSetDead(CallbackInfo ci) { if (this.isDead) { return; } World world = (World) this.worldObj; LightningEvent.Strike strike = SpongeEventFactory.createLightningEventStrike( this.cause, this.struckEntities, this.struckEntitySnapshots, world, this.struckBlocks); Sponge.getEventManager().post(strike); if (!strike.isCancelled()) { for (Transaction<BlockSnapshot> bt : strike.getTransactions()) { if (bt.isValid()) { BlockSnapshot bs = bt.getFinal(); world.setBlock(bs.getPosition(), bs.getState()); } } for (Entity e : strike.getEntities()) { ((net.minecraft.entity.Entity) e).onStruckByLightning((EntityLightningBolt) (Object) this); } SpongeImpl.postEvent(SpongeEventFactory.createLightningEventPost(this.cause)); } }
public void init() { SqlService sql = Sponge.getServiceManager() .provide(SqlService.class) .orElseThrow(() -> new IllegalStateException("NoSQL?")); String jdbcUrl = Planetesimals.getInstance().getJDBCUrl(); String[] dbParts = jdbcUrl.split(":"); if (dbParts.length < 2 || !dbParts[1].equals("h2")) { throw new IllegalStateException("Not H2. Dunno what to do."); } try { this.data = sql.getDataSource(jdbcUrl); } catch (SQLException e) { throw new IllegalStateException("Couldn't load DB", e); } this.db = using(this.data, SQLDialect.H2); if (getDB() .meta() .getTables() .stream() .noneMatch(t -> t.getName().equalsIgnoreCase(PLANETS_TABLE.getName()))) { getDB() .createTable(PLANETS_TABLE) .column(CHUNK_X_FIELD, getDataType(Integer.class)) .column(CHUNK_Y_FIELD, getDataType(Integer.class)) .column(CHUNK_Z_FIELD, getDataType(Integer.class)) .column(PLANET_X_FIELD, getDataType(Integer.class)) .column(PLANET_Y_FIELD, getDataType(Integer.class)) .column(PLANET_Z_FIELD, getDataType(Integer.class)) .column(PLANET_RADIUS_FIELD, getDataType(Integer.class)) .execute(); } }
@Override public Optional<Text> getValue(@Nullable Object player) { if (player == null) return Optional.empty(); if (player instanceof Player) { Player p = (Player) player; if (Sponge.getServiceManager().provide(EconomyService.class).isPresent()) { EconomyService es = Sponge.getServiceManager().provide(EconomyService.class).get(); if (es.getOrCreateAccount(p.getUniqueId()).isPresent()) { BigDecimal balance = es.getOrCreateAccount(p.getUniqueId()).get().getBalance(es.getDefaultCurrency()); return Optional.of(Text.of(balance.toString())); } } return Optional.empty(); } return Optional.empty(); }
public void cancel() { cancelled = true; tasks .values() .forEach( task -> { Sponge.getEventManager().unregisterListeners(task); }); }
final boolean unregister() { if (this.registered) { this.registered = false; Sponge.getEventManager().unregisterListeners(this); return true; } else { return false; } }
@Listener(order = Order.POST) public void onAffectSlotEvent(AffectSlotEvent event, @Root Player player) { for (SlotTransaction transaction : event.getTransactions()) { ItemStack itemStack = transaction.getFinal().createStack(); BigDecimal amount = WalletDrop.getValue(itemStack); if (amount.compareTo(BigDecimal.ZERO) == 0) { continue; } WorldSettings settings = WorldSettings.get(player.getWorld()); if (player.gameMode().get().equals(GameModes.CREATIVE) && !settings.isCreativeModeAllowed()) { event.setCancelled(true); return; } if (settings.isUsePermissions()) { if (!player.hasPermission("walletdrop.enable")) { return; } } WalletPickupEvent moneyPickupEvent = new WalletPickupEvent(itemStack, amount, Cause.of(NamedCause.source(player))); if (!Sponge.getEventManager().post(moneyPickupEvent)) { Sponge.getScheduler() .createTaskBuilder() .delayTicks(2) .execute( c -> { player.getInventory().query(itemStack).clear(); }) .submit(Main.getPlugin()); WalletDrop.depositOrWithdraw(player, moneyPickupEvent.getAmount()); WalletDrop.sendPickupMessage(player, amount); } } }
@Override public Optional<Text> getBanReason(GameProfile profile) { checkNotNull(profile, "Game profile cannot be null!"); BanService service = Sponge.getServiceManager().provide(BanService.class).get(); Optional<Ban.Profile> optionalBan = service.getBanFor(profile); if (optionalBan.isPresent()) { return optionalBan.get().getReason(); } return Optional.empty(); }
final boolean register(Class<S> event) { if (this.registered) { return false; } else { this.registered = true; Sponge.getEventManager() .registerListener( Pore.getPlugin(), event, EventPriorityConverter.of(this.priority), this); return true; } }
@Listener public void onWorldLoad(LoadWorldEvent event) { World world = event.getTargetWorld(); logger.info("World loaded: " + world.getName()); UUID uniqueId = world.getUniqueId(); claimedChunks.put(uniqueId, new HashMap<>()); try { worldContexts.put(uniqueId, loadWorldContext(world)); } catch (IOException e) { logger.error("Failed to load world data"); Sponge.getServer().shutdown(); } }
public CreatingJob(UUID uuid) { this.uuid = uuid; // Add tasks addTasks( new NameTask(this), new MaxLevelTask(this), new ColorTask(this), new BlockDataTask(this), new BreakTask(this), new PlaceTask(this), new KillTask(this), new SilkTouchTask(this), new WorldGenTask(this), new FinalTask(this)); // Send cancel message for (Player player : Sponge.getServer().getOnlinePlayers()) { if (player.getUniqueId().equals(uuid)) player.sendMessage(messages.getMessage("creation.cancel")); } // Register listener Sponge.getEventManager().registerListeners(JobsLite.getInstance(), this); // Start task nextTask(); }
public void submitInventory(Class owner, boolean openInventory) { this.owner = owner; em.registerListener(owner, this); if (openInventory) { for (UUID user : users) { Optional<Player> player = Sponge.getServer().getPlayer(user); if (player.isPresent()) { this.container = player .get() .openInventory(this.inventory, Cause.of(NamedCause.source(player))) .orElse(null); // TODO check if not opened } } } }
@Listener public void onSpawnEntityEvent(SpawnEntityEvent event, @Root SpawnCause cause) { WorldSettings settings = WorldSettings.get(event.getTargetWorld()); if (!settings.isVanillaSpawnerAllowed() && cause.getType().equals(SpawnTypes.MOB_SPAWNER)) { return; } else if (!settings.isModSpawnerAllowed() && cause.getType().equals(SpawnTypes.CUSTOM)) { return; } else if (!settings.isPluginSpawnerAllowed() && cause.getType().equals(SpawnTypes.PLUGIN)) { return; } else if (!settings.isEggSpawnerAllowed() && cause.getType().equals(SpawnTypes.SPAWN_EGG)) { return; } for (Entity entity : event.getEntities()) { entity.offer(Sponge.getDataManager().getManipulatorBuilder(MoneyData.class).get().create()); } }
@Listener public void onChunkLoad(LoadChunkEvent event) { Chunk chunk = event.getTargetChunk(); UUID worldId = chunk.getWorld().getUniqueId(); Vector3i position = chunk.getPosition(); WorldFallbackContext context = worldContexts.get(worldId); if (context == null) { IllegalStateException exception = new IllegalStateException( "Failed to find the world context for the world " + chunk.getWorld().getName()); logger.error( "An error happened while loading the chunk " + chunk.getWorld().getName() + position, exception); Sponge.getServer().shutdown(); throw exception; } try { dataStorage .loadChunk(worldId, position) .ifPresent( claimedChunk -> { logger.info("Chunk loaded: " + chunk.getWorld().getName() + position); getChunkMap(worldId) .orElseThrow(IllegalStateException::new) .put(position, claimedChunk); }); } catch (DataStorageException e) { logger.error( "Failed to load chunk information on " + chunk.getWorld().getName() + position, e); getChunkMap(worldId) .orElseThrow(IllegalStateException::new) .put(position, new ClaimedChunk(context, position)); } }
@Override protected Optional<FireworkEffect> buildContent(DataView container) throws InvalidDataException { if (container.contains( DataQueries.FIREWORK_SHAPE, DataQueries.FIREWORK_COLORS, DataQueries.FIREWORK_FADE_COLORS, DataQueries.FIREWORK_FLICKERS, DataQueries.FIREWORK_TRAILS)) { final String fireworkShapeId = DataUtil.getData(container, DataQueries.FIREWORK_SHAPE, String.class); final Optional<FireworkShape> shapeOptional = Sponge.getRegistry().getType(FireworkShape.class, fireworkShapeId); if (!shapeOptional.isPresent()) { throw new InvalidDataException( "Could not find the FireworkShape for the provided id: " + fireworkShapeId); } final FireworkShape shape = shapeOptional.get(); final boolean trails = DataUtil.getData(container, DataQueries.FIREWORK_TRAILS, Boolean.class); final boolean flickers = DataUtil.getData(container, DataQueries.FIREWORK_FLICKERS, Boolean.class); final List<Color> colors = container.getSerializableList(DataQueries.FIREWORK_COLORS, Color.class).get(); final List<Color> fadeColors = container.getSerializableList(DataQueries.FIREWORK_FADE_COLORS, Color.class).get(); return Optional.of( FireworkEffect.builder() .colors(colors) .flicker(flickers) .fades(fadeColors) .trail(trails) .shape(shape) .build()); } return Optional.empty(); }
@Override public Set<Context> getActiveContexts() { time().onGetActiveContexts().startTimingIfSync(); try { int ticks; ActiveContextsHolder holder, newHolder; do { ticks = Sponge.getGame().getServer().getRunningTimeTicks(); holder = this.cachedContexts.get(); if (holder != null && ticks == holder.getUpdateTicks()) { return holder.getContexts(); } Set<Context> set = new HashSet<>(); for (ContextCalculator<Subject> calc : this.collection.getPlugin().getContextCalculators()) { calc.accumulateContexts(this, set); } newHolder = new ActiveContextsHolder(ticks, ImmutableSet.copyOf(set)); } while (!this.cachedContexts.compareAndSet(holder, newHolder)); return newHolder.getContexts(); } finally { time().onGetActiveContexts().stopTimingIfSync(); } }
public static void init() { channel = Sponge.getChannelRegistrar().createRawChannel(SpongeWorldEdit.inst(), CUI_PLUGIN_CHANNEL); channel.addListener(Platform.Type.SERVER, new CUIChannelHandler()); }
@Listener(order = Order.PRE) public void onDestructEntityEventDeathPlayer( DestructEntityEvent.Death event, @First EntityDamageSource damageSrc) { if (!(event.getTargetEntity() instanceof Player)) { return; } Player player = (Player) event.getTargetEntity(); WorldSettings settings = WorldSettings.get(player.getWorld()); DeathReason reason = DeathReason.GENERIC; Entity src = damageSrc.getSource(); if (src instanceof Player) { reason = DeathReason.PLAYER; } else if (src instanceof Projectile) { Projectile projectile = (Projectile) src; Optional<UUID> optionalUUID = projectile.getCreator(); if (!optionalUUID.isPresent()) { return; } Optional<Player> optionalPlayer = Sponge.getServer().getPlayer(optionalUUID.get()); if (optionalPlayer.isPresent()) { reason = DeathReason.PLAYER; } else { reason = DeathReason.PROJECTILE; } } else { DamageType cause = damageSrc.getType(); reason = DeathReason.valueOf(cause.getName().toUpperCase()); } Optional<EconomyService> optionalEconomy = Sponge.getServiceManager().provide(EconomyService.class); if (!optionalEconomy.isPresent()) { Main.instance().getLog().error("Economy plugin not found"); return; } EconomyService economy = optionalEconomy.get(); BigDecimal balance = economy .getOrCreateAccount(player.getUniqueId()) .get() .getBalance(WorldSettings.get(player.getWorld()).getCurrency()); PlayerWallet wallet = settings.getPlayerWallet(); BigDecimal amount = wallet.getAmount(reason, balance); WalletDropEvent walletDropEvent = new WalletDropEvent(amount, player); if (walletDropEvent.getAmount().compareTo(BigDecimal.ZERO) != 0 && (!Sponge.getEventManager().post(walletDropEvent))) { WalletDrop.depositOrWithdraw( player, walletDropEvent.getAmount().multiply(BigDecimal.valueOf(-1))); if (settings.isDropsEnabled()) { for (MoneyStack moneyStack : walletDropEvent.getMoneyStacks()) { moneyStack.drop(walletDropEvent.getLocation()); } } WalletDrop.sendDeathMessage( WorldSettings.get(player.getWorld()), player, walletDropEvent.getAmount()); } }
public void registerListener(EventListener eventListener) { Sponge.getGame().getEventManager().registerListeners(TowerOfBabel.instance, eventListener); }
/** * Get the loaded chunk at the given block coordinate position. * * @param bx The x coordinate * @param by The y coordinate * @param bz The z coordinate * @return The chunk, if available */ default Optional<Chunk> getChunkAtBlock(int bx, int by, int bz) { return getChunk(Sponge.getServer().getChunkLayout().forceToChunk(bx, by, bz)); }
@Override protected MapValue<K, V> getValueGetter() { return Sponge.getRegistry() .getValueFactory() .createMapValue((Key<MapValue<K, V>>) this.usedKey, this.getValue()); }
/** * Creates a new DeathmatchMinigame instance. * * @param arena the arena to be played. * @param teamA the players on team A. * @param teamB the players on team B. * @throws Exception If the match failed to register. */ public DeathmatchMinigame(UltimateGamesArena arena, List<Player> teamA, List<Player> teamB) throws Exception { this.teamA = teamA; this.teamB = teamB; this.arena = arena; Objective.Builder objectiveBuilder = Sponge.getRegistry().createBuilder(Objective.Builder.class); Text title = Text.of(TextColors.AQUA, "UltimateGames"); final Objective mainObjective = objectiveBuilder.name("<Arena>").criterion(Criteria.DUMMY).displayName(title).build(); Score teamAName = mainObjective.getOrCreateScore(Text.of(TextColors.BLUE, TextStyles.BOLD, "Team A")); teamAName.setScore(4); this.teamAScoreboardTeam = Team.builder() .name("TeamA") .displayName(Text.of("TeamA")) .prefix(Text.of(TextColors.BLUE)) .nameTagVisibility(Visibilities.ALL) .canSeeFriendlyInvisibles(true) .allowFriendlyFire(false) .members(Sets.newHashSet(Text.of(TextColors.BLUE, TextStyles.BOLD, "Team A"))) .build(); Score teamAScore = mainObjective.getOrCreateScore(Text.of(TextColors.BLUE, "Kills: ")); teamAScore.setScore(3); Team teamAScoreTeam = Team.builder() .name("TeamAScore") .displayName(Text.of("TeamAScore")) .members(Sets.newHashSet(Text.of(TextColors.BLUE, "Kills: "))) .build(); Score teamBName = mainObjective.getOrCreateScore(Text.of(TextColors.RED, TextStyles.BOLD, "Team B")); teamBName.setScore(2); this.teamBScoreboardTeam = Team.builder() .name("TeamB") .displayName(Text.of("TeamB")) .prefix(Text.of(TextColors.RED)) .nameTagVisibility(Visibilities.ALL) .canSeeFriendlyInvisibles(true) .allowFriendlyFire(false) .members(Sets.newHashSet(Text.of(TextColors.RED, TextStyles.BOLD, "Team B"))) .build(); Score teamBScore = mainObjective.getOrCreateScore(Text.of(TextColors.RED, "Kills: ")); teamBScore.setScore(1); Team teamBScoreTeam = Team.builder() .name("TeamBScore") .displayName(Text.of("TeamBScore")) .members(Sets.newHashSet(Text.of(TextColors.RED, "Kills: "))) .build(); List<Objective> objectives = new ArrayList<Objective>(); objectives.add(mainObjective); scoreboard = Scoreboard.builder().objectives(objectives).build(); scoreboard.registerTeam(this.teamAScoreboardTeam); scoreboard.registerTeam(teamAScoreTeam); scoreboard.registerTeam(this.teamBScoreboardTeam); scoreboard.registerTeam(teamBScoreTeam); scoreboard.updateDisplaySlot(mainObjective, DisplaySlots.SIDEBAR); Scheduler scheduler = Sponge.getScheduler(); scheduler .createTaskBuilder() .execute( () -> { try { teamAScoreTeam.setSuffix(Text.of(TextColors.GRAY, teamAPoints)); teamBScoreTeam.setSuffix(Text.of(TextColors.GRAY, teamBPoints)); } catch (Exception e) { e.printStackTrace(); } }) .interval(1, TimeUnit.MILLISECONDS) .name("UltimateGames - Update scoreboard") .submit( Sponge.getPluginManager() .getPlugin("io.github.hsyyid.ultimategames") .get() .getInstance() .get()); Ember.register(arena, this); }
@Listener public void onStart(MinigameStartedEvent event) { if (event.getMinigame().equals(this)) { for (Player player : players()) { player.sendMessage( Text.of( TextColors.BLUE, "[UltimateGames]: ", TextColors.GREEN, "Deathmatch starting...")); } for (Player player : this.teamA) { player.offer(Keys.GAME_MODE, GameModes.SURVIVAL); player.setScoreboard(scoreboard); this.teamAScoreboardTeam.addMember(player.getTeamRepresentation()); if (this.arena.getTeamALoadout() != null) UltimateGames.game .getCommandManager() .process( Sponge.getServer().getConsole(), "kit " + this.arena.getTeamALoadout() + " " + player.getName()); if (player .getWorld() .getUniqueId() .equals(this.arena.getTeamASpawn().getLocation().getExtent().getUniqueId())) { player.setLocation(this.arena.getTeamASpawn().getLocation()); } else { player.transferToWorld( this.arena.getTeamASpawn().getLocation().getExtent().getUniqueId(), this.arena.getTeamASpawn().getLocation().getPosition()); } player.sendMessage( Text.of(TextColors.BLUE, "[UltimateGames]: ", TextColors.GOLD, "May the games begin!")); } for (Player player : this.teamB) { player.offer(Keys.GAME_MODE, GameModes.SURVIVAL); player.setScoreboard(scoreboard); this.teamBScoreboardTeam.addMember(player.getTeamRepresentation()); if (this.arena.getTeamBLoadout() != null) UltimateGames.game .getCommandManager() .process( Sponge.getServer().getConsole(), "kit " + this.arena.getTeamBLoadout() + " " + player.getName()); if (player .getWorld() .getUniqueId() .equals(this.arena.getTeamBSpawn().getLocation().getExtent().getUniqueId())) { player.setLocation(this.arena.getTeamBSpawn().getLocation()); } else { player.transferToWorld( this.arena.getTeamBSpawn().getLocation().getExtent().getUniqueId(), this.arena.getTeamBSpawn().getLocation().getPosition()); } player.sendMessage( Text.of(TextColors.BLUE, "[UltimateGames]: ", TextColors.GOLD, "May the games begin!")); } Scheduler scheduler = UltimateGames.game.getScheduler(); Task.Builder taskBuilder = scheduler.createTaskBuilder(); taskBuilder .execute( () -> { try { Ember.unregister(this.arena); } catch (Exception e) { System.out.println( "[UltimateGames]: Error when ending deathmatch in arena " + arena.getName()); } }) .delay(this.arena.getLength(), TimeUnit.MINUTES) .name("UltimateGames - End Deathmatch") .submit( UltimateGames.game .getPluginManager() .getPlugin("io.github.hsyyid.ultimategames") .get() .getInstance() .get()); } }
@Listener public void onSendCommandEvent(SendCommandEvent event, @First CommandSource src) { String command = event.getCommand(); if (!command.equalsIgnoreCase("say")) { return; } if (Sponge.getPluginManager().isLoaded("simplechat")) { return; } String message = event.getArguments(); if (message == null || message.equals("")) { return; } MutableMessageChannel channel = MessageChannel.TO_ALL.asMutable(); if (message.startsWith("@")) { channel = MessageChannel.TO_NONE.asMutable(); String selector = message.substring(0, message.indexOf(" ")); for (Entity entity : Selector.parse(selector).resolve(src)) { if (entity instanceof Player) { channel.addMember((MessageReceiver) entity); } } if (channel.getMembers().size() == 0) { src.sendMessage(Text.of(TextColors.RED, "Selector returned no players")); return; } channel.addMember(Sponge.getServer().getConsole()); message = message.replace(selector, ""); } Text text = TextSerializers.FORMATTING_CODE.deserialize(message); if (src instanceof Player) { Player player = (Player) src; Optional<PlayerTag> optionalPlayerTag = PlayerTag.get(player); if (optionalPlayerTag.isPresent()) { text = Text.join(optionalPlayerTag.get().getTag(), Text.of(" "), text); } else { text = Text.join(PlayerTag.getDefault(player), Text.of(" "), text); } } else { Optional<SingleTag> optionalTag = SingleTag.get("simpletags", "console"); if (optionalTag.isPresent()) { text = Text.join(optionalTag.get().getTag(), Text.of(" "), text); } } channel.send(text); event.setCancelled(true); }
static Builder builder() { return Sponge.getRegistry().createBuilder(Builder.class); }
@Listener public void onGameInit(GameInitializationEvent event) { ConfigurationOptions options = ConfigurationOptions.defaults().setShouldCopyDefaults(true); try { HoconConfigurationLoader defaultConfigLoader = HoconConfigurationLoader.builder() .setPath(configDir.resolve("default-permissions.conf")) .build(); CommentedConfigurationNode defaultPermissions = defaultConfigLoader.load(options); CommentedConfigurationNode fallback = defaultPermissions.getNode("fallback"); fallback.setComment( "Defines the fallback values for permission flags that are not defined on any context of a protected terrain."); CommentedConfigurationNode wild = defaultPermissions.getNode("default-world-permissions"); wild.setComment( "The default permissions for new worlds/dimensions that affects unclaimed chunks"); loadWorldConfig(null, wild, true); loadWorldConfig(null, fallback, false); try { defaultConfigLoader.save(defaultPermissions); } catch (IOException e) { logger.error("Failed to save the default-permissions.config file", e); } } catch (IOException e) { logger.error("Failed to load the default-permissions.config file", e); Sponge.getServer().shutdown(); } try { CommentedConfigurationNode mainConfig = mainConfigLoader.load(options); mainConfig.setComment("This configuration defines the fundamental settings from MyChunks"); CommentedConfigurationNode dataStorageNode = mainConfig.getNode("data-storage"); CommentedConfigurationNode engineNode = dataStorageNode.getNode("engine"); engineNode.setComment("The storage engine can only be \"binary\" currently"); CommentedConfigurationNode binaryNode = dataStorageNode.getNode("binary"); binaryNode.setComment("Configurations used by the binary engine."); CommentedConfigurationNode node = binaryNode.getNode("save-dir"); node.setComment("The directory where the binary data will be saved. It must be writable"); String binarySaveDir = node.getString(configDir.resolve("data").resolve("binary").toString()); String engine = engineNode.getString("binary"); if ("binary".equalsIgnoreCase(engine.trim())) dataStorage = new BinaryDataStorage(Paths.get(binarySaveDir).toFile()); else throw new IllegalArgumentException("The storage engine '" + engine + "' is not supported"); try { mainConfigLoader.save(mainConfig); } catch (IOException e) { logger.error("Failed to save the main config file", e); } } catch (Exception e) { logger.error("Failed to load the main config file", e); Sponge.getServer().shutdown(); } }
@Listener public void onServerInit(GameInitializationEvent event) { getLogger().info("CommandSigns loading..."); HashMap<List<String>, CommandSpec> subcommands = new HashMap<List<String>, CommandSpec>(); subcommands.put( Arrays.asList("setcommandsign"), CommandSpec.builder() .description(Text.of("Creates CommandSigns")) .permission("commandsigns.setcommandsign") .arguments( GenericArguments.seq( GenericArguments.onlyOne(GenericArguments.bool(Text.of("one time"))), GenericArguments.onlyOne( GenericArguments.remainingJoinedStrings(Text.of("command"))))) .executor(new SetCommandSignExecutor()) .build()); subcommands.put( Arrays.asList("addcommand"), CommandSpec.builder() .description(Text.of("Adds Command to CommandSign")) .permission("commandsigns.addcommand") .arguments( GenericArguments.onlyOne( GenericArguments.remainingJoinedStrings(Text.of("command")))) .executor(new AddCommandExecutor()) .build()); subcommands.put( Arrays.asList("removecommand"), CommandSpec.builder() .description(Text.of("Removes Command on CommandSign")) .permission("commandsigns.removecommand") .arguments( GenericArguments.onlyOne(GenericArguments.integer(Text.of("command number")))) .executor(new RemoveCommandExecutor()) .build()); subcommands.put( Arrays.asList("listcommands"), CommandSpec.builder() .description(Text.of("List Commands on CommandSign")) .permission("commandsigns.listcommands") .executor(new ListCommandsExecutor()) .build()); CommandSpec commandSignsCommandSpec = CommandSpec.builder() .description(Text.of("CommandSigns Command")) .permission("commandsigns.command") .executor(new CommandSignsExecutor()) .children(subcommands) .build(); Sponge.getCommandManager() .register(this, commandSignsCommandSpec, "cs", "commandsign", "commandsigns"); // One-Time Sponge.getDataManager() .register(IsOneTimeData.class, ImmutableIsOneTimeData.class, new IsOneTimeDataBuilder()); Sponge.getDataManager() .register( SpongeIsOneTimeData.class, ImmutableSpongeIsOneTimeData.class, new IsOneTimeDataBuilder()); // IsCommandSign Sponge.getDataManager() .register( IsCommandSignData.class, ImmutableIsCommandSignData.class, new IsCommandSignDataBuilder()); Sponge.getDataManager() .register( SpongeIsCommandSignData.class, ImmutableSpongeIsCommandSignData.class, new IsCommandSignDataBuilder()); // Commands Sponge.getDataManager() .register(CommandsData.class, ImmutableCommandsData.class, new CommandsDataBuilder()); Sponge.getDataManager() .register( SpongeCommandsData.class, ImmutableSpongeCommandsData.class, new CommandsDataBuilder()); // Users Sponge.getDataManager() .register(UsersData.class, ImmutableUsersData.class, new UsersDataBuilder()); Sponge.getDataManager() .register(SpongeUsersData.class, ImmutableSpongeUsersData.class, new UsersDataBuilder()); Sponge.getEventManager().registerListeners(this, new HitBlockListener()); Sponge.getEventManager().registerListeners(this, new InteractBlockListener()); getLogger().info("-----------------------------"); getLogger().info("CommandSigns was made by HassanS6000!"); getLogger().info("Please post all errors on the Sponge Thread or on GitHub!"); getLogger().info("Have fun, and enjoy! :D"); getLogger().info("-----------------------------"); getLogger().info("CommandSigns loaded!"); }