mcipc.rcon.je.commands package

Submodules

mcipc.rcon.je.commands.advancement module

Implementation of the advancement command.

class mcipc.rcon.je.commands.advancement.AdvancementProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for advancements-related commands.

grant(targets: str) → AdvancementSubProxy

Delegates to a mcipc.rcon.je.commands.advancement.AdvancementSubProxy

revoke(targets: str) → AdvancementSubProxy

Delegates to a mcipc.rcon.je.commands.advancement.AdvancementSubProxy

class mcipc.rcon.je.commands.advancement.AdvancementSubProxy(client: Client, *args: str)

Bases: CommandProxy

Sub-proxy for advancement-related commands.

everything() → str

Grants or revokes everyting.

from_(advancement: str) → str

Grants or revokes from the given advancement.

only(advancement: str, criterion: str | None = None) → str

Only grants or revokes the given advancement.

through(advancement: str) → str

Grants or revokes through the given advancement.

until(advancement: str) → str

Grants or revokes until the given advancement.

mcipc.rcon.je.commands.advancement.advancement(self: Client) → AdvancementProxy

Delegates to a mcipc.rcon.je.commands.advancement.AdvancementProxy

mcipc.rcon.je.commands.attribute module

Implementation of the attribute command.

class mcipc.rcon.je.commands.attribute.AttributeProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for attribute actions.

property base: BaseProxy

Delegates to a mcipc.rcon.je.commands.attribute.BaseProxy

get(scale: float | None = None) → str

Returns the total value of the specified attribute.

property modifier: ModifierProxy

Delegates to a mcipc.rcon.je.commands.attribute.ModifierProxy

class mcipc.rcon.je.commands.attribute.BaseProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy to modify bases.

get(scale: float | None = None) → str

Returns the base value of the specified attribute.

set(value: str) → str

Overwrites the base value of the specified attribute with the given value.

class mcipc.rcon.je.commands.attribute.ModifierProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy to modify attributes.

add(uuid: str, name: str, value: str, action: Action | str) → str

Adds an attribute modifier with the specified properties if no modifier with the same UUID already existed.

remove(uuid: str) → str

Removes the attribute modifier with the specified UUID.

property value: ValueProxy

Delegates to a mcipc.rcon.je.commands.attribute.ValueProxy

class mcipc.rcon.je.commands.attribute.ValueProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for attribute value getter.

get(uuid: str, scale: float | None = None) → str

Returns the value of the modifier with the specified UUID.

mcipc.rcon.je.commands.attribute.attribute(self: Client, target: str, attribute: str) → AttributeProxy

Delegates to a mcipc.rcon.je.commands.attribute.AttributeProxy

mcipc.rcon.je.commands.ban module

Banning, pardoning and kicking of players or IP addresses.

mcipc.rcon.je.commands.ban.ban(self: Client, player: str, *reasons: str) → str

Adds a player to then ban list.

mcipc.rcon.je.commands.ban.ban_ip(self: Client, target: IPv4Address | IPv6Address | str, *reasons: str) → str

Adds an IP address to the ban list.

mcipc.rcon.je.commands.ban.banlist(self: Client, *ips_or_players: IPv4Address | IPv6Address | str) → str

Displays the server’s ban list.

mcipc.rcon.je.commands.ban.pardon(self: Client, target: str) → str

Removes entries from the ban list.

mcipc.rcon.je.commands.bossbar module

Implementation of the bossbar command.

class mcipc.rcon.je.commands.bossbar.BossbarProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for boss bar methods.

add(id: str, name: dict) → str

Create a new boss bar.

get(id: str, attribute: Attribute | str) → str

Return the requested setting as a result of the command.

list() → str

Display a list of existing boss bars.

remove(id: str) → str

Remove an existing bossbar.

set(id: str, attribute: Attribute | str) → BossbarSetProxy

Delegates to a mcipc.rcon.je.commands.bossbar.BossbarSetProxy

class mcipc.rcon.je.commands.bossbar.BossbarSetProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy to handle boss bar set commands.

