mcipc.rcon.be.commands package

Submodules

mcipc.rcon.be.commands.ability module

Implementation of the ability command.

mcipc.rcon.be.commands.ability.ability(self: Client, player: str, ability: Ability | str | None = None, value: bool | None = None) → str

Sets or queries player with a specific ability.

mcipc.rcon.be.commands.camerashake module

Implementation of the camerashake command.

class mcipc.rcon.be.commands.camerashake.CamerashakeProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for camera shake commands.

add(player: str, intensity: float | None = None, seconds: float | None = None, shake_type: CamerashakeType | str | None = None) → str

Used to enable a camera shaking effect.

mcipc.rcon.be.commands.camerashake.camerashake(self: Client) → CamerashakeProxy

Delegates to a mcipc.rcon.be.commands.camerashake.CamerashakeProxy

mcipc.rcon.be.commands.clear module

Implementation of the clear command.

mcipc.rcon.be.commands.clear.clear(self: Client, player: str | None = None, item_name: str | None = None, data: int | None = None, max_count: int | None = None) → str

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

mcipc.rcon.be.commands.clearspawnpoint module

Implementation of the clearspawnpoint.

mcipc.rcon.be.commands.clearspawnpoint.clearspawnpoint(self: Client, player: str | None = None) → str

Used to remove spawnpoints in the world.

mcipc.rcon.be.commands.clone module

Implementation of the clone command.

mcipc.rcon.be.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, clone_mode: CloneMode | str | None = None, tile_name: str | None = None, tile_data: int | None = None) → str

Clones blocks from one region to another.

mcipc.rcon.be.commands.difficulty module

Implementation of the difficulty command.

mcipc.rcon.be.commands.difficulty.difficulty(self: Client, difficulty: Difficulty | str | int) → str

Sets the difficulty.

mcipc.rcon.be.commands.effect module

Implementation of the effect command.

mcipc.rcon.be.commands.effect.effect(self: Client, player: str, effect_or_clear: str, seconds: int | None = None, amplifier: int | None = None, hide_particles: bool | None = None) → str

Returns a proxy for available sub-commands.

mcipc.rcon.be.commands.enchant module

Implementation of the enchant command.

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

Enchants the given player.

mcipc.rcon.be.commands.event module

Implementation of the event command.

class mcipc.rcon.be.commands.event.EventProxy(client: Client, *args: str)

Bases: CommandProxy

Proxies event-related commands.

entity(target: str, event_name: str) → str

Triggers an event on an entity.

mcipc.rcon.be.commands.event.event(self: Client) → EventProxy

Delegates to a mcipc.rcon.be.commands.event.EventProxy

mcipc.rcon.be.commands.fill module

Implementation of the fill command.

mcipc.rcon.be.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, tile_data: int | None = None, old_block_handling: FillMode | str | None = None, replace_tile_name: str | None = None, replace_data_value: str | None = None) → str

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

mcipc.rcon.be.commands.fog module

Implementation of the fog command.

class mcipc.rcon.be.commands.fog.FogProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for fog-related commands.

pop(user_provided_id: str) → str

Pops the respective fog.

push(fog_id: str, user_provided_id: str) → str

Adds the respective fog.

remove(user_provided_id: str) → str

Remove the respective fog.

mcipc.rcon.be.commands.fog.fog(self: Client, victim: str) → FogProxy

Delegates to a mcipc.rcon.be.commands.fog.Proxy

mcipc.rcon.be.commands.gamemode module

Implementation of the gamemode command.

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

Sets the game mode.

mcipc.rcon.be.commands.give module

Implementation of the give command.

mcipc.rcon.be.commands.give.give(self: Client, target: str, item: str, amount: int | None = None, data: int | None = None, components: dict | None = None) → str

Gives an item to one or more players.

mcipc.rcon.be.commands.help module

Implementation of the help command.

mcipc.rcon.be.commands.help.help(client: Client, command_or_page: str | int | None = None) → str

Returns help about commands.

mcipc.rcon.be.commands.list module

Implementation of the list command.

mcipc.rcon.be.commands.list.list(client: Client) → str

