rustycord 0.1.5

A fast, lightweight, and feature-rich Discord bot library written in Rust.
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

// gateway/shard_manager.rs

use futures::future::join_all;

use crate::client::Client;
use crate::gateway::gateway::Manager;

use super::gateway::PresenceUpdate;

pub struct ShardManager {
    pub total_shards: usize,
    pub token: String,
    pub client: Client,
}

impl ShardManager {
    pub fn new(token: String, total_shards: usize, client: Client) -> Self {
        Self {
            total_shards,
            token,
            client,
        }
    }

    pub async fn start(&self, intents: Option<i32>, presense: Option<PresenceUpdate>) {
        let mut shard_tasks = Vec::new();

        for shard_id in 0..self.total_shards {
            let token = self.token.clone();
            let intents: i32 = match intents {
                Some(int) => int,
                None => {
                    log::warn!("No intents provided using default");
                    1
                }
            };
            let intents = intents;
            let compress = false;
            let large_threshold = Some(50);
            let shard = Some(vec![shard_id as i32, self.total_shards as i32]);
            let presence = presense.clone(); // Initialize with your desired presence if any
            let client = self.client.clone();

            // Spawn each shard as a separate task
            let shard_task = async move {
                let mut shard_manager = Manager::new(token.clone(), intents, shard_id, self.total_shards).await;
                shard_manager.set_client(client);
                shard_manager.send_identify(
                    token,
                    intents,
                    compress,
                    large_threshold,
                    shard,
                    presence,
                ).await;

                loop {
                    // Handle heartbeats
                    shard_manager.handle_heartbeat().await;

                    // Handle incoming events
                    shard_manager.handle_event().await;

                    // Sleep for a short duration to prevent tight looping
                    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
                }
            };

            shard_tasks.push(shard_task);
        }

        // Await all shard tasks
        join_all(shard_tasks).await;
    }
}