color(color: Color | str) → str

Set the text color (if no color was specified as part of a text component) and bar color. Defaults to white upon creation.

max(max: int) → str

Set the boss bar’s maximum value. Defaults to 100 upon creation.

name(name: str) → str

Set the boss bar’s name.

players(*targets: str) → str

Change the set of players to whom the bar is visible. Defaults to none upon creation.

style(style: Style | str) → str

Set the boss bar’s visual amount of segments. Defaults to progress upon creation.

value(value: int) → str

Set the boss bar’s current value. Defaults to 0 upon creation.

visible(visible: bool) → str

Set the boss bar’s visibility. Defaults to true upon creation.

mcipc.rcon.je.commands.bossbar.bossbar(self: Client) → BossbarProxy

Delegates to a mcipc.rcon.je.commands.bossbar.BossbarProxy

mcipc.rcon.je.commands.clear module

Implementation of the clear command.

mcipc.rcon.je.commands.clear.clear(self: Client, targets: str | None = None, item: str | None = None, max_count: int | None = None) → str

Clears items from player inventory, including items being dragged by the player. Java Edition implementation.

mcipc.rcon.je.commands.clone module

Implementation of the clone command.

mcipc.rcon.je.commands.clone.clone(self: Client, begin: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, end: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, destination: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, *, mask_mode: MaskMode | str | None = None, filter: str | None = None, clone_mode: CloneMode | str | None = None) → str

Clones blocks from one region to another.

mcipc.rcon.je.commands.data module

Implementation of the data command.

class mcipc.rcon.je.commands.data.DataModifyProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for data modification.

property append: DataModifySubProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifySubProxy

insert(index: int) → DataModifySubProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifySubProxy

property merge: DataModifySubProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifySubProxy

property prepend: DataModifySubProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifySubProxy

property set: DataModifySubProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifySubProxy

class mcipc.rcon.je.commands.data.DataModifySubProxy(client: Client, *args: str)

Bases: CommandProxy

Sub-proxy for the modify method.

from_(*, block: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, entity: Item | NBT | TargetSelector | str | None = None, storage: str | None = None, path: str) → str

Appends data.

value(value: str) → str

Sets data value.

class mcipc.rcon.je.commands.data.DataProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for data sub-commands.

get(*, block: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, entity: Item | NBT | TargetSelector | str | None = None, storage: str | None = None, path: str | None = None, scale: float | None = None) → str

Read off the entire NBT data or the subsection of the NBT data from the targeted block position or entity to the executor with syntax highlighting, scaled by <scale> if specified.

merge(*, block: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, entity: Item | NBT | TargetSelector | str | None = None, storage: str | None = None, nbt: dict) → str

Merge the NBT data from the sourced block position or entity with the specified <nbt> data.

modify(*, block: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, entity: Item | NBT | TargetSelector | str | None = None, storage: str | None = None, path: str) → DataModifyProxy

Delegates to a mcipc.rcon.je.commands.data.DataModifyProxy

remove(*, block: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, entity: Item | NBT | TargetSelector | str | None = None, storage: str | None = None, path: str) → str

Removes NBT data at <path> from the targeted block position or entity. Player NBT data cannot be removed.

mcipc.rcon.je.commands.data.data(self: Client) → DataProxy

Delegates to a mcipc.rcon.je.commands.data.DataProxy

mcipc.rcon.je.commands.datapack module

Implementation of the datapack command.

class mcipc.rcon.je.commands.datapack.DatapackProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for datapack related commands.

disable(name: str) → str

Disables a datapack.

enable(name: str, mode: DatapackMode | str, existing: str | None = None) → str

Enables a datapack.

list(state: DatapackState | str | None = None) → str

Lists the enabled datapacks.

mcipc.rcon.je.commands.datapack.datapack(self: Client) → DatapackProxy

Delegates to a mcipc.rcon.je.commands.datapack.DatapackProxy

mcipc.rcon.je.commands.debug module

Implementation of the debug command.