Returns the players.

mcipc.rcon.be.commands.locate module

Implementation of the locate command.

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

Locates the respective structure.

mcipc.rcon.be.commands.mixer module

Implementation of the mixer command.

mcipc.rcon.be.commands.mixer.mixer(self: Client) → str

Mixer control.

mcipc.rcon.be.commands.mobevent module

Implementation of the mobevent command.

mcipc.rcon.be.commands.mobevent.mobevent(self: Client, event: str, value: bool | None = None) → str

Controls or queries what mob events are allowed to run.

mcipc.rcon.be.commands.music module

Implementation of the music command.

class mcipc.rcon.be.commands.music.MusicProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for music commands.

play(track_name: str, volume: float | None = None, fade_seconds: float | None = None, repeat_mode: MusicRepeatMode | str | None = None) → str

Plays the music track.

queue(track_name: str, volume: float | None = None, fade_seconds: float | None = None, repeat_mode: MusicRepeatMode | str | None = None) → str

Add the music tracks to the queue.

stop(fade_seconds: float | None = None) → str

Stops the music.

volume(volume: float) → str

Adjusting the music volume.

mcipc.rcon.be.commands.music.music(self: Client) → MusicProxy

Delegates to a mcipc.rcon.be.commands.music.MusicProxy

mcipc.rcon.be.commands.particle module

Implementation of the particle command.

mcipc.rcon.be.commands.particle.particle(self: Client, effect: str, position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str) → str

Creates the respective particles.

mcipc.rcon.be.commands.playanimation module

Implementation of the playanimation command.

mcipc.rcon.be.commands.playanimation.playanimation(self: Client, entity: str, animation: str, next_state: str | None = None, blend_out_time: float | None = None, stop_expression: str | None = None, controller: str | None = None) → str

Makes one or more entities play a one-off animation.

mcipc.rcon.be.commands.playsound module

Implementation of the playsound command.

mcipc.rcon.be.commands.playsound.playsound(self: Client, sound: str, player: str | None = None, position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, volume: float | None = None, minimum_volume: float | None = None) → str

Plays a sound.

mcipc.rcon.be.commands.replaceitem module

Implementation of the replaceitem command.

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

Bases: CommandProxy

Proxy for replaceitem related commands.

block(position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, slot_id: int, item_name: str, amount: int | None = None, data: int | None = None, components: dict | None = None, *, old_item_handling: ReplaceMode | str | None = None) → str

Replaces a block.

entity(target: str, slot_type: EntityEquipmentSlot | str, slot_id: int, item_name: str, amount: int | None = None, data: int | None = None, components: dict | None = None, *, old_item_handling: ReplaceMode | str | None = None) → str

Replaces an item.

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

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

mcipc.rcon.be.commands.ride module

Implementation of the ride command.

class mcipc.rcon.be.commands.ride.RideProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for ride related commands.

evict_riders() → str

Makes entities that are riding on <rides> dismount.

start_riding(ride: str, teleport_rules: TeleportRules | str | None = None, how_to_fill: FillType | str | None = None) → str

Makes <riders> ride on <ride>.

stop_riding() → str

Makes <riders> dismount.

summon_ride(entity_type: str, ride_rules: RideRules | str | None = None, spawn_event: str | None = None, name_tag: str | None = None) → str

Summons a ride.

summon_rider(entity_type: str, spawn_event: str | None = None, name_tag: str | None = None) → str

Summons a rider.

mcipc.rcon.be.commands.ride.ride(self: Client, riders_or_rides: str) → RideProxy

Delegates to a mcipc.rcon.be.commands.ride.RideProxy

mcipc.rcon.be.commands.save module

Implementation of the save command.

mcipc.rcon.be.commands.save.save(self: Client, command: SaveCommand | str) → str

Issues the specified save command.

mcipc.rcon.be.commands.schedule module

Implementation of the schedule command.

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

Bases: CommandProxy

Proxy for schedule-related commands.

circle(center: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, radius: int, function: Path) → str

Adds a circle.

tickingarea(name: str, function: Path) → str

Adds a ticking ares.

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

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

