Struct DiscordHttpResource 

pub struct DiscordHttpResource {
    pub http: Arc<Http>,
}

Available on (crate features http or rich_presence) and crate feature http only.

A Bevy resource that provides access to the Discord HTTP client.

This resource is automatically inserted into the Bevy app when using DiscordHttpPlugin. It wraps Serenity’s Http client in an Arc for safe concurrent access.

Examples

use bevy_discord::res::DiscordHttpResource;
use std::sync::Arc;
use serenity::all::Http;

let http = Arc::new(Http::new("token"));
let resource = DiscordHttpResource::new(http);

// Get a cloned Arc reference
let client = resource.client();

// Get a reference to the client
let client_ref = resource.client_ref();

Fields

http: Arc<Http>

Arc-wrapped Serenity HTTP client for Discord API operations.

Implementations

impl DiscordHttpResource

pub fn new(http: Arc<Http>) -> Self

Creates a new DiscordHttpResource instance.

Arguments

• http - An Arc-wrapped Serenity HTTP client

pub fn client(&self) -> Arc<Http>

Returns a cloned Arc reference to the HTTP client.

Use this method when you need to share ownership of the client across multiple systems or threads.

Examples found in repository

examples/reactions.rs (line 39)

fn handle_discord_messages(
    mut messages: MessageReader<DiscordMessage>,
    http: Option<Res<bevy_discord::res::DiscordHttpResource>>,
) {
    for message in messages.read() {
        if let Some(http) = &http {
            if message.new_message.author.bot {
                continue;
            }

            if message.new_message.content == "!react" {
                let http = http.client();
                let message_id = message.new_message.id;
                let channel_id = message.new_message.channel_id;

                bevy_discord::runtime::tokio_runtime().spawn(async move {
                    // Add a thumbs up reaction
                    let _ = http
                        .create_reaction(
                            channel_id,
                            message_id,
                            &ReactionType::Unicode("👍".to_string()),
                        )
                        .await;
                });
            }
        }
    }
}

fn handle_discord_reactions(
    mut reaction_add: MessageReader<ReactionAddMessage>,
    http: Option<Res<bevy_discord::res::DiscordHttpResource>>,
) {
    for reaction in reaction_add.read() {
        if let Some(http) = &http {
            // Skip bot reactions
            if reaction.add_reaction.user_id == Some(reaction.ctx.cache.current_user().id) {
                continue;
            }

            let http = http.client();
            let channel_id = reaction.add_reaction.channel_id;

            bevy_discord::runtime::tokio_runtime().spawn(async move {
                let _ = http
                    .send_message(
                        channel_id,
                        vec![],
                        &json!({
                            "content": "Thanks for reacting! 😊"
                        }),
                    )
                    .await;
            });
        }
    }
}

examples/basic_bot.rs (line 49)

fn handle_discord_message(
    mut messages: MessageReader<DiscordMessage>,
    http: Option<Res<bevy_discord::res::DiscordHttpResource>>,
) {
    for message in messages.read() {
        if let Some(http) = &http {
            // Skip messages from bots (including our own)
            if message.new_message.author.bot {
                continue;
            }

            let content = &message.new_message.content;
            let channel_id = message.new_message.channel_id;

            // Simple ping-pong command
            if content == "!ping" {
                let http = http.client();

                bevy_discord::runtime::tokio_runtime().spawn(async move {
                    let _ = http
                        .send_message(
                            channel_id,
                            vec![],
                            &json!({
                                "content": "Pong! 🏓"
                            }),
                        )
                        .await;
                });
            }
        }
    }
}

pub fn client_ref(&self) -> &Http

Returns a reference to the underlying HTTP client.

Use this method when you only need temporary access to the client and don’t need to share ownership.

Trait Implementations

impl Clone for DiscordHttpResource

fn clone(&self) -> DiscordHttpResource

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DiscordHttpResource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Resource for DiscordHttpResource

where Self: Send + Sync + 'static,