mcipc.rcon.je.commands.debug.debug(self: Client, command: DebugCommand | str) → str

Invokes the debug command.

mcipc.rcon.je.commands.defaultgamemode module

Implementation of the defaultgamemode command.

mcipc.rcon.je.commands.defaultgamemode.defaultgamemode(self: Client, mode: GameMode | str) → str

Sets the default game mode.

mcipc.rcon.je.commands.difficulty module

Implementation of the difficulty command.

mcipc.rcon.je.commands.difficulty.difficulty(self: Client, difficulty: Difficulty | str) → bool

Sets the difficulty.

mcipc.rcon.je.commands.effect module

Implementation of the effect command.

class mcipc.rcon.je.commands.effect.EffectProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for effect commands on the Java Edition.

clear(targets: str | None = None, effect: str | None = None) → str

Clears effects.

give(targets: str, effect: str, seconds: int | None = None, amplifier: int | None = None, hide_particles: bool | None = None) → str

Gives an effect.

mcipc.rcon.je.commands.effect.effect(self: Client) → EffectProxy

Delegates to a mcipc.rcon.je.commands.effect.EffectProxy

mcipc.rcon.je.commands.enchant module

Implementation of the enchant command.

mcipc.rcon.je.commands.enchant.enchant(self: Client, target: str, enchantment: Enchantment | str, level: int | None = None) → str

Enchants the target.

mcipc.rcon.je.commands.experience module

Implementation of the experience and xp commands.

class mcipc.rcon.je.commands.experience.ExperienceProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for Experience commands.

add(targets: str, amount: int, unit: XPUnit | str | None = None) → str

Gives the target the specified amount of XP units.

query(targets: str, amount: int, unit: XPUnit | str) → str

Queries the amount in given unit of XP of the targets.

set(targets: str, amount: int, unit: XPUnit | str | None = None) → str

Sets the XP of the target to the specified amount and units.

mcipc.rcon.je.commands.experience.experience(self: Client) → ExperienceProxy

Delegates to a mcipc.rcon.je.commands.experience.ExperienceProxy

mcipc.rcon.je.commands.experience.xp(self: Client) → ExperienceProxy

Delegates to a mcipc.rcon.je.commands.experience.ExperienceProxy

mcipc.rcon.je.commands.fill module

Implementation of the fill command.

mcipc.rcon.je.commands.fill.fill(self: Client, from_: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, to: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, block: str, mode: FillMode | str | None = None, filter: str | None = None) → str

Fills all or parts of a region with a specific block.

mcipc.rcon.je.commands.forceload module

Implementation of the forceload command.

class mcipc.rcon.je.commands.forceload.ForceloadProxy(client: Client, *args: str)

Bases: CommandProxy

Provides forceload-related sub commands.

add(from_: tuple[Union[int, str, float], Union[int, str, float]] | str, to: tuple[Union[int, str, float], Union[int, str, float]] | str | None = None) → str

Forces the chunk at the <from> position (through to <to> if set) in the dimension of the command’s execution to be loaded constantly.

query(pos: tuple[Union[int, str, float], Union[int, str, float]] | str | None = None) → str

If chunk coordinates are given, displays the specified chunk in the dimension of the command’s execution is force loaded; otherwise, lists which chunks in the dimension of the command’s execution are force loaded.

remove(from_or_all: tuple[Union[int, str, float], Union[int, str, float]] | str | all, to: tuple[Union[int, str, float], Union[int, str, float]] | str | None = None) → str

Unforces the chunk at the <from> position (through to <to> if set) in the dimension of the command’s execution to be loaded constantly.

mcipc.rcon.je.commands.forceload.forceload(self: Client) → ForceloadProxy

Delegates to a mcipc.rcon.je.commands.forceload.ForceloadProxy

mcipc.rcon.je.commands.gamemode module

Implementation of the gamemode command.

mcipc.rcon.je.commands.gamemode.gamemode(self: Client, mode: GameMode | str, target: str | None = None) → str

Sets the game mode.

mcipc.rcon.je.commands.give module

