nurtex 0.3.0

Lightweight library for creating Minecraft bots. Asynchronous, optimized, ease of coding.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

# NurtexMC


**NurtexMC** is a library written in Rust that allows you to create Minecraft bots and manage them, including connection and packet processing. This library focuses on an asynchronous environment, maximum speed and optimization, and ease of coding.

Supported Minecraft version: `1.21.11` (or protocol version - `774`).

# Usage


To use this library in your code, add a dependency to the Cargo.toml:

```
nurtex = "0.3.0"
```

# Examples


## Creating a bot


```rust
use std::io;

use nurtex::bot::Bot;
use nurtex::events::EventInvoker;
use nurtex::common::BotCommand;

#[tokio::main]

async fn main() -> io::Result<()> {
  // Creating a bot
  let bot = Bot::new("NurtexBot");

  // Create an event invoker
  let mut event_invoker = EventInvoker::new();

  // Сreate a handler for the "spawn" event
  event_invoker.on_spawn(|terminal| async move {
    terminal.chat("Hello, world!").await;
  });

  // Сreate a handler for the "chat" event
  event_invoker.on_chat(|terminal, payload| async move {
    if payload.message.contains("disconnect") {
      // Disconnect bot
      terminal.send(BotCommand::Disconnect).await;
    }
  });

  bot
    .set_event_invoker(event_invoker) // Set event invoker
    .connect_to("localhost", 25565) // Connect bot to server
    .await?;

  Ok(())
}
```

## Creating a swarm


```rust
use std::io;
use std::time::Duration;

use nurtex::common::BotCommand;
use nurtex::swarm::SwarmObject;
use nurtex::time::sleep;
use nurtex::{create_shared_swarm, destroy_shared_swarm, launch_shared_swarm};

#[tokio::main]

async fn main() -> io::Result<()> {
  // Creating swarm objects
  let mut objects = Vec::new();

  for i in 0..=5 {
    let object = SwarmObject::new(format!("bot_{}", i));
    objects.push(object);
  }

  // Creating a shared-swarm of bots
  let swarm = create_shared_swarm(objects);

  // Starting the swarm without blocking the thread
  launch_shared_swarm(swarm.clone(), "localhost".to_string(), 25565, 500);

  sleep(8000).await; // Waiting for all the bots to connect

  {
    let guard = swarm.read().await;

    // Send a message to the chat from all bots
    guard.send(BotCommand::Chat("Hello, world!".to_string())).await;
  }

  sleep(5000).await; // Wait a little

  // Clear and destroy swarm
  destroy_shared_swarm(swarm, Duration::from_secs(5)).await?;

  Ok(())
}
```