mcipc.rcon.be.commands.scoreboard module

Implementation of the scoreboard command.

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

Bases: CommandProxy

Proxy for objective commands.

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

Adds an objective.

list() → str

Lists objectives.

remove(objective: str) → str

Removes an objective.

setdisplay(location: Location | str, objective: str, order: Order | str | None = None) → str

Sets a display.

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

Bases: CommandProxy

Proxy for player commands.

add(player: str, objective: str, count: int) → str

Adds to a player’s score.

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

Lists player scores.

operation(target_name: str, target_objective: str, operation: Operator | str, selector: str, objective: str) → str

Executes an operation.

random(player: str, objective: str, min: int, max: int | None = None) → str

Sets a random score for the player’s objective.

remove(player: str, objective: str, count: int) → str

Removes from a player’s score.

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

Resets a player’s score.

set(player: str, objective: str, count: int) → str

Sets a player’s score.

test(player: str, objective: str, min: int | str, max: str | int | None = None) → str

Tests whether a player’s score is within the given boundaries.

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

Bases: CommandProxy

Proxy for scoreboard related commands.

property objectives: ObjectivesProxy

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

property players: PlayersProxy

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

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

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

mcipc.rcon.be.commands.setblock module

Implementation of the setblock command.

mcipc.rcon.be.commands.setblock.setblock(self: Client, position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, tile_name: str, tile_data: int | None = None, mode: SetblockMode | str | None = None) → str

Sets a block.

mcipc.rcon.be.commands.setmaxplayers module

Implementation of the setmaxplayers command.

mcipc.rcon.be.commands.setmaxplayers.setmaxplayers(self: Client, max_players: int) → str

Sets the maximally allowed players on the server.

mcipc.rcon.be.commands.setworldspawn module

Implementation of the setworldspawn command.

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

Sets the world spawn.

mcipc.rcon.be.commands.spawnpoint module

Implementation of the spawnpoint command.

mcipc.rcon.be.commands.spawnpoint.spawnpoint(self: Client, player: str | None = None, spawn_pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None) → str

Sets the spawn point for a player.

mcipc.rcon.be.commands.spreadplayers module

Implementation of the spreadplayers command.

mcipc.rcon.be.commands.spreadplayers.spreadplayers(self: Client, x: float | str, y: float | str, spread_distance: float, max_range: float, victim: str) → str

Spreads players.

mcipc.rcon.be.commands.stopsound module

Implementation of the stopsound command.

mcipc.rcon.be.commands.stopsound.stopsound(self: Client, player: str, sound: str | None = None) → str

Stops playing a sound.

mcipc.rcon.be.commands.structure module

Implementation of the structure command.

class mcipc.rcon.be.commands.structure.StructureProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for structure commands.

load(name: str, to: tuple[typing.Union[int, str, float], typing.Union[int, str, float], typing.Union[int, str, float]] | str, rotation: ~mcipc.rcon.be.enumerations.Rotation | str | None = None, mirror: ~mcipc.rcon.be.enumerations.Mirror | str | None = None, includes_entities: bool | None = None, includes_blocks: bool | None = None, integrity: float | None = None, seed: str = <class 'NoneType'>, *, animation_mode: ~mcipc.rcon.be.enumerations.StructureAnimationMode | str | None = None, animation_seconds: float | None = None) → str

Loads a structure.

save(name: str, 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, save_mode: StructureSaveMode | str | None = None, includes_blocks: bool | None = None, *, includes_entities: bool | None = None) → str

Saves a structure.

mcipc.rcon.be.commands.structure.structure(self: Client) → StructureProxy

Delegates to a mcipc.rcon.be.commands.structure.StructureProxy

mcipc.rcon.be.commands.summon module

Implementation of the summon command.

mcipc.rcon.be.commands.summon.summon(self: Client, entity_type: str, spawn_pos: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, spawn_event: str | None = None, name_tag: str | None = None) → str

Summons an entity.

mcipc.rcon.be.commands.teleport module

Implementation of the teleport command.