Implementation of the give command.

mcipc.rcon.je.commands.give.give(self: Client, target: str, item: str, count: int | None = None) → str

Gives an item to one or more players.

mcipc.rcon.je.commands.help module

Implementation of the help command.

mcipc.rcon.je.commands.help.help(client: Client, command: str | None = None) → dict

Returns help about commands.

mcipc.rcon.je.commands.item module

Implementation of the item command.

class mcipc.rcon.je.commands.item.CopyProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for item copy commands.

block(pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, slot: str, modifier: str | None = None) → str

Copies a block.

entity(targets: str, slot: str, modifier: str | None = None) → str

Copies an entity.

class mcipc.rcon.je.commands.item.ItemProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for item-related commands.

block(pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, slot: str) → ItemSubProxy

Delegates to a mcipc.rcon.je.commands.item.ItemSubProxy

entity(targets: str, slot: str) → ItemSubProxy

Delegates to a mcipc.rcon.je.commands.item.ItemSubProxy

class mcipc.rcon.je.commands.item.ItemSubProxy(client: Client, *args: str)

Bases: CommandProxy

Sub-proxy for block and entity related commands.

property copy: CopyProxy

Delegates to a mcipc.rcon.je.commands.item.CopyProxy

modify(modifier: str) → str

Modifies the item.

replace(item: str, count: int | None = None) → str

Replaces an item.

mcipc.rcon.je.commands.item.item(self: Client) → ItemProxy

Delegates to a mcipc.rcon.je.commands.item.ItemProxy

mcipc.rcon.je.commands.list module

Implementation of the list command.

mcipc.rcon.je.commands.list.list(client: Client, uuids: bool = False) → Players

Returns the players.

mcipc.rcon.je.commands.locate module

Implementation of the locate command.

mcipc.rcon.je.commands.locate.locate(client: Client, structure: Structure | str) → Location

Locates the respective structure.

mcipc.rcon.je.commands.locatebiome module

Implementation of the locatebiome command.

mcipc.rcon.je.commands.locatebiome.locatebiome(self: Client, biome: Biome | str) → Location

Locates the given biome.

mcipc.rcon.je.commands.loot module

Implementation of loot command.

class mcipc.rcon.je.commands.loot.LootProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for target-related commands.

give(players: str) → SourceProxy

Delegates to a mcipc.rcon.je.commands.loot.SourceProxy

insert(target_pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str) → SourceProxy

Delegates to a mcipc.rcon.je.commands.loot.SourceProxy

property replace: ReplaceProxy

Delegates to a mcipc.rcon.je.commands.loot.ReplaceProxy

spawn(target_pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str) → SourceProxy

Delegates to a mcipc.rcon.je.commands.loot.SourceProxy

class mcipc.rcon.je.commands.loot.ReplaceProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for replace commands.

block(target_pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, slot: str, count: int | None = None) → SourceProxy

Delegates to a mcipc.rcon.je.commands.loot.SourceProxy

entity(entities: str, slot: str, count: int | None = None) → SourceProxy

Delegates to a mcipc.rcon.je.commands.loot.SourceProxy

class mcipc.rcon.je.commands.loot.SourceProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for source commands.

fish(loot_table: str, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, tool_or_hand: Hand | str | None = None) → str

Runs the command with the fish source.

kill(target: str) → str

Runs the command with a killed target as source.

loot(loot_table: str) → str

Runs the command with a loot source.

mine(pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, tool_or_hand: Hand | str | None = None) → str

Runs the command with a mined resource as source.

mcipc.rcon.je.commands.loot.loot(self: Client) → LootProxy

Delegates to a mcipc.rcon.je.commands.loot.LootProxy

mcipc.rcon.je.commands.particle module

Implementation of the particle command.

mcipc.rcon.je.commands.particle.particle(self: Client, name: str, speed: float, count: int, parameters: str | None = None, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, delta: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, mode: ParticleMode | str | None = None, viewers: str | None = None) → str

Creates the respective particles.

mcipc.rcon.je.commands.playsound module

