pub fn bool() -> impl ArgumentTypeExamples found in repository?
azalea/examples/testbot/commands/combat.rs (line 9)
7pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
8 commands.register(
9 literal("killaura").then(argument("enabled", bool()).executes(|ctx: &Ctx| {
10 let enabled = get_bool(ctx, "enabled").unwrap();
11 let source = ctx.source.lock();
12 let bot = source.bot.clone();
13 bot.query_self::<&mut State, _>(|mut state| state.killaura = enabled);
14 source.reply(if enabled {
15 "Enabled killaura"
16 } else {
17 "Disabled killaura"
18 });
19 1
20 })),
21 );
22}More examples
azalea/examples/testbot/commands/movement.rs (line 195)
13pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
14 commands.register(
15 literal("goto")
16 .executes(|ctx: &Ctx| {
17 let source = ctx.source.lock();
18 println!("got goto");
19 // look for the sender
20 let Some(entity) = source.entity() else {
21 source.reply("I can't see you!");
22 return 0;
23 };
24 let position = entity.position();
25 source.reply("ok");
26 source
27 .bot
28 .start_goto(BlockPosGoal(BlockPos::from(position.up(0.5))));
29 1
30 })
31 .then(literal("xz").then(argument("x", integer()).then(
32 argument("z", integer()).executes(|ctx: &Ctx| {
33 let source = ctx.source.lock();
34 let x = get_integer(ctx, "x").unwrap();
35 let z = get_integer(ctx, "z").unwrap();
36 println!("goto xz {x} {z}");
37 source.reply("ok");
38 source.bot.start_goto(XZGoal { x, z });
39 1
40 }),
41 )))
42 .then(literal("radius").then(argument("radius", float()).then(
43 argument("x", integer()).then(argument("y", integer()).then(
44 argument("z", integer()).executes(|ctx: &Ctx| {
45 let source = ctx.source.lock();
46 let radius = get_float(ctx, "radius").unwrap();
47 let x = get_integer(ctx, "x").unwrap();
48 let y = get_integer(ctx, "y").unwrap();
49 let z = get_integer(ctx, "z").unwrap();
50 println!("goto radius {radius}, position: {x} {y} {z}");
51 source.reply("ok");
52 source.bot.start_goto(RadiusGoal {
53 pos: BlockPos::new(x, y, z).center(),
54 radius,
55 });
56 1
57 }),
58 )),
59 )))
60 .then(argument("x", integer()).then(argument("y", integer()).then(
61 argument("z", integer()).executes(|ctx: &Ctx| {
62 let source = ctx.source.lock();
63 let x = get_integer(ctx, "x").unwrap();
64 let y = get_integer(ctx, "y").unwrap();
65 let z = get_integer(ctx, "z").unwrap();
66 println!("goto xyz {x} {y} {z}");
67 source.reply("ok");
68 source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
69 1
70 }),
71 ))),
72 );
73
74 commands.register(literal("follow").executes(|ctx: &Ctx| {
75 let source = ctx.source.lock();
76 println!("got follow");
77 // look for the sender
78 let Some(entity) = source.entity() else {
79 source.reply("I can't see you!");
80 return 0;
81 };
82 source.reply("ok");
83 *source.state.following_entity.lock() = Some(entity);
84 1
85 }));
86
87 commands.register(literal("down").executes(|ctx: &Ctx| {
88 let source = ctx.source.clone();
89 tokio::spawn(async move {
90 let bot = source.lock().bot.clone();
91 let position = BlockPos::from(bot.position());
92 source.lock().reply("mining...");
93 bot.mine(position.down(1)).await;
94 source.lock().reply("done");
95 });
96 1
97 }));
98
99 commands.register(
100 literal("look")
101 .executes(|ctx: &Ctx| {
102 // look for the sender
103 let source = ctx.source.lock();
104 let Some(entity) = source.entity() else {
105 source.reply("I can't see you!");
106 return 0;
107 };
108 let eye_position = entity.eye_position();
109 source.bot.look_at(eye_position);
110 1
111 })
112 .then(argument("x", integer()).then(argument("y", integer()).then(
113 argument("z", integer()).executes(|ctx: &Ctx| {
114 let pos = BlockPos::new(
115 get_integer(ctx, "x").unwrap(),
116 get_integer(ctx, "y").unwrap(),
117 get_integer(ctx, "z").unwrap(),
118 );
119 println!("{pos:?}");
120 let source = ctx.source.lock();
121 source.bot.look_at(pos.center());
122 1
123 }),
124 ))),
125 );
126
127 commands.register(
128 literal("walk").then(argument("seconds", float()).executes(|ctx: &Ctx| {
129 let mut seconds = get_float(ctx, "seconds").unwrap();
130 let source = ctx.source.lock();
131 let bot = source.bot.clone();
132
133 if seconds < 0. {
134 bot.walk(WalkDirection::Backward);
135 seconds = -seconds;
136 } else {
137 bot.walk(WalkDirection::Forward);
138 }
139
140 tokio::spawn(async move {
141 tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
142 bot.walk(WalkDirection::None);
143 });
144 source.reply(format!("ok, walking for {seconds} seconds"));
145 1
146 })),
147 );
148 commands.register(
149 literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
150 let seconds = get_float(ctx, "seconds").unwrap();
151 let source = ctx.source.lock();
152 let bot = source.bot.clone();
153 bot.sprint(SprintDirection::Forward);
154 tokio::spawn(async move {
155 tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
156 bot.walk(WalkDirection::None);
157 });
158 source.reply(format!("ok, sprinting for {seconds} seconds"));
159 1
160 })),
161 );
162
163 commands.register(literal("north").executes(|ctx: &Ctx| {
164 let source = ctx.source.lock();
165 source.bot.set_direction(180., 0.);
166 source.reply("ok");
167 1
168 }));
169 commands.register(literal("south").executes(|ctx: &Ctx| {
170 let source = ctx.source.lock();
171 source.bot.set_direction(0., 0.);
172 source.reply("ok");
173 1
174 }));
175 commands.register(literal("east").executes(|ctx: &Ctx| {
176 let source = ctx.source.lock();
177 source.bot.set_direction(-90., 0.);
178 source.reply("ok");
179 1
180 }));
181 commands.register(literal("west").executes(|ctx: &Ctx| {
182 let source = ctx.source.lock();
183 source.bot.set_direction(90., 0.);
184 source.reply("ok");
185 1
186 }));
187 commands.register(
188 literal("jump")
189 .executes(|ctx: &Ctx| {
190 let source = ctx.source.lock();
191 source.bot.jump();
192 source.reply("ok");
193 1
194 })
195 .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
196 let jumping = get_bool(ctx, "enabled").unwrap();
197 let source = ctx.source.lock();
198 source.bot.set_jumping(jumping);
199 1
200 })),
201 );
202
203 let sneak = |ctx: &Ctx| {
204 let source = ctx.source.lock();
205 source.bot.set_crouching(!source.bot.crouching());
206 source.reply("ok");
207 1
208 };
209 let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
210 let sneaking = get_bool(ctx, "enabled").unwrap();
211 let source = ctx.source.lock();
212 source.bot.set_crouching(sneaking);
213 1
214 });
215 commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
216 commands.register(literal("crouch").executes(sneak).then(sneak_enabled));
217
218 commands.register(literal("stop").executes(|ctx: &Ctx| {
219 let source = ctx.source.lock();
220 source.bot.stop_pathfinding();
221 source.reply("ok");
222 *source.state.following_entity.lock() = None;
223 1
224 }));
225 commands.register(literal("forcestop").executes(|ctx: &Ctx| {
226 let source = ctx.source.lock();
227 source.bot.force_stop_pathfinding();
228 source.reply("ok");
229 *source.state.following_entity.lock() = None;
230 1
231 }));
232}