mcipc.rcon.be.commands.teleport.teleport(self: Client, *, destination: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, victim: str | None = None, check_for_blocks: bool | None = None, y_rot: float | str | None = None, x_rot: float | str | None = None, look_at_position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None, look_at_entity: str | None = None) → str

Teleports the player.

mcipc.rcon.be.commands.testfor module

Implementation of the testfor command.

mcipc.rcon.be.commands.testfor.testfor(self: Client, victim: str) → str

Counts entities matching specified conditions.

mcipc.rcon.be.commands.testforblock module

Implementation of the testforblock command.

mcipc.rcon.be.commands.testforblock.testforblock(self: Client, position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, tile_name: str, data_value: int | None = None) → str

Tests whether a certain block is in a specific location.

mcipc.rcon.be.commands.testforblocks module

Implements the testforblocks command.

mcipc.rcon.be.commands.testforblocks.testforblocks(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, match_mode: MatchMode | str | None = None) → str

Tests whether the blocks in two regions match.

mcipc.rcon.be.commands.tickingarea module

Implementes the tickingarea command.

class mcipc.rcon.be.commands.tickingarea.AddProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for add comamnds.

circle(center: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str, radius: int, name: str | None = None) → str

Adds a ticking area in a circle.

class mcipc.rcon.be.commands.tickingarea.TickingareaProxy(client: Client, *args: str)

Bases: CommandProxy

Proxy for tickingarea commands.

add() → AddProxy

Delegates to a mcipc.rcon.be.commands.tickingarea.AddProxy

list(all_dimensions: bool = False) → str

Lists ticking areas.

remove(*, name: str | None = None, position: tuple[Union[int, str, float], Union[int, str, float], Union[int, str, float]] | str | None = None) → str

Removes a ticking ares.

mcipc.rcon.be.commands.tickingarea.tickingarea(self: Client) → TickingareaProxy

Delegates to a mcipc.rcon.be.commands.tickingarea.TickingareaProxy

mcipc.rcon.be.commands.time module

Implementation of the time command.

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

Bases: CommandProxy

Proxy for time commands.

add(time: int) → str

Adds time.

query(time_type: TimeType | str) → str

Queries the given time type.

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

Sets the time to the given amount.

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

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

mcipc.rcon.be.commands.title module

Implementation of the title comman.

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

Bases: CommandProxy

Proxy for title commands.

actionbar(title_text: str) → str

Sets the action bar.

clear() → str

Clears the title.

reset() → str

Resets the title.

subtitle(title_text: 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_text: str) → str

Sets the title.

mcipc.rcon.be.commands.title.title(self: Client, player: str) → TitleProxy

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

mcipc.rcon.be.commands.toggledownfall module

Implements the toggledownfall command.

mcipc.rcon.be.commands.toggledownfall.toggledownfall(self: Client) → str

Toggles downfall.

mcipc.rcon.be.commands.transferserver module

Implementation of the transferserver command.

mcipc.rcon.be.commands.transferserver.transferserver(self: Client, server: str, port: int) → str

Transfer player to another server.

mcipc.rcon.be.commands.weather module

Implementation of the weather command.

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

Bases: WeatherProxy

Proxy for weather commands.

query() → str

Queries the current weather.

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

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

mcipc.rcon.be.commands.worldbuilder module

Implementation of the worldbuilder and wb commands.

mcipc.rcon.be.commands.worldbuilder.wb(self: Client) → str

Toggles the world builder feature.

mcipc.rcon.be.commands.worldbuilder.worldbuilder(self: Client) → str

Toggles the world builder feature.

mcipc.rcon.be.commands.wsserver module

Implementation of the wsserver and connect commands.

mcipc.rcon.be.commands.wsserver.connect(self: Client, server_uri: str) → str

Connect to designated WebSocket server.

mcipc.rcon.be.commands.wsserver.wsserver(self: Client, server_uri: str) → str

Connect to designated WebSocket server.

mcipc.rcon.be.commands.xp module

Implementation of the xp command.

mcipc.rcon.be.commands.xp.xp(self: Client, amount: int, player: str) → str

Gives the player the specified amount of XP.

Module contents

Commands for the Bedrock Edition.