Implementation of the playsound command.

mcipc.rcon.je.commands.playsound.playsound(self: Client, sound: str, source: SoundSource | str, targets: str, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, volume: float | None = None, pitch: float | None = None, min_volume: float | None = None) → str

Plays a sound.

mcipc.rcon.je.commands.publish module

Implementation of the publish command.

mcipc.rcon.je.commands.publish.publish(self: Client, port: int | None = None) → str

Opens singleplayer world to the local network.

mcipc.rcon.je.commands.recipe module

Implementation of the recipe command.

class mcipc.rcon.je.commands.recipe.RecipeProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for recipe related commands.

give(targets: str, recipe: str = '*') → str

Gives or takes all recipes from that player.

take(targets: str, recipe: str = '*') → str

Gives or takes a specified recipe from that player.

mcipc.rcon.je.commands.recipe.recipe(self: Client) → RecipeProxy

Delegates to a mcipc.rcon.je.commands.recipe.RecipeProxy

mcipc.rcon.je.commands.replaceitem module

Implementation of the replaceitem command.

class mcipc.rcon.je.commands.replaceitem.ReplaceitemProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for replaceitem related commands.

block(pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, slot: str, item: str, count: int | None = None) → str

Replaces a block.

entity(targets: str, slot: str, item: str, count: int | None = None) → str

Replaces an entity.

mcipc.rcon.je.commands.replaceitem.replaceitem(self: Client) → ReplaceitemProxy

Delegates to a mcipc.rcon.je.commands.replaceitem.ReplaceitemProxy

mcipc.rcon.je.commands.save module

Implementation of the save-* commands.

mcipc.rcon.je.commands.save.save_all(self: Client, flush: bool = False) → str

Saves the server to the data storage device.

mcipc.rcon.je.commands.save.save_off(self: Client) → str

Disables the server writing to the world files.

mcipc.rcon.je.commands.save.save_on(self: Client) → str

Enables the server writing to the world files.

mcipc.rcon.je.commands.schedule module

Implementation of the schedule command.

class mcipc.rcon.je.commands.schedule.ScheduleProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for schedule sub-commands.

clear(function: str) → str

Removes a schedule.

function(function: str, time: str | int | float, mode: ScheduleMode | str | None = None) → str

Adds a schedule.

mcipc.rcon.je.commands.schedule.schedule(self: Client) → ScheduleProxy

Delegates to a mcipc.rcon.je.commands.schedule.ScheduleProxy

mcipc.rcon.je.commands.scoreboard module

Implementation of the scoreboard command.

class mcipc.rcon.je.commands.scoreboard.ModifyProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for modify commands.

displayname(objective: str, display_name: str) → str

Modifies the display name of the objective.

rendertype(objective: str, render_type: RenderType | str)

Modifies the render type of the objective.

class mcipc.rcon.je.commands.scoreboard.ObjectivesProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for objectives sub commands.

add(objective: str, criterion: str, display_name: str | None = None) → str

Adds an objective to the scoreboard.

list() → str

Lists objectives on the scoreboard.

modify(objective: str) → ModifyProxy

Delegates to a mcipc.rcon.je.commands.scoreboard.ModifyProxy

remove(objective: str) → str

Removes an objective from the scoreboard.

setdisplay(slot: str, objective: str | None = None) → str

Sets the display slot of an objective.

class mcipc.rcon.je.commands.scoreboard.PlayersProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for player commands.

add(targets: str, objective: str, score: int) → str

Adds score for an objective for a player.

enable(targets: str, objective: str) → str

Enables an objective for the given targets.

get(target: str, objective: str) → str

Gets a player’s objective.

list(target: str | None = None) → str

Lists scoreboard of an optional player.

operation(targets: str, target_objective: str, operation: str, source: str, source_objective: str) → str

Applies an arithmetic operation altering the target’s/targets’ score(s) in the target objective, using source target’s/targets’ score(s) in the source objective as input.

remove(targets: str, objective: str, score: int) → str

Decrements the target’s/targets’ score(s) in that objective by the given amount.

reset(targets: str, objective: str | None = None) → str

Resets a player’s score.

set(targets: str, objective: str, score: int) → str

Sets a player’s score.

class mcipc.rcon.je.commands.scoreboard.ScoreboardProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for scoreboard sub commands.

property objectives: ObjectivesProxy

Delegates to a mcipc.rcon.je.commands.scoreboard.ObjectivesProxy

property players: PlayersProxy

Delegates to a mcipc.rcon.je.commands.scoreboard.PlayersProxy

mcipc.rcon.je.commands.scoreboard.scoreboard(self: Client) → ScoreboardProxy

Delegates to a mcipc.rcon.je.commands.scoreboard.ScoreboardProxy

mcipc.rcon.je.commands.seed module

Implementation of the seed command.

mcipc.rcon.je.commands.seed.seed(self: Client) → int

Returns the server seed.

mcipc.rcon.je.commands.setblock module

Implementation of the setblock command.

mcipc.rcon.je.commands.setblock.setblock(self: Client, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, block: str, mode: SetblockMode | str | None = None) → str

Sets a block.

mcipc.rcon.je.commands.setidletimeout module

Implementation of the setidletimeout command.

mcipc.rcon.je.commands.setidletimeout.setidletimeout(self: Client, minutes: int) → str

Sets the time before idle players are kicked from the server.

mcipc.rcon.je.commands.setworldspawn module

Implementation of the setworldspawn command.

mcipc.rcon.je.commands.setworldspawn.setworldspawn(self: Client, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, angle: float | None = None) → str

Sets the world spawn.

mcipc.rcon.je.commands.spawnpoint module

Implementation of the spawnpoint command.

mcipc.rcon.je.commands.spawnpoint.spawnpoint(self: Client, targets: str | None = None, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, angle: float | None = None) → str

Sets the spawn point for a player.

mcipc.rcon.je.commands.spectate module

Implementation of the spectate command.

mcipc.rcon.je.commands.spectate.spectate(self: Client, target: str | None = None, player: str | None = None) → str

Start or stop spectating.

mcipc.rcon.je.commands.spreadplayers module

Implementation of the spreadplayers command.

mcipc.rcon.je.commands.spreadplayers.spreadplayers(self: Client, center: tuple[Union[int, str, float], Union[int, str, float]] | str, spread_distance: float, max_range: float, respec_teams: bool, targets: str, *, max_height: int | None = None) → str

Spreads players to resulting position under the maximum height.

mcipc.rcon.je.commands.stop module

Implementation of the stop command.

mcipc.rcon.je.commands.stop.stop(self: Client) → str

Stops the server.

mcipc.rcon.je.commands.stopsound module

Implementation of the stopsound command.

mcipc.rcon.je.commands.stopsound.stopsound(self: Client, targets: str, source: SoundSource | str | None = None, sound: str | None = None) → str

Stops a sound.

mcipc.rcon.je.commands.summon module

Implementation of the summon command.

mcipc.rcon.je.commands.summon.summon(self: Client, entity: str, pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, nbt: dict | None = None) → str

Summons an entity.

mcipc.rcon.je.commands.team module

Implementation of the team command.

class mcipc.rcon.je.commands.team.TeamProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for team commands.

add(team: str, display_name: dict | None = None) → str

Adds a team.

empty(team: str) → str

Emties a team.

join(team: str, members: str | None = None) → str

Joins a team.

leave(members: str | None = None) → str

Leaves the team.

list(team: str | None = None) → str

Lists team members.

modify(team: str, option: TeamOption | str, value: CollisionRule | str | Color | Visibility | dict | bool) → str

Modifies a team.

remove(team: str) → str

Removes the given team.

mcipc.rcon.je.commands.team.team(self: Client) → TeamProxy

Delegates to a mcipc.rcon.je.commands.team.TeamProxy

mcipc.rcon.je.commands.teammsg module

Implementation of the teammsg and tm commands.

mcipc.rcon.je.commands.teammsg.teammsg(self: Client, message: str) → str

Sends a team message.

mcipc.rcon.je.commands.teammsg.tm(self: Client, message: str) → str

Sends a team message.

mcipc.rcon.je.commands.teleport module

Implementation of the teleport command.

mcipc.rcon.je.commands.teleport.teleport(self: Client, *, destination: str | None = None, location: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, targets: str | None = None, rotation: tuple[Union[int, str], Union[int, str]] | str | None = None, facing_location: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, facing_entity: str | None = None, facing_anchor: Anchor | str | None = None) → str

Teleports the player.

mcipc.rcon.je.commands.time module

Implementation of the time command.

class mcipc.rcon.je.commands.time.TimeProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for time commands.

add(time: str | int | float) → str

Adds time.

query(time_type: TimeType | str) → str

Queries the given time type.

set(time: TimeSpec | str | int | float) → str

Sets the time to the given amount.

mcipc.rcon.je.commands.time.time(self: Client) → TimeProxy

Delegates to a mcipc.rcon.je.commands.time.TimeProxy

mcipc.rcon.je.commands.title module

Implementation of the title comman.

class mcipc.rcon.je.commands.title.TitleProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for title commands.

actionbar(title: str) → str

Sets the action bar.

clear() → str

Clears the title.

reset() → str

Resets the title.

subtitle(title: str) → str

Sets the subtitle.

times(fade_in: int, stay: int, fade_out: int) → str

Changes the fade-in, stay, and fade-out times of all current and future screen titles for the specified player(s).

title(title: str) → str

Sets the title.

mcipc.rcon.je.commands.title.title(self: Client, targets: str) → TitleProxy

Delegates to a mcipc.rcon.je.commands.title.TitleProxy

mcipc.rcon.je.commands.trigger module

Implementation of the trigger command.

class mcipc.rcon.je.commands.trigger.TriggerProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for trigger commands.

add(objective: str, value: int) → str

Adds <value> to the current value of <objective>.

set(objective: str, value: int) → str

Sets the value of <objective> to <value>.

mcipc.rcon.je.commands.trigger.trigger(self: Client) → TriggerProxy

Delegates to a mcipc.rcon.je.commands.trigger.TriggerProxy

mcipc.rcon.je.commands.weather module

Implementation of the weather command.

class mcipc.rcon.je.commands.weather.WeatherProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for weather commands.

clear(duration: int | None = None) → str

Sets the weather to clear.

rain(duration: int | None = None) → str

Sets the weather to raining.

thunder(duration: int | None = None) → str

Sets the weather to a thunderstorm.

mcipc.rcon.je.commands.weather.weather(self: Client) → WeatherProxy

Delegates to a mcipc.rcon.je.commands.weather.WeatherProxy

mcipc.rcon.je.commands.worldborder module

Implementation of the worldborder command.

class mcipc.rcon.je.commands.worldborder.DamageProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for damage commands.

amount(damage_per_block: float) → str

Sets the amount of damage per block.

buffer(distance: float) → str

Sets the distance for the damage buffer.

class mcipc.rcon.je.commands.worldborder.WarningProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for warning commands.

distance(distance: int) → str

Sets the warning distance.

time(time: int) → str

Sets the warning time.

class mcipc.rcon.je.commands.worldborder.WorldborderProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for worldborder commands.

add(distance: float, time: int | None = None) → str

Adds a world border.

center(pos: tuple[Union[int, str, float], Union[int, str, float]] | str) → str

Sets the center of the world border.

property damage: DamageProxy

Delegates to a mcipc.rcon.je.commands.worldborder.DamageProxy

get() → str

Returns information about the world border.

set(distance: float, time: int | None = None) → str

Sets the world border.

property warning: WarningProxy

Delegates to a mcipc.rcon.je.commands.worldborder.WarningProxy

mcipc.rcon.je.commands.worldborder.worldborder(self: Client) → WorldborderProxy

Delegates to a mcipc.rcon.je.commands.worldborder.WorldborderProxy

Module contents

Commands for the Java Edition.