diff --git a/crates/avatar/Cargo.toml b/crates/avatar/Cargo.toml
index b16e250d..fb82adc4 100644
--- a/crates/avatar/Cargo.toml
+++ b/crates/avatar/Cargo.toml
@@ -19,6 +19,7 @@ input_manager = { workspace = true }
world_ui = { workspace = true }
collectibles = { workspace = true }
scene_material = { workspace = true }
+social = { workspace = true }
bevy = { workspace = true }
bevy_kira_audio = { workspace = true }
diff --git a/crates/avatar/src/avatar_texture.rs b/crates/avatar/src/avatar_texture.rs
index d2290b11..22d34933 100644
--- a/crates/avatar/src/avatar_texture.rs
+++ b/crates/avatar/src/avatar_texture.rs
@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, path::PathBuf, sync::Arc};
+use std::{collections::VecDeque, sync::Arc};
use anyhow::anyhow;
use bevy::{
@@ -11,6 +11,7 @@ use bevy::{
prelude::*,
render::{
camera::RenderTarget,
+ render_asset::RenderAssetUsages,
render_resource::{
Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
},
@@ -20,13 +21,8 @@ use bevy::{
};
use bevy_dui::{DuiRegistry, DuiTemplate};
use collectibles::{urn::CollectibleUrn, Emote};
-use common::{
- sets::SetupSets,
- structs::{AvatarTextureHandle, PrimaryPlayerRes, AVATAR_TEXTURE_RENDERLAYER},
-};
-use comms::{global_crdt::ForeignPlayer, profile::UserProfile};
+use common::sets::SetupSets;
use dcl_component::proto_components::sdk::components::PbAvatarEmoteCommand;
-use ipfs::{ipfs_path::IpfsPath, IpfsAssetServer};
use ui_core::ui_actions::{DragData, Dragged, On};
use crate::{
@@ -41,16 +37,8 @@ const SNAPSHOT_FRAMES: u32 = 5;
impl Plugin for AvatarTexturePlugin {
fn build(&self, app: &mut App) {
app.init_resource::
();
- app.add_systems(Startup, setup_primary_avatar_camera.in_set(SetupSets::Main));
- app.add_systems(
- Update,
- (
- load_foreign_textures,
- update_booth_image,
- snapshot,
- clean_booths,
- ),
- );
+ app.add_systems(Startup, setup.in_set(SetupSets::Main));
+ app.add_systems(Update, (update_booth_image, snapshot, clean_booths));
}
}
@@ -227,30 +215,7 @@ impl BoothInstance {
}
}
-fn setup_primary_avatar_camera(
- mut commands: Commands,
- player: Res,
- mut images: ResMut>,
- mut dui: ResMut,
-) {
- let size = Extent3d {
- width: 512,
- height: 512,
- ..default()
- };
-
- let (avatar_texture, _) = add_booth_camera(
- &mut commands,
- &mut images,
- player.0,
- size,
- AVATAR_TEXTURE_RENDERLAYER,
- );
-
- commands
- .entity(player.0)
- .insert(AvatarTextureHandle(avatar_texture));
-
+fn setup(mut dui: ResMut) {
dui.register_template("photobooth", DuiBooth);
}
@@ -328,27 +293,6 @@ fn add_booth_camera(
(avatar_texture, camera.unwrap())
}
-#[allow(clippy::type_complexity)]
-fn load_foreign_textures(
- mut q: Query<
- (&mut AvatarTextureHandle, &UserProfile),
- (With, Changed),
- >,
- ipfas: IpfsAssetServer,
-) {
- for (mut texture, profile) in q.iter_mut() {
- if let Some(snapshots) = profile.content.avatar.snapshots.as_ref() {
- let url = format!("{}{}", profile.base_url, snapshots.face256);
- let ipfs_path = IpfsPath::new_from_url(&url, "png");
- texture.0 = ipfas.asset_server().load(PathBuf::from(&ipfs_path));
- debug!(
- "loaded remote avatar texture ({}) for {}",
- url, profile.content.eth_address
- );
- }
- }
-}
-
fn update_booth_image(
q: Query<(&Node, &UiImage), With>,
mut images: ResMut>,
@@ -452,8 +396,8 @@ fn snapshot(
let face_window = timer.1.take().unwrap();
let face_cam = cam(
face_window,
- Transform::from_translation(Vec3::new(0.0, 1.8, -1.0))
- .looking_at(Vec3::Y * 1.8, Vec3::Y),
+ Transform::from_translation(Vec3::new(0.0, 1.7, -1.0))
+ .looking_at(Vec3::Y * 1.7, Vec3::Y),
);
let body_window = timer.2.take().unwrap();
@@ -508,11 +452,12 @@ fn snapshot(
commands.entity(camera).despawn_recursive();
let Some(target) = images.get_mut(&target) else {
- error!("target not found");
+ error!("target {:?} not found", target);
continue;
};
*target = image;
+ target.asset_usage = RenderAssetUsages::default();
}
}
diff --git a/crates/avatar/src/colliders.rs b/crates/avatar/src/colliders.rs
index c3fa7b74..5be4a915 100644
--- a/crates/avatar/src/colliders.rs
+++ b/crates/avatar/src/colliders.rs
@@ -1,15 +1,15 @@
+use crate::AvatarMaterials;
use bevy::{
core::FrameCount,
prelude::*,
- render::render_resource::Extent3d,
utils::{HashMap, HashSet},
};
-use bevy_dui::{DuiCommandsExt, DuiProps, DuiRegistry};
use common::{
dynamics::{PLAYER_COLLIDER_HEIGHT, PLAYER_COLLIDER_OVERLAP, PLAYER_COLLIDER_RADIUS},
rpc::{RpcCall, RpcEventSender},
sets::SceneSets,
- structs::{ActiveDialog, PrimaryCamera, ToolTips, PROFILE_UI_RENDERLAYER},
+ structs::{PrimaryCamera, ShowProfileEvent, ToolTips, TooltipSource},
+ util::{AsH160, FireEventEx},
};
use comms::{global_crdt::ForeignPlayer, profile::UserProfile};
use input_manager::AcceptInput;
@@ -26,9 +26,6 @@ use scene_runner::{
},
};
use serde_json::json;
-use ui_core::button::DuiButton;
-
-use crate::{avatar_texture::PhotoBooth, AvatarMaterials, AvatarShape};
pub struct AvatarColliderPlugin;
@@ -110,12 +107,7 @@ fn update_avatar_collider_actions(
mut colliders: ResMut,
camera: Query<(&Camera, &GlobalTransform), With>,
windows: Query<&Window>,
- (accept_input, pointer_target, frame, active_dialog): (
- Res,
- Res,
- Res,
- Res,
- ),
+ (accept_input, pointer_target, frame): (Res, Res, Res),
mut tooltips: ResMut,
profiles: Query<(
&ForeignPlayer,
@@ -126,8 +118,6 @@ fn update_avatar_collider_actions(
mouse_input: Res>,
mut senders: Local>,
mut subscribe_events: EventReader,
- mut photo_booth: PhotoBooth,
- dui: Res,
mut hilighted_materials: Local>>,
mut scene_materials: ResMut>,
) {
@@ -139,7 +129,7 @@ fn update_avatar_collider_actions(
senders.push(sender.clone());
}
- tooltips.0.remove("avatar_pointer");
+ tooltips.0.remove(&TooltipSource::Label("avatar_pointer"));
// check for scene ui
if !matches!(*ui_target, UiPointerTarget::None) {
@@ -219,11 +209,11 @@ fn update_avatar_collider_actions(
}
tooltips.0.insert(
- "avatar_pointer",
+ TooltipSource::Label("avatar_pointer"),
vec![("Middle Click : Profile".to_owned(), true)],
);
- if mouse_input.just_pressed(MouseButton::Middle) {
+ if mouse_input.just_pressed(MouseButton::Left) {
// send event
let event = json!({
"userId": format!("{:#x}", player.address),
@@ -236,33 +226,15 @@ fn update_avatar_collider_actions(
for sender in senders.iter() {
let _ = sender.send(event.clone());
}
+ }
+ if mouse_input.just_pressed(MouseButton::Middle) {
// display profile
- let instance = photo_booth.spawn_booth(
- PROFILE_UI_RENDERLAYER,
- AvatarShape::from(profile),
- Extent3d::default(),
- false,
- );
-
- let Some(permit) = active_dialog.try_acquire() else {
- warn!("can't open profile with other active dialog");
- return;
- };
-
- let components = commands
- .spawn_template(
- &dui,
- "foreign-profile",
- DuiProps::new()
- .with_prop("title", format!("{} profile", profile.content.name))
- .with_prop("booth-instance", instance)
- .with_prop("eth-address", profile.content.eth_address.clone())
- .with_prop("buttons", vec![DuiButton::close_happy("Ok")]),
- )
- .unwrap();
-
- commands.entity(components.root).insert(permit);
+ if let Some(address) = profile.content.eth_address.as_h160() {
+ commands.fire_event(ShowProfileEvent(address));
+ } else {
+ warn!("Profile has a bad address {}", profile.content.eth_address);
+ }
}
}
diff --git a/crates/avatar/src/lib.rs b/crates/avatar/src/lib.rs
index c530a6c5..56d0db0f 100644
--- a/crates/avatar/src/lib.rs
+++ b/crates/avatar/src/lib.rs
@@ -37,10 +37,7 @@ pub mod npc_dynamics;
use common::{
sets::SetupSets,
- structs::{
- AppConfig, AttachPoints, PrimaryUser, AVATAR_TEXTURE_RENDERLAYER,
- PRIMARY_AVATAR_LIGHT_LAYER,
- },
+ structs::{AppConfig, AttachPoints, PrimaryUser, PRIMARY_AVATAR_LIGHT_LAYER},
util::{DespawnWith, TryPushChildrenEx},
};
use comms::{
@@ -453,11 +450,7 @@ fn select_avatar(
scene: update.current_source,
shape,
render_layers: if maybe_player.is_none() {
- Some(
- RenderLayers::default()
- .union(&PRIMARY_AVATAR_LIGHT_LAYER)
- .union(&AVATAR_TEXTURE_RENDERLAYER),
- )
+ Some(RenderLayers::default().union(&PRIMARY_AVATAR_LIGHT_LAYER))
} else {
None
},
diff --git a/crates/common/src/profile.rs b/crates/common/src/profile.rs
index c5c5c4a2..37973722 100644
--- a/crates/common/src/profile.rs
+++ b/crates/common/src/profile.rs
@@ -95,10 +95,6 @@ impl Default for SerializedProfile {
{\"slot\": 8, \"urn\": \"headexplode\" },
{\"slot\": 9, \"urn\": \"shrug\" }
],
- \"snapshots\": {
- \"face256\":\"bafkreifxucgpg7w2rnnfevjzvlokojxnxqh7uvxhe2nwwyks4xr4unx4bu\",
- \"body\":\"bafkreicdr2mdferawy7bwl3vwitqg37sohjmkt6zsaqbhlmxwprcquaacy\"
- },
\"eyes\":{
\"color\":{\"r\":0.3,\"g\":0.2235294133424759,\"b\":0.99,\"a\":1}
},
diff --git a/crates/common/src/structs.rs b/crates/common/src/structs.rs
index 633ffbd9..4c99eab8 100644
--- a/crates/common/src/structs.rs
+++ b/crates/common/src/structs.rs
@@ -77,10 +77,6 @@ impl AttachPoints {
}
}
-// component holding avatar texture (just the face currently)
-#[derive(Component, Default)]
-pub struct AvatarTextureHandle(pub Handle);
-
// main camera entity
#[derive(Component)]
pub struct PrimaryCamera {
@@ -150,8 +146,14 @@ pub struct PrimaryCameraRes(pub Entity);
#[derive(Component)]
pub struct UiRoot;
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Clone, Copy)]
+pub enum TooltipSource {
+ Label(&'static str),
+ Entity(Entity),
+}
+
#[derive(Resource, Default)]
-pub struct ToolTips(pub HashMap<&'static str, Vec<(String, bool)>>);
+pub struct ToolTips(pub HashMap>);
// web3 authorization chain link
#[derive(Serialize, Deserialize, Clone, Debug)]
@@ -580,6 +582,9 @@ pub enum SettingsTab {
#[derive(Event, Clone)]
pub struct ShowSettingsEvent(pub SettingsTab);
+#[derive(Event, Clone)]
+pub struct ShowProfileEvent(pub Address);
+
#[derive(Event, Clone)]
pub struct SystemAudio(pub String);
@@ -613,7 +618,5 @@ pub struct PermissionTarget {
// - world lights target both 0 and 1, the main camera uses 0
// - this allows shadows to be cast by the player without the player being visible
pub const PRIMARY_AVATAR_LIGHT_LAYER: RenderLayers = RenderLayers::layer(1);
-// primary avatar texture layer
-pub const AVATAR_TEXTURE_RENDERLAYER: RenderLayers = RenderLayers::layer(2);
// layer for profile content
pub const PROFILE_UI_RENDERLAYER: RenderLayers = RenderLayers::layer(3);
diff --git a/crates/common/src/util.rs b/crates/common/src/util.rs
index 56eb95aa..30445bde 100644
--- a/crates/common/src/util.rs
+++ b/crates/common/src/util.rs
@@ -79,6 +79,22 @@ impl AsH160 for String {
}
}
+pub fn format_address(address: H160, name: Option<&str>) -> String {
+ let str_address = format!("{:x}", address);
+ let str_address = str_address
+ .chars()
+ .skip(str_address.len().saturating_sub(4))
+ .collect::();
+ if let Some(name) = name {
+ format!("{name}#{str_address}")
+ } else {
+ format!(
+ "0x{}...{str_address}",
+ str_address.chars().take(4).collect::()
+ )
+ }
+}
+
/// a struct for buffering a certain amount of history and providing a subscription mechanism for updates
#[derive(Debug)]
pub struct RingBuffer {
diff --git a/crates/comms/Cargo.toml b/crates/comms/Cargo.toml
index f4e31ebc..b8be64ff 100644
--- a/crates/comms/Cargo.toml
+++ b/crates/comms/Cargo.toml
@@ -29,11 +29,11 @@ prost = { workspace = true }
async-std = { workspace = true }
bevy_kira_audio = { workspace = true }
kira = { workspace = true }
+async-trait = { workspace = true }
+async-tungstenite = { workspace = true }
+futures-util = { workspace = true }
-async-trait = "0.1.68"
-async-tungstenite = { version = "0.22.0", features = ["async-std-runtime", "async-tls"] }
async-tls = "0.12.0"
-futures-util = "0.3.28"
livekit = { git = "https://github.com/robtfm/client-sdk-rust", branch="0.6-h264-false-2", features=["rustls-tls-webpki-roots"], optional = true }
rand = "0.8.5"
multihash-codetable = { version = "0.1.1", features = ["digest", "sha2"] }
diff --git a/crates/comms/src/global_crdt.rs b/crates/comms/src/global_crdt.rs
index 33b3d99b..2ef69f7d 100644
--- a/crates/comms/src/global_crdt.rs
+++ b/crates/comms/src/global_crdt.rs
@@ -7,7 +7,7 @@ use bevy::{
use bimap::BiMap;
use common::{
rpc::{RpcCall, RpcEventSender},
- structs::{AttachPoints, AudioDecoderError, AvatarTextureHandle},
+ structs::{AttachPoints, AudioDecoderError},
};
use ethers_core::types::Address;
use kira::sound::streaming::StreamingSoundData;
@@ -284,7 +284,6 @@ pub fn process_transport_updates(
audio_sender: audio_sender.clone(),
},
ForeignAudioSource(audio_receiver),
- AvatarTextureHandle::default(),
))
.push_children(&attach_points.entities())
.insert(attach_points)
diff --git a/crates/comms/src/lib.rs b/crates/comms/src/lib.rs
index 8a1f7e47..bdfbbeeb 100644
--- a/crates/comms/src/lib.rs
+++ b/crates/comms/src/lib.rs
@@ -194,6 +194,10 @@ impl<'w, 's> AdapterManager<'w, 's> {
address: address.to_owned(),
});
}
+ "fixed-adapter" => {
+ // fixed-adapter should be ignored and we use the tail as the full protocol:address
+ return self.connect(address);
+ }
_ => {
warn!("unrecognised adapter protocol: {protocol}");
}
diff --git a/crates/comms/src/profile.rs b/crates/comms/src/profile.rs
index a33dec1f..ad1b6a01 100644
--- a/crates/comms/src/profile.rs
+++ b/crates/comms/src/profile.rs
@@ -1,14 +1,15 @@
-use std::{io::Read, sync::Arc};
+use std::{io::Read, path::PathBuf, sync::Arc};
use anyhow::anyhow;
use bevy::{
+ ecs::system::SystemParam,
prelude::*,
tasks::{IoTaskPool, Task},
utils::HashMap,
};
use dcl::interface::CrdtType;
use ethers_core::types::Address;
-use ipfs::{IpfsAssetServer, IpfsIo, TypedIpfsRef};
+use ipfs::{ipfs_path::IpfsPath, IpfsAssetServer, IpfsIo, TypedIpfsRef};
use isahc::{http::StatusCode, AsyncReadResponseExt, ReadResponseExt, RequestExt};
use multihash_codetable::MultihashDigest;
use serde::{Deserialize, Serialize};
@@ -47,6 +48,81 @@ impl Plugin for UserProfilePlugin {
);
app.insert_resource(CurrentUserProfile::default());
+ app.init_resource::();
+ }
+}
+
+enum ProfileDisplayState {
+ Loaded(Box),
+ Loading(Task>),
+ Failed,
+}
+
+#[derive(Resource, Default)]
+pub struct ProfileCache(HashMap);
+
+#[derive(SystemParam)]
+pub struct ProfileManager<'w, 's> {
+ cache: ResMut<'w, ProfileCache>,
+ ipfs: IpfsAssetServer<'w, 's>,
+}
+
+pub struct ProfileMissingError;
+
+impl<'w, 's> ProfileManager<'w, 's> {
+ pub fn get_data(
+ &mut self,
+ address: Address,
+ ) -> Result, ProfileMissingError> {
+ let state = self.cache.0.entry(address).or_insert_with(|| {
+ ProfileDisplayState::Loading(
+ IoTaskPool::get().spawn(get_remote_profile(address, self.ipfs.ipfs().clone())),
+ )
+ });
+
+ if let ProfileDisplayState::Loading(task) = state {
+ match task.complete() {
+ Some(Ok(profile)) => *state = ProfileDisplayState::Loaded(Box::new(profile)),
+ Some(Err(_)) => *state = ProfileDisplayState::Failed,
+ None => (),
+ }
+ }
+
+ Ok(match state {
+ ProfileDisplayState::Loaded(data) => Some(data),
+ ProfileDisplayState::Loading(_) => None,
+ ProfileDisplayState::Failed => return Err(ProfileMissingError),
+ })
+ }
+
+ pub fn get_image(
+ &mut self,
+ address: Address,
+ ) -> Result>, ProfileMissingError> {
+ let profile = self.get_data(address)?;
+ let Some(profile) = profile else {
+ return Ok(None);
+ };
+ let Some(path) = profile.content.avatar.snapshots.as_ref().map(|snapshots| {
+ let url = format!("{}{}", profile.base_url, snapshots.face256);
+ let ipfs_path = IpfsPath::new_from_url(&url, "png");
+ PathBuf::from(&ipfs_path)
+ }) else {
+ return Err(ProfileMissingError);
+ };
+ Ok(Some(self.ipfs.asset_server().load(path)))
+ }
+
+ pub fn get_name(&mut self, address: Address) -> Result, ProfileMissingError> {
+ Ok(self.get_data(address)?.map(|profile| &profile.content.name))
+ }
+
+ pub fn update(&mut self, profile: UserProfile) {
+ if let Some(address) = profile.content.eth_address.as_h160() {
+ self.cache
+ .0
+ .insert(address, ProfileDisplayState::Loaded(Box::new(profile)));
+ }
}
}
@@ -63,6 +139,7 @@ pub fn setup_primary_profile(
ipfas: IpfsAssetServer,
images: Res>,
mut global_crdt: ResMut,
+ mut cache: ProfileManager,
) {
// gather any event receivers
for sender in subscribe_events.read().filter_map(|ev| match ev {
@@ -82,6 +159,9 @@ pub fn setup_primary_profile(
// update component
commands.entity(player).try_insert(profile.clone());
+ // update cache
+ cache.update(profile.clone());
+
// send to scenes
global_crdt.update_crdt(
SceneComponentId::PLAYER_IDENTITY_DATA,
@@ -161,6 +241,7 @@ pub fn setup_primary_profile(
.avatar
.snapshots = Some(AvatarSnapshots { face256, body });
current_profile.snapshots = None;
+ cache.update(current_profile.profile.clone().unwrap());
}
Some(Err(e)) => {
error!("failed to deploy profile: {e}");
@@ -237,6 +318,7 @@ pub fn process_profile_events(
transports: Query<&Transport>,
current_profile: Res,
mut global_crdt: ResMut,
+ mut cache: ProfileManager,
) {
for ev in events.read() {
match &ev.event {
@@ -325,6 +407,8 @@ pub fn process_profile_events(
},
);
+ cache.update(profile.clone());
+
if let Some(mut existing_profile) = maybe_profile {
if existing_profile.as_ref() != &profile {
*existing_profile = profile;
@@ -342,7 +426,7 @@ pub fn process_profile_events(
last_sent_request.retain(|_, req_time| *req_time > time.elapsed_seconds() - 10.0);
}
-#[derive(Component, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+#[derive(Component, Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Default)]
pub struct UserProfile {
pub version: u32,
pub content: SerializedProfile,
diff --git a/crates/dcl_component/Cargo.toml b/crates/dcl_component/Cargo.toml
index 4f990bf5..2e6cb1c4 100644
--- a/crates/dcl_component/Cargo.toml
+++ b/crates/dcl_component/Cargo.toml
@@ -9,6 +9,9 @@ edition = "2021"
bevy = { workspace = true }
prost = { workspace = true }
serde = { workspace = true }
+dcl-rpc = { workspace = true }
+async-trait = { workspace = true }
[build-dependencies]
-prost-build = "0.11.8"
\ No newline at end of file
+prost-build = "0.11.8"
+dcl-rpc = { workspace = true }
diff --git a/crates/dcl_component/build.rs b/crates/dcl_component/build.rs
index 284fafde..8c3f128c 100644
--- a/crates/dcl_component/build.rs
+++ b/crates/dcl_component/build.rs
@@ -1,5 +1,5 @@
use std::io::Result;
-fn main() -> Result<()> {
+fn gen_sdk_components() -> Result<()> {
let components = [
"engine_info",
"billboard",
@@ -57,6 +57,7 @@ fn main() -> Result<()> {
sources.push("src/proto/decentraland/kernel/comms/rfc5/ws_comms.proto".into());
sources.push("src/proto/decentraland/kernel/comms/rfc4/comms.proto".into());
sources.push("src/proto/decentraland/kernel/comms/v3/archipelago.proto".into());
+ sources.push("src/proto/decentraland/social/friendships/friendships.proto".into());
let serde_components = ["Color3"];
@@ -73,3 +74,20 @@ fn main() -> Result<()> {
Ok(())
}
+
+fn gen_social_service() -> Result<()> {
+ let mut conf = prost_build::Config::new();
+ conf.service_generator(Box::new(dcl_rpc::codegen::RPCServiceGenerator::new()));
+ conf.type_attribute("*", "#[derive(Debug)]");
+ conf.compile_protos(
+ &["src/proto/decentraland/social/friendships/friendships.proto"],
+ &["src/proto"],
+ )?;
+ Ok(())
+}
+
+fn main() -> Result<()> {
+ gen_sdk_components()?;
+ gen_social_service()?;
+ Ok(())
+}
diff --git a/crates/dcl_component/src/proto_components.rs b/crates/dcl_component/src/proto_components.rs
index 50399a9f..ebcec2b5 100644
--- a/crates/dcl_component/src/proto_components.rs
+++ b/crates/dcl_component/src/proto_components.rs
@@ -40,6 +40,13 @@ pub mod common {
include!(concat!(env!("OUT_DIR"), "/decentraland.common.rs"));
}
+pub mod social {
+ include!(concat!(
+ env!("OUT_DIR"),
+ "/decentraland.social.friendships.rs"
+ ));
+}
+
trait DclProtoComponent: prost::Message + Default {}
impl FromDclReader for T {
diff --git a/crates/scene_runner/src/update_world/material.rs b/crates/scene_runner/src/update_world/material.rs
index f4702c21..61cbab4a 100644
--- a/crates/scene_runner/src/update_world/material.rs
+++ b/crates/scene_runner/src/update_world/material.rs
@@ -9,8 +9,8 @@ use bevy::{
texture::{ImageAddressMode, ImageFilterMode, ImageSampler, ImageSamplerDescriptor},
},
};
-use common::structs::{AppConfig, AvatarTextureHandle};
-use comms::profile::UserProfile;
+use common::{structs::AppConfig, util::AsH160};
+use comms::profile::ProfileManager;
use ipfs::{ipfs_path::IpfsPath, IpfsAssetServer};
use crate::{
@@ -229,7 +229,7 @@ pub struct TextureResolver<'w, 's> {
ipfas: IpfsAssetServer<'w, 's>,
videos: Query<'w, 's, &'static VideoTextureOutput>,
uis: Query<'w, 's, &'static UiTextureOutput>,
- avatars: Query<'w, 's, (&'static UserProfile, &'static AvatarTextureHandle)>,
+ profiles: ProfileManager<'w, 's>,
}
#[derive(Debug)]
@@ -241,7 +241,7 @@ pub struct ResolvedTexture {
impl<'w, 's> TextureResolver<'w, 's> {
pub fn resolve_texture(
- &self,
+ &mut self,
scene: &RendererSceneContext,
texture: &texture_union::Tex,
) -> Result {
@@ -257,16 +257,23 @@ impl<'w, 's> TextureResolver<'w, 's> {
camera_target: None,
})
}
- texture_union::Tex::AvatarTexture(at) => self
- .avatars
- .iter()
- .find(|(profile, _)| profile.content.eth_address == at.user_id)
- .map(|(_, tex)| ResolvedTexture {
- image: tex.0.clone(),
+ texture_union::Tex::AvatarTexture(at) => {
+ let h160 = at
+ .user_id
+ .as_h160()
+ .ok_or(TextureResolveError::AvatarNotFound)?;
+ let image = self
+ .profiles
+ .get_image(h160)
+ .map_err(|_| TextureResolveError::AvatarNotFound)?
+ .ok_or(TextureResolveError::SourceNotReady)?;
+
+ Ok(ResolvedTexture {
+ image,
source_entity: None,
camera_target: None,
})
- .ok_or(TextureResolveError::AvatarNotFound),
+ }
texture_union::Tex::VideoTexture(vt) => {
let Some(video_entity) =
scene.bevy_entity(SceneEntityId::from_proto_u32(vt.video_player_entity))
@@ -333,7 +340,7 @@ fn update_materials(
>,
mut materials: ResMut>,
sourced: Query<(Entity, &Handle, &MaterialSource)>,
- resolver: TextureResolver,
+ mut resolver: TextureResolver,
mut scenes: Query<&mut RendererSceneContext>,
config: Res,
mut gltf_resolver: GltfMaterialResolver,
diff --git a/crates/scene_runner/src/update_world/pointer_events.rs b/crates/scene_runner/src/update_world/pointer_events.rs
index 514c6a8e..3d463db6 100644
--- a/crates/scene_runner/src/update_world/pointer_events.rs
+++ b/crates/scene_runner/src/update_world/pointer_events.rs
@@ -1,5 +1,5 @@
use bevy::prelude::*;
-use common::structs::ToolTips;
+use common::structs::{ToolTips, TooltipSource};
use input_manager::InputMap;
use crate::update_scene::pointer_results::{PointerTarget, PointerTargetInfo};
@@ -74,5 +74,7 @@ fn hover_text(
}
}
- tooltip.0.insert("pointer_events", texts);
+ tooltip
+ .0
+ .insert(TooltipSource::Label("pointer_events"), texts);
}
diff --git a/crates/scene_runner/src/update_world/scene_ui/ui_background.rs b/crates/scene_runner/src/update_world/scene_ui/ui_background.rs
index a1f1a278..cc94cb27 100644
--- a/crates/scene_runner/src/update_world/scene_ui/ui_background.rs
+++ b/crates/scene_runner/src/update_world/scene_ui/ui_background.rs
@@ -98,7 +98,7 @@ pub fn set_ui_background(
children: Query<&Children>,
prev_backgrounds: Query>,
contexts: Query<&RendererSceneContext>,
- resolver: TextureResolver,
+ mut resolver: TextureResolver,
mut stretch_uvs: ResMut>,
) {
for ent in removed.read() {
diff --git a/crates/social/Cargo.toml b/crates/social/Cargo.toml
new file mode 100644
index 00000000..67be9d32
--- /dev/null
+++ b/crates/social/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "social"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+
+[dependencies]
+common = { workspace = true }
+comms = { workspace = true }
+dcl = { workspace = true }
+dcl_component = { workspace = true }
+ipfs = { workspace = true }
+wallet = { workspace = true }
+
+bevy = { workspace = true }
+bevy_egui = { workspace = true }
+bevy_dui = { workspace = true }
+bevy_console = { workspace = true }
+urn = { workspace = true }
+ethers-core = { workspace = true }
+ethers-signers = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+isahc = { workspace = true }
+tokio = { workspace = true }
+anyhow = { workspace = true }
+chrono = { workspace = true }
+clap = { workspace = true }
+opener = { workspace = true }
+urlencoding = { workspace = true }
+build-time = { workspace = true }
+
+futures-lite = { workspace = true }
+
+async-tungstenite = { workspace = true }
+
+prost = { workspace = true }
+dcl-rpc = { workspace = true }
+futures-util = { workspace = true }
+
+matrix-sdk = { version = "0.7.1", default-features = false, features = ["e2e-encryption", "rustls-tls"] }
diff --git a/crates/social/src/client.rs b/crates/social/src/client.rs
new file mode 100644
index 00000000..33eae868
--- /dev/null
+++ b/crates/social/src/client.rs
@@ -0,0 +1,753 @@
+use anyhow::anyhow;
+use bevy::{
+ log::{debug, warn},
+ tasks::IoTaskPool,
+ utils::{HashMap, HashSet},
+};
+use common::util::AsH160;
+use dcl_component::proto_components::social::{
+ friendship_event_payload, friendship_event_response, request_events_response,
+ subscribe_friendship_events_updates_response, users_response, AcceptPayload, CancelPayload,
+ DeletePayload, FriendshipEventPayload, FriendshipsServiceClient,
+ FriendshipsServiceClientDefinition, Payload, RejectPayload, RequestEvents, RequestPayload,
+ RequestResponse, SubscribeFriendshipEventsUpdatesResponse, UpdateFriendshipPayload, User,
+ Users,
+};
+use dcl_rpc::{client::RpcClient, transports::web_sockets::WebSocketTransport};
+use ethers_core::types::Address;
+use futures_util::{pin_mut, select, FutureExt};
+use matrix_sdk::{
+ config::SyncSettings,
+ event_handler::Ctx,
+ room::MessagesOptions,
+ ruma::{
+ api::client::{
+ filter::{FilterDefinition, RoomEventFilter},
+ receipt::create_receipt::v3::ReceiptType,
+ },
+ events::{
+ receipt::ReceiptThread,
+ room::message::{MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent},
+ AnyMessageLikeEventContent, AnyTimelineEvent, MessageLikeEventType,
+ },
+ RoomOrAliasId, UserId,
+ },
+ Room, RoomMemberships,
+};
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc::{self, channel, Receiver, Sender, UnboundedReceiver, UnboundedSender};
+use wallet::SimpleAuthChain;
+
+#[derive(Serialize, Deserialize)]
+struct SocialIdentifier {
+ r#type: String,
+ user: String,
+}
+
+impl SocialIdentifier {
+ fn new(address: Address) -> Self {
+ Self {
+ r#type: "m.id.user".to_owned(),
+ user: format!("{:#x}", address),
+ }
+ }
+}
+
+#[derive(Serialize)]
+struct SocialLogin {
+ auth_chain: SimpleAuthChain,
+ identifier: SocialIdentifier,
+ timestamp: String,
+ r#type: String,
+}
+
+impl SocialLogin {
+ async fn try_new(wallet: &wallet::Wallet) -> Result {
+ let timestamp: chrono::DateTime = std::time::SystemTime::now().into();
+ let timestamp = format!("{}", timestamp.timestamp_millis());
+
+ let auth_chain = wallet
+ .sign_message(timestamp.clone())
+ .await
+ .map_err(dbgerr)?;
+ let identifier = SocialIdentifier::new(wallet.address().ok_or(anyhow!("not connected"))?);
+
+ Ok(Self {
+ auth_chain,
+ identifier,
+ timestamp,
+ r#type: "m.login.decentraland".to_owned(),
+ })
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct DirectChatMessage {
+ pub partner: Address,
+ pub me_speaking: bool,
+ pub message: String,
+}
+
+enum FriendData {
+ Init {
+ sent_requests: HashSet,
+ received_requests: HashMap>,
+ friends: HashSet,
+ },
+ Event(friendship_event_response::Body),
+ Chat(DirectChatMessage),
+}
+
+enum FriendshipOutbound {
+ FriendshipEvent(FriendshipEventPayload),
+ ChatMessage(DirectChatMessage),
+ HistoryRequest(Address, Sender),
+}
+
+pub struct SocialClientHandler {
+ sender: UnboundedSender,
+ friendship_receiver: UnboundedReceiver,
+
+ pub is_initialized: bool,
+ pub sent_requests: HashSet,
+ pub received_requests: HashMap>,
+ pub friends: HashSet,
+
+ pub unread_messages: HashMap,
+
+ friend_event_callback: Box,
+ chat_event_callback: Box,
+}
+
+impl SocialClientHandler {
+ pub fn connect(
+ wallet: wallet::Wallet,
+ friend_callback: impl Fn(&friendship_event_response::Body) + Send + Sync + 'static,
+ chat_callback: impl Fn(DirectChatMessage) + Send + Sync + 'static,
+ ) -> Option {
+ let (event_sx, event_rx) = mpsc::unbounded_channel();
+ let (response_sx, response_rx) = mpsc::unbounded_channel();
+
+ IoTaskPool::get()
+ .spawn(social_socket_handler(wallet, event_rx, response_sx))
+ .detach();
+ Some(Self {
+ is_initialized: false,
+ sender: event_sx,
+ friendship_receiver: response_rx,
+ sent_requests: Default::default(),
+ received_requests: Default::default(),
+ friends: Default::default(),
+ unread_messages: Default::default(),
+ friend_event_callback: Box::new(friend_callback),
+ chat_event_callback: Box::new(chat_callback),
+ })
+ }
+
+ pub fn live(&self) -> bool {
+ !self.friendship_receiver.is_closed()
+ }
+
+ pub fn friend_request(
+ &mut self,
+ address: Address,
+ message: Option,
+ ) -> Result<(), anyhow::Error> {
+ self.sender.send(FriendshipOutbound::FriendshipEvent(
+ FriendshipEventPayload {
+ body: Some(friendship_event_payload::Body::Request(RequestPayload {
+ user: Some(User {
+ address: format!("{address:#x}"),
+ }),
+ message,
+ })),
+ },
+ ))?;
+ self.sent_requests.insert(address);
+ Ok(())
+ }
+
+ pub fn cancel_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+ self.sender.send(FriendshipOutbound::FriendshipEvent(
+ FriendshipEventPayload {
+ body: Some(friendship_event_payload::Body::Cancel(CancelPayload {
+ user: Some(User {
+ address: format!("{address:#x}"),
+ }),
+ })),
+ },
+ ))?;
+ self.sent_requests.remove(&address);
+ Ok(())
+ }
+
+ pub fn accept_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+ if self.received_requests.remove(&address).is_none() {
+ return Err(anyhow!("no request"));
+ };
+
+ self.sender.send(FriendshipOutbound::FriendshipEvent(
+ FriendshipEventPayload {
+ body: Some(friendship_event_payload::Body::Accept(AcceptPayload {
+ user: Some(User {
+ address: format!("{address:#x}"),
+ }),
+ })),
+ },
+ ))?;
+ self.friends.insert(address);
+ Ok(())
+ }
+
+ pub fn reject_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+ if self.received_requests.remove(&address).is_none() {
+ return Err(anyhow!("no request"));
+ };
+
+ self.sender.send(FriendshipOutbound::FriendshipEvent(
+ FriendshipEventPayload {
+ body: Some(friendship_event_payload::Body::Reject(RejectPayload {
+ user: Some(User {
+ address: format!("{address:#x}"),
+ }),
+ })),
+ },
+ ))?;
+ Ok(())
+ }
+
+ pub fn delete_friend(&mut self, address: Address) -> Result<(), anyhow::Error> {
+ if !self.friends.remove(&address) {
+ return Err(anyhow!("no request"));
+ };
+
+ self.sender.send(FriendshipOutbound::FriendshipEvent(
+ FriendshipEventPayload {
+ body: Some(friendship_event_payload::Body::Delete(DeletePayload {
+ user: Some(User {
+ address: format!("{address:#x}"),
+ }),
+ })),
+ },
+ ))?;
+ Ok(())
+ }
+
+ pub fn chat(&self, address: Address, message: String) -> Result<(), anyhow::Error> {
+ self.sender
+ .send(FriendshipOutbound::ChatMessage(DirectChatMessage {
+ partner: address,
+ me_speaking: true,
+ message,
+ }))
+ .map_err(dbgerr)
+ }
+
+ pub fn get_chat_history(
+ &self,
+ address: Address,
+ ) -> Result, anyhow::Error> {
+ let (sx, rx) = channel(1);
+ self.sender
+ .send(FriendshipOutbound::HistoryRequest(address, sx))?;
+ Ok(rx)
+ }
+
+ pub fn mark_as_read(&mut self, address: Address) {
+ self.unread_messages.remove(&address);
+ }
+
+ pub fn unread_messages(&self) -> &HashMap {
+ &self.unread_messages
+ }
+
+ pub fn update(&mut self) {
+ while let Ok(rec) = self.friendship_receiver.try_recv() {
+ match rec {
+ FriendData::Init {
+ sent_requests,
+ received_requests,
+ friends,
+ } => {
+ self.received_requests = received_requests;
+ self.sent_requests = sent_requests;
+ self.friends = friends;
+ self.is_initialized = true;
+ }
+ FriendData::Event(ev) => {
+ (self.friend_event_callback)(&ev);
+ match ev {
+ friendship_event_response::Body::Request(body) => {
+ let Some(address) =
+ body.user.as_ref().and_then(|u| u.address.as_h160())
+ else {
+ warn!("invalid friend request (no address): {body:?}");
+ continue;
+ };
+ self.received_requests.insert(address, body.message);
+ }
+ friendship_event_response::Body::Accept(body) => {
+ let Some(address) =
+ body.user.as_ref().and_then(|u| u.address.as_h160())
+ else {
+ warn!("invalid friend accept (no address): {body:?}");
+ continue;
+ };
+ self.sent_requests.remove(&address);
+ self.friends.insert(address);
+ }
+ friendship_event_response::Body::Reject(body) => {
+ let Some(address) =
+ body.user.as_ref().and_then(|u| u.address.as_h160())
+ else {
+ warn!("invalid friend reject (no address): {body:?}");
+ continue;
+ };
+ self.sent_requests.remove(&address);
+ }
+ friendship_event_response::Body::Delete(body) => {
+ let Some(address) =
+ body.user.as_ref().and_then(|u| u.address.as_h160())
+ else {
+ warn!("invalid friend delete (no address): {body:?}");
+ continue;
+ };
+ self.friends.remove(&address);
+ }
+ friendship_event_response::Body::Cancel(body) => {
+ let Some(address) =
+ body.user.as_ref().and_then(|u| u.address.as_h160())
+ else {
+ warn!("invalid friend accept (no address): {body:?}");
+ continue;
+ };
+ self.received_requests.remove(&address);
+ }
+ }
+ }
+ FriendData::Chat(chat) => {
+ if !chat.me_speaking {
+ *self.unread_messages.entry(chat.partner).or_default() += 1;
+ }
+ (self.chat_event_callback)(chat);
+ }
+ }
+ }
+ }
+}
+
+async fn social_socket_handler(
+ wallet: wallet::Wallet,
+ event_rx: UnboundedReceiver,
+ response_sx: UnboundedSender,
+) {
+ let rt = std::sync::Arc::new(
+ tokio::runtime::Builder::new_current_thread()
+ .enable_all()
+ .build()
+ .unwrap(),
+ );
+ if let Err(e) = rt.block_on(social_socket_handler_inner(
+ wallet.clone(),
+ event_rx,
+ response_sx,
+ )) {
+ warn!("social socket handler print: {e}");
+ } else {
+ debug!("k");
+ }
+}
+
+fn dbgerr(e: E) -> anyhow::Error {
+ anyhow!(format!("{e:?}"))
+}
+
+async fn social_socket_handler_inner(
+ wallet: wallet::Wallet,
+ mut rx: UnboundedReceiver,
+ response_sx: UnboundedSender,
+) -> Result<(), anyhow::Error> {
+ let req = SocialLogin::try_new(&wallet).await?;
+ let req = serde_json::to_value(&req)
+ .unwrap()
+ .as_object()
+ .unwrap()
+ .clone();
+ let matrix_client = matrix_sdk::Client::builder()
+ .homeserver_url("https://social.decentraland.org")
+ .build()
+ .await?;
+ let login = matrix_client
+ .matrix_auth()
+ .login_custom("m.login.decentraland", req)
+ .unwrap()
+ .send()
+ .await?;
+ let synapse_token = login.access_token;
+
+ // create connection
+ let service_connection =
+ dcl_rpc::transports::web_sockets::tungstenite::WebSocketClient::connect(
+ "wss://rpc-social-service.decentraland.org",
+ )
+ .await
+ .map_err(dbgerr)?;
+ let service_transport = WebSocketTransport::new(service_connection);
+ let mut service_client = RpcClient::new(service_transport).await.unwrap();
+ let port = service_client.create_port("whatever").await.unwrap();
+ let service_module = port
+ .load_module::>("FriendshipsService")
+ .await
+ .map_err(dbgerr)?;
+
+ // gather and send initial data
+ let mut friends_req = service_module
+ .get_friends(Payload {
+ synapse_token: Some(synapse_token.clone()),
+ })
+ .await
+ .map_err(dbgerr)?;
+ let requests_req = service_module
+ .get_request_events(Payload {
+ synapse_token: Some(synapse_token.clone()),
+ })
+ .await
+ .map_err(dbgerr)?;
+
+ let mut friends = HashSet::default();
+ while let Some(f) = friends_req.next().await {
+ if let Some(users_response::Response::Users(Users { users })) = f.response {
+ for user in users {
+ if let Some(address) = user.address.as_h160() {
+ friends.insert(address);
+ }
+ }
+ }
+ }
+
+ let mut received_requests = HashMap::default();
+ let mut sent_requests = HashSet::default();
+ if let Some(request_events_response::Response::Events(RequestEvents { incoming, outgoing })) =
+ requests_req.response
+ {
+ if let Some(incoming) = incoming {
+ for RequestResponse { user, message, .. } in incoming.items {
+ if let Some(address) = user.and_then(|u| u.address.as_h160()) {
+ received_requests.insert(address, message);
+ }
+ }
+ }
+ if let Some(outgoing) = outgoing {
+ for RequestResponse { user, .. } in outgoing.items {
+ if let Some(address) = user.and_then(|u| u.address.as_h160()) {
+ sent_requests.insert(address);
+ }
+ }
+ }
+ }
+
+ response_sx.send(FriendData::Init {
+ sent_requests,
+ received_requests,
+ friends,
+ })?;
+
+ // build workers
+ let mut inbound_service_events = service_module
+ .subscribe_friendship_events_updates(Payload {
+ synapse_token: Some(synapse_token.clone()),
+ })
+ .await
+ .map_err(dbgerr)?;
+
+ // demux the received data
+ let (sx_friend, mut rx_friend) = mpsc::channel(10);
+ let (sx_chat, mut rx_chat) = mpsc::channel(10);
+ let (sx_history, mut rx_history) = mpsc::channel(10);
+ tokio::spawn(async move {
+ while let Some(message) = rx.recv().await {
+ match message {
+ FriendshipOutbound::FriendshipEvent(data) => {
+ let _ = sx_friend.send(data).await;
+ }
+ FriendshipOutbound::ChatMessage(chat) => {
+ let _ = sx_chat.send(chat).await;
+ }
+ FriendshipOutbound::HistoryRequest(address, sender) => {
+ let _ = sx_history.send((address, sender)).await;
+ }
+ }
+ }
+ });
+
+ struct RoomAliasConverter(String);
+ impl RoomAliasConverter {
+ fn as_ref(&self) -> Result<&RoomOrAliasId, anyhow::Error> {
+ self.0.as_str().try_into().map_err(dbgerr)
+ }
+ }
+
+ let room_alias = |other: Address| -> Result {
+ let me = format!(
+ "{:#x}",
+ wallet.address().ok_or(anyhow!("wallet disconnected!"))?
+ );
+ let other = format!("{other:#x}");
+ let alias = format!(
+ "#{}+{}:{}",
+ (&me).min(&other),
+ (&me).max(&other),
+ "decentraland.org"
+ )
+ .to_ascii_lowercase();
+ Ok(RoomAliasConverter(alias))
+ };
+
+ // outbound matrix events
+ let client = matrix_client.clone();
+ let f_matrix_write = async move {
+ while let Some(chat) = rx_chat.recv().await {
+ let alias = room_alias(chat.partner)?;
+ match client.join_room_by_id_or_alias(alias.as_ref()?, &[]).await {
+ Err(e) => {
+ warn!("failed to find room for address {:#?}", chat.partner);
+ warn!("err: {e}");
+ continue;
+ }
+ Ok(room) => {
+ room.send(RoomMessageEventContent::text_plain(chat.message))
+ .await?
+ }
+ };
+ }
+
+ Ok(())
+ }
+ .fuse();
+
+ async fn handle_history(
+ address: Address,
+ alias: RoomAliasConverter,
+ client: matrix_sdk::Client,
+ sx: Sender,
+ ) -> Result<(), anyhow::Error> {
+ warn!("history requested for {address:#?}");
+ let room = client
+ .join_room_by_id_or_alias(alias.as_ref()?, &[])
+ .await?;
+ let mut token = None;
+ let mut filter = RoomEventFilter::default();
+ filter.types = Some(vec!["m.room.message".to_owned()]);
+
+ loop {
+ let mut options = MessagesOptions::backward();
+ options.limit = 10u32.into();
+ options.filter = filter.clone();
+ options.from = token.take();
+
+ let history = room.messages(options).await?;
+ debug!("got -> {:?}", (&history.start, &history.end));
+ for event in history.chunk {
+ if let Ok(AnyTimelineEvent::MessageLike(m)) = event.event.deserialize() {
+ if m.event_type() == MessageLikeEventType::RoomMessage {
+ let Some(sender) = matrix_to_h160(m.sender()) else {
+ warn!("no h160 from {:?}", m.sender());
+ continue;
+ };
+ let Some(AnyMessageLikeEventContent::RoomMessage(content)) =
+ m.original_content()
+ else {
+ continue;
+ };
+ let MessageType::Text(text_content) = content.msgtype else {
+ continue;
+ };
+ sx.send(DirectChatMessage {
+ partner: address,
+ me_speaking: address != sender,
+ message: text_content.body,
+ })
+ .await?;
+ }
+ }
+ }
+ debug!("next -> {:?}", &history.end);
+ token = history.end;
+ if token.is_none() {
+ return Ok(());
+ }
+ }
+ }
+
+ // history requests
+ let client = matrix_client.clone();
+ let f_matrix_history = async move {
+ while let Some((address, sx)) = rx_history.recv().await {
+ let Ok(alias) = room_alias(address) else {
+ warn!("failed to get room alias");
+ continue;
+ };
+ let client = client.clone();
+ tokio::spawn(async move {
+ if let Err(e) = handle_history(address, alias, client, sx).await {
+ warn!("history err: {e}");
+ }
+ });
+ }
+ Result::<(), anyhow::Error>::Ok(())
+ }
+ .fuse();
+
+ // outbound service events
+ let f_service_write = async move {
+ while let Some(req) = rx_friend.recv().await {
+ service_module
+ .update_friendship_event(UpdateFriendshipPayload {
+ event: Some(req),
+ auth_token: Some(Payload {
+ synapse_token: Some(synapse_token.clone()),
+ }),
+ })
+ .await
+ .map_err(dbgerr)?;
+ }
+ Result::<(), anyhow::Error>::Ok(())
+ }
+ .fuse();
+
+ // inbound service events
+ let sx = response_sx.clone();
+ let f_service_read = async move {
+ while let Some(SubscribeFriendshipEventsUpdatesResponse {
+ response: Some(response),
+ }) = inbound_service_events.next().await
+ {
+ match response {
+ subscribe_friendship_events_updates_response::Response::Events(evs) => {
+ for ev in evs.responses.into_iter().flat_map(|r| r.body) {
+ sx.send(FriendData::Event(ev)).map_err(dbgerr)?;
+ }
+ }
+ other => return Err(dbgerr(other)),
+ }
+ }
+
+ Ok(())
+ }
+ .fuse();
+
+ fn matrix_to_h160(s: &UserId) -> Option {
+ let base = s.as_str().get(1..)?;
+ base.split_once(':')
+ .map(|(init, _)| init)
+ .unwrap_or(base)
+ .as_h160()
+ }
+
+ #[derive(Clone)]
+ pub struct IsStartup(bool);
+
+ // fn as async closures are unstable
+ async fn handle_message(
+ event: OriginalSyncRoomMessageEvent,
+ room: Room,
+ response_sx: Ctx>,
+ is_startup: Ctx,
+ client: matrix_sdk::Client,
+ ) {
+ debug!("inbound process {event:?}");
+ let Some(sender) = matrix_to_h160(&event.sender) else {
+ debug!("skip 1");
+ return;
+ };
+ let MessageType::Text(text_content) = event.content.msgtype else {
+ debug!("skip 3");
+ return;
+ };
+ let Some(user) = client.user_id() else {
+ debug!("skip 4");
+ return;
+ };
+
+ let Ok(members) = room.members(RoomMemberships::all()).await else {
+ warn!("failed to fetch members");
+ return;
+ };
+ let Some(partner) = members
+ .iter()
+ .filter(|member| !member.is_account_user())
+ .flat_map(|member| matrix_to_h160(member.user_id()))
+ .next()
+ else {
+ warn!("failed to determine partner");
+ return;
+ };
+
+ if (*is_startup).0 {
+ // skip if last read event is this event (we only read 1 so this should be fine, otherwise we'd need to fetch the receipt event as well to compare age)
+ let read_receipt_event_id = room
+ .load_user_receipt(
+ matrix_sdk::ruma::events::receipt::ReceiptType::Read,
+ ReceiptThread::Unthreaded,
+ user,
+ )
+ .await
+ .unwrap_or(None);
+ if read_receipt_event_id.map_or(false, |receipt| receipt.0 == event.event_id) {
+ debug!("skip on read");
+ return;
+ }
+ }
+
+ let _ = response_sx.send(FriendData::Chat(DirectChatMessage {
+ partner,
+ me_speaking: sender != partner,
+ message: text_content.body,
+ }));
+ if let Err(e) = room
+ .send_single_receipt(ReceiptType::Read, ReceiptThread::Unthreaded, event.event_id)
+ .await
+ {
+ debug!("receipt err: {e:?}");
+ };
+ debug!("processed");
+ }
+
+ // inbound matrix events
+ matrix_client.add_event_handler(handle_message);
+ matrix_client.add_event_handler_context(response_sx.clone());
+ matrix_client.add_event_handler_context(IsStartup(true));
+
+ let f_matrix_read = async move {
+ // limit initial history to 1 message so we can check for unread
+ let mut filter = FilterDefinition::default();
+ filter.room.timeline.types = Some(vec!["m.room.message".to_owned()]);
+ filter.room.timeline.limit = Some(1u32.into());
+ let settings = SyncSettings::default().filter(filter.into());
+ matrix_client.sync(settings).await.map_err(dbgerr)?;
+ matrix_client.add_event_handler_context(IsStartup(false));
+ loop {
+ matrix_client
+ .sync(SyncSettings::default())
+ .await
+ .map_err(dbgerr)?;
+ }
+ }
+ .fuse();
+
+ // until a stream is broken
+ pin_mut!(
+ f_service_read,
+ f_matrix_read,
+ f_service_write,
+ f_matrix_write,
+ f_matrix_history,
+ );
+ select! {
+ r = f_service_read => r,
+ r = f_matrix_read => r,
+ r = f_service_write => r,
+ r = f_matrix_write => r,
+ r = f_matrix_history => r,
+ }
+}
diff --git a/crates/social/src/lib.rs b/crates/social/src/lib.rs
new file mode 100644
index 00000000..f7261f78
--- /dev/null
+++ b/crates/social/src/lib.rs
@@ -0,0 +1,93 @@
+pub mod client;
+
+use bevy::prelude::*;
+use client::{DirectChatMessage, SocialClientHandler};
+use common::util::FireEventEx;
+use dcl_component::proto_components::social::friendship_event_response;
+use ethers_core::types::Address;
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+use wallet::Wallet;
+
+pub struct SocialPlugin;
+
+impl Plugin for SocialPlugin {
+ fn build(&self, app: &mut bevy::prelude::App) {
+ app.add_event::();
+ app.add_event::();
+ app.init_resource::();
+ app.add_systems(PostUpdate, |mut client: ResMut| {
+ if let Some(client) = client.0.as_mut() {
+ client.update();
+ }
+ });
+ app.add_systems(PostUpdate, init_social_client);
+ }
+}
+
+pub fn init_social_client(
+ mut commands: Commands,
+ wallet: Res,
+ mut social: ResMut,
+ mut friends: Local>>,
+ mut chats: Local>>,
+) {
+ if wallet.is_changed() && wallet.address().is_some() {
+ let (f_sx, f_rx) = unbounded_channel();
+ let (c_sx, c_rx) = unbounded_channel();
+ let client = SocialClientHandler::connect(
+ wallet.clone(),
+ move |f| {
+ let _ = f_sx.send(FriendshipEvent(Some(f.clone())));
+ },
+ move |c| {
+ let _ = c_sx.send(DirectChatEvent(c));
+ },
+ );
+ social.0 = client;
+ *friends = Some(f_rx);
+ *chats = Some(c_rx);
+ }
+
+ while let Some(f) = friends.as_mut().and_then(|rx| rx.try_recv().ok()) {
+ commands.fire_event(f);
+ }
+ while let Some(c) = chats.as_mut().and_then(|rx| rx.try_recv().ok()) {
+ commands.fire_event(c);
+ }
+}
+
+#[derive(Resource, Default)]
+pub struct SocialClient(pub Option);
+
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+pub enum FriendshipState {
+ NotFriends,
+ SentRequest,
+ RecdRequested,
+ Friends,
+ Error,
+}
+
+impl SocialClient {
+ pub fn get_state(&self, address: Address) -> FriendshipState {
+ let Some(client) = self.0.as_ref() else {
+ return FriendshipState::Error;
+ };
+ if client.friends.contains(&address) {
+ return FriendshipState::Friends;
+ }
+ if client.sent_requests.contains(&address) {
+ return FriendshipState::SentRequest;
+ }
+ if client.received_requests.contains_key(&address) {
+ return FriendshipState::RecdRequested;
+ }
+ FriendshipState::NotFriends
+ }
+}
+
+#[derive(Event)]
+pub struct FriendshipEvent(pub Option);
+
+#[derive(Event)]
+pub struct DirectChatEvent(pub DirectChatMessage);
diff --git a/crates/system_ui/Cargo.toml b/crates/system_ui/Cargo.toml
index 7fda3e61..f8a966d6 100644
--- a/crates/system_ui/Cargo.toml
+++ b/crates/system_ui/Cargo.toml
@@ -26,6 +26,7 @@ console = { workspace = true }
scene_material = { workspace = true }
world_ui = { workspace = true }
analytics = { workspace = true }
+social = { workspace = true }
bevy = { workspace = true }
bevy_egui = { workspace = true }
diff --git a/crates/system_ui/src/chat/conversation_manager.rs b/crates/system_ui/src/chat/conversation_manager.rs
new file mode 100644
index 00000000..369d90a0
--- /dev/null
+++ b/crates/system_ui/src/chat/conversation_manager.rs
@@ -0,0 +1,247 @@
+use bevy::{core::FrameCount, ecs::system::SystemParam, prelude::*};
+use bevy_dui::{DuiCommandsExt, DuiEntities, DuiProps, DuiRegistry};
+use common::{structs::ShowProfileEvent, util::TryPushChildrenEx};
+use copypasta::{ClipboardContext, ClipboardProvider};
+use ethers_core::types::Address;
+use scene_runner::Toaster;
+use ui_core::ui_actions::{Click, EventCloneExt, On, UiCaller};
+use wallet::Wallet;
+
+use crate::chat::friends::PendingProfileUiImage;
+
+use super::friends::PrivateChat;
+
+#[derive(Component)]
+pub struct ChatBubble(pub Option, pub Color);
+
+#[allow(clippy::type_complexity)]
+#[derive(SystemParam)]
+pub struct ConversationManager<'w, 's> {
+ children: Query<'w, 's, &'static Children>,
+ containers: Query<'w, 's, (&'static ChatBubble, &'static DuiEntities)>,
+ commands: Commands<'w, 's>,
+ dui: Res<'w, DuiRegistry>,
+ wallet: Res<'w, Wallet>,
+ frame: Res<'w, FrameCount>,
+ asset_server: Res<'w, AssetServer>,
+ added_this_frame: Local<
+ 's,
+ Option<(
+ u32,
+ Option<(Option, Color, (Entity, Entity))>,
+ Option<(Option, Color, (Entity, Entity))>,
+ )>,
+ >,
+}
+
+impl<'w, 's> ConversationManager<'w, 's> {
+ fn existing_bubble(
+ &self,
+ container: Entity,
+ address: Option,
+ color: Color,
+ historic: bool,
+ ) -> Option<(Entity, Entity)> {
+ if let Some((frame, top, bottom)) = self.added_this_frame.as_ref() {
+ if *frame == self.frame.0 {
+ if let Some((existing_address, existing_color, existing_entity)) =
+ if historic { top } else { bottom }
+ {
+ if *existing_address == address && *existing_color == color {
+ return Some(*existing_entity);
+ } else {
+ return None;
+ }
+ }
+ }
+ }
+
+ let children = self.children.get(container).ok()?;
+
+ let potential_container = if historic {
+ children.iter().next()
+ } else {
+ children.iter().last()
+ }?;
+
+ let (potential_container, entities) = self.containers.get(*potential_container).ok()?;
+ (potential_container.0 == address && potential_container.1 == color)
+ .then_some((entities.root, entities.named("content")))
+ }
+
+ pub fn clear(&mut self, container: Entity) {
+ self.commands.entity(container).despawn_descendants();
+ }
+
+ pub fn add_history_button(&mut self, container: Entity, private_chat_ent: Entity) {
+ let button = self
+ .commands
+ .spawn_template(
+ &self.dui,
+ "button",
+ DuiProps::new()
+ .with_prop("label", "load more history".to_string())
+ .with_prop(
+ "onclick",
+ On::::new(
+ move |mut private_chats: Query<&mut PrivateChat>,
+ caller: Res,
+ parent: Query<&Parent>,
+ mut commands: Commands| {
+ if let Ok(parent) = parent.get(caller.0) {
+ commands.entity(parent.get()).despawn_recursive();
+ }
+ if let Ok(mut chat) = private_chats.get_mut(private_chat_ent) {
+ chat.wants_history_count = 10;
+ }
+ },
+ ),
+ ),
+ )
+ .unwrap()
+ .root;
+
+ self.commands
+ .entity(container)
+ .insert_children(0, &[button]);
+ }
+
+ pub fn get_bubble(
+ &mut self,
+ container: Entity,
+ address: Option,
+ color: Color,
+ historic: bool,
+ ) -> (Entity, Entity) {
+ if let Some((bubble, content)) = self.existing_bubble(container, address, color, historic) {
+ return (bubble, content);
+ }
+
+ let components = if let Some(address) = address {
+ let components = self
+ .commands
+ .spawn_template(
+ &self.dui,
+ "chat-container-other",
+ DuiProps::new().with_prop("color", color),
+ )
+ .unwrap();
+ if address != Address::zero() {
+ self.commands
+ .entity(components.named("image"))
+ .insert(ShowProfileEvent(address).send_value_on::());
+ }
+ components
+ } else {
+ self.commands
+ .spawn_template(
+ &self.dui,
+ "chat-container-me",
+ DuiProps::new().with_prop("color", color),
+ )
+ .unwrap()
+ };
+ if let Some(address) = address.or_else(|| self.wallet.address()) {
+ if address != Address::zero() {
+ self.commands
+ .entity(components.named("image"))
+ .insert(PendingProfileUiImage(address));
+ } else {
+ self.commands
+ .entity(components.named("image"))
+ .insert(UiImage::new(
+ self.asset_server
+ .load("images/backpack/wearable_categories/hat.png"),
+ ));
+ }
+ }
+
+ let bubble = components.root;
+ let content = components.named("content");
+
+ self.commands
+ .entity(bubble)
+ .insert(ChatBubble(address, color));
+
+ let added = self.added_this_frame.get_or_insert_with(Default::default);
+ if added.0 != self.frame.0 {
+ added.0 = self.frame.0;
+ added.1 = None;
+ added.2 = None;
+ }
+ if historic {
+ self.commands
+ .entity(container)
+ .insert_children(0, &[bubble]);
+ added.1 = Some((address, color, (bubble, content)));
+ } else {
+ self.commands.entity(container).push_children(&[bubble]);
+ added.2 = Some((address, color, (bubble, content)));
+ }
+
+ debug!("{:?} -> new {:?}", address, (bubble, content));
+ (bubble, content)
+ }
+
+ pub fn add_message(
+ &mut self,
+ container: Entity,
+ sender: Option,
+ color: Color,
+ message: impl ToString,
+ historic: bool,
+ ) -> (Entity, Entity) {
+ let me_speaking = sender.is_none() || self.wallet.address() == sender;
+ let (bubble, content) = self.get_bubble(
+ container,
+ (!me_speaking).then(|| sender.unwrap()),
+ color,
+ historic,
+ );
+ debug!("container: {content:?}");
+
+ let message_body = message.to_string();
+ let message = self
+ .commands
+ .spawn_template(
+ &self.dui,
+ if me_speaking {
+ "chat-content-me"
+ } else {
+ "chat-content-other"
+ },
+ DuiProps::new()
+ .with_prop("text", message_body.clone())
+ .with_prop(
+ "copy",
+ On::::new(move |mut toaster: Toaster, frame: Res| {
+ let Ok(mut ctx) = ClipboardContext::new() else {
+ warn!("failed to copy");
+ return;
+ };
+
+ if ctx.set_contents(message_body.clone()).is_ok() {
+ toaster.add_toast(
+ format!("chatcopy {}", frame.0),
+ "Message copied to clipboard",
+ );
+ } else {
+ toaster.add_toast(
+ format!("chatcopy {}", frame.0),
+ "Failed to copy message",
+ );
+ }
+ }),
+ ),
+ )
+ .unwrap()
+ .root;
+ if historic {
+ self.commands.entity(content).insert_children(0, &[message]);
+ } else {
+ self.commands.entity(content).try_push_children(&[message]);
+ }
+ debug!("added");
+ (bubble, message)
+ }
+}
diff --git a/crates/system_ui/src/chat/friends.rs b/crates/system_ui/src/chat/friends.rs
new file mode 100644
index 00000000..c2942c3f
--- /dev/null
+++ b/crates/system_ui/src/chat/friends.rs
@@ -0,0 +1,565 @@
+use bevy::{prelude::*, utils::hashbrown::HashMap};
+use bevy_dui::{DuiCommandsExt, DuiEntities, DuiProps, DuiRegistry};
+use common::{
+ structs::{ShowProfileEvent, SystemAudio},
+ util::{format_address, FireEventEx, TryPushChildrenEx},
+};
+use comms::profile::ProfileManager;
+use ethers_core::types::Address;
+use social::{client::DirectChatMessage, DirectChatEvent, FriendshipEvent, SocialClient};
+use tokio::sync::mpsc::Receiver;
+use ui_core::{
+ button::{DuiButton, TabManager, TabSelection},
+ focus::Focus,
+ text_entry::TextEntry,
+ ui_actions::{Click, EventCloneExt, On},
+ user_font, FontName, WeightName,
+};
+
+use crate::chat::{ChatInput, ChatTab, ChatboxContainer, PrivateChatEntered};
+
+use super::{conversation_manager::ConversationManager, ChatBox};
+
+pub struct FriendsPlugin;
+
+impl Plugin for FriendsPlugin {
+ fn build(&self, app: &mut App) {
+ app.add_systems(
+ Update,
+ (
+ update_friends,
+ update_conversations,
+ show_conversation,
+ update_profile_names,
+ update_profile_images,
+ bold_unread,
+ ),
+ );
+ app.add_event::();
+ }
+}
+
+#[derive(Component)]
+pub struct PrivateChat {
+ pub address: Address,
+ pub history_receiver: Receiver,
+ pub wants_history_count: usize,
+ pub messages: Vec,
+}
+
+#[derive(Component)]
+pub struct PendingProfileName(Address);
+
+pub fn update_profile_names(
+ mut cache: ProfileManager,
+ mut commands: Commands,
+ mut q: Query<(Entity, &PendingProfileName, &mut Text)>,
+) {
+ for (ent, pending, mut text) in q.iter_mut() {
+ match cache.get_name(pending.0) {
+ Err(_) => {
+ for section in &mut text.sections {
+ section.style.color = Color::srgb(0.5, 0.0, 0.0);
+ }
+ commands.entity(ent).remove::();
+ }
+ Ok(Some(name)) => {
+ for section in &mut text.sections {
+ section.style.color = Color::srgb(0.0, 0.0, 0.0);
+ if section.value.starts_with("0x") {
+ section.value = format_address(pending.0, Some(name));
+ }
+ }
+ commands.entity(ent).remove::();
+ }
+ Ok(None) => (),
+ }
+ }
+}
+
+#[derive(Component)]
+pub struct PendingProfileUiImage(pub Address);
+
+pub fn update_profile_images(
+ mut commands: Commands,
+ mut cache: ProfileManager,
+ mut q: Query<(Entity, &PendingProfileUiImage, &mut UiImage)>,
+) {
+ for (ent, pending, mut ui_image) in q.iter_mut() {
+ match cache.get_image(pending.0) {
+ Err(_) => {
+ commands.entity(ent).remove::();
+ }
+ Ok(Some(image)) => {
+ ui_image.texture = image;
+ commands.entity(ent).remove::();
+ }
+ Ok(None) => (),
+ }
+ }
+}
+
+#[derive(Event, Clone)]
+pub struct ShowConversationEvent(pub Address);
+
+#[allow(clippy::too_many_arguments)]
+pub fn show_conversation(
+ mut show_events: EventReader,
+ mut pending_event: Local>,
+ mut commands: Commands,
+ client: Res,
+ dui: Res,
+ existing_chats: Query<(Entity, &PrivateChat)>,
+ mut tab_manager: TabManager,
+ tab: Query>,
+ mut profile_cache: ProfileManager,
+ mut container: Query<&mut Style, With>,
+ entry: Query>,
+) {
+ if let Some(event) = show_events.read().last() {
+ *pending_event = Some(event.0);
+ }
+
+ let Ok(tab) = tab.get_single() else {
+ return;
+ };
+
+ let Some(&friend) = pending_event.as_ref() else {
+ return;
+ };
+ println!("got ev");
+
+ let name = match profile_cache.get_name(friend) {
+ Ok(Some(name)) => name.to_owned(),
+ Ok(None) => return,
+ Err(_) => format!("{friend:#x}"),
+ };
+
+ // we're going ahead after these checks, so clear the pending
+ pending_event.take();
+ println!("going ahead");
+
+ if let Ok(mut style) = container.get_single_mut() {
+ if style.display == Display::None {
+ commands.fire_event(SystemAudio("sounds/ui/toggle_enable.wav".to_owned()));
+ style.display = Display::Flex;
+ };
+ }
+
+ if let Ok(entry) = entry.get_single() {
+ commands.entity(entry).insert(Focus);
+ }
+
+ if let Some((existing, _)) = existing_chats.iter().find(|(_, c)| c.address == friend) {
+ tab_manager.set_selected_entity(tab, existing);
+ return;
+ }
+
+ let short_name = if name.len() > 25 {
+ format!(
+ "{}...{}",
+ name.chars().take(17).collect::(),
+ name.chars().skip(name.len() - 8).collect::()
+ )
+ } else {
+ name
+ };
+
+ let button_content = commands
+ .spawn_template(
+ &dui,
+ "direct-chat-button",
+ DuiProps::default().with_prop("name", short_name).with_prop(
+ "close",
+ On::::new(
+ move |mut tab_manager: TabManager,
+ tab: Query>,
+ buttons: Query<(Entity, &PrivateChat)>| {
+ // delete this tab
+ let Ok(tab) = tab.get_single() else {
+ return;
+ };
+
+ let Some((this, _)) = buttons.iter().find(|(_, b)| b.address == friend)
+ else {
+ return;
+ };
+
+ tab_manager.remove_entity(tab, this);
+ },
+ ),
+ ),
+ )
+ .unwrap();
+
+ commands
+ .entity(button_content.named("name"))
+ .insert(BoldUnread(friend));
+
+ let button = DuiButton {
+ enabled: true,
+ children: Some(button_content.root),
+ ..Default::default()
+ };
+
+ let new_tab = tab_manager
+ .add(
+ tab,
+ None,
+ button,
+ false,
+ Some(UiRect::new(
+ Val::Px(1.0),
+ Val::Px(1.0),
+ Val::Px(1.0),
+ Val::Px(0.0),
+ )),
+ )
+ .unwrap()
+ .root;
+
+ let Some(client) = client.0.as_ref() else {
+ warn!("social not connected");
+ return;
+ };
+
+ let Ok(history_receiver) = client.get_chat_history(friend) else {
+ warn!("failed to get history");
+ return;
+ };
+
+ commands.entity(new_tab).insert(PrivateChat {
+ address: friend,
+ history_receiver,
+ wants_history_count: 10,
+ messages: Vec::default(),
+ });
+
+ tab_manager.set_selected_entity(tab, new_tab);
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn update_friends(
+ mut commands: Commands,
+ client: Res,
+ mut init: Local,
+ components: Query<&DuiEntities, With>,
+ dui: Res,
+ mut friend_events: EventReader,
+) {
+ let is_init = client.0.as_ref().map_or(false, |c| c.is_initialized);
+ if is_init != *init || friend_events.read().next().is_some() {
+ *init = is_init;
+ let Ok(components) = components.get_single() else {
+ return;
+ };
+ if !is_init {
+ // clean up, disconnected
+ } else {
+ //initialize
+ let client = client.0.as_ref().unwrap();
+ let new_friends = client
+ .friends
+ .iter()
+ .map(|friend| {
+ let friend = *friend;
+ let mut root = commands.spawn_empty();
+ let components = dui
+ .apply_template(
+ &mut root,
+ "friend",
+ DuiProps::default()
+ .with_prop(
+ "name",
+ format!("{}", format_address(friend, None)),
+ )
+ .with_prop(
+ "profile",
+ ShowProfileEvent(friend).send_value_on::(),
+ )
+ .with_prop(
+ "chat",
+ ShowConversationEvent(friend).send_value_on::(),
+ ),
+ )
+ .unwrap();
+
+ commands
+ .entity(components.named("name"))
+ .insert(PendingProfileName(friend))
+ .insert(BoldUnread(friend));
+ components.root
+ })
+ .collect::>();
+ let mut friends = commands.entity(components.named("friends"));
+ friends.despawn_descendants();
+ friends.try_push_children(&new_friends);
+
+ let new_sent = client
+ .sent_requests
+ .iter()
+ .map(|friend| {
+ let friend = *friend;
+ let components = commands
+ .spawn_template(
+ &dui,
+ "sent-pending-friend",
+ DuiProps::default()
+ .with_prop(
+ "name",
+ format!("{}", format_address(friend, None)),
+ )
+ .with_prop("profile", ShowProfileEvent(friend).send_value_on::())
+ .with_prop(
+ "cancel",
+ On::::new(move |mut client: ResMut, mut commands: Commands| {
+ let Some(client) = client.0.as_mut() else {
+ warn!("no client");
+ return;
+ };
+
+ let _ = client.cancel_request(friend);
+ commands.fire_event(FriendshipEvent(None));
+ }),
+ ),
+ )
+ .unwrap();
+
+ commands
+ .entity(components.named("name"))
+ .insert(PendingProfileName(friend))
+ .insert(BoldUnread(friend));
+ components.root
+ })
+ .collect::>();
+
+ let mut sent_pending = commands.entity(components.named("sent-friends"));
+ sent_pending.despawn_descendants();
+ sent_pending.try_push_children(&new_sent);
+
+ let new_recd = client
+ .received_requests
+ .iter()
+ .map(|(friend, _msg)| {
+ let friend = *friend;
+ let components = commands
+ .spawn_template(
+ &dui,
+ "received-pending-friend",
+ DuiProps::default()
+ .with_prop(
+ "name",
+ format!("{}", format_address(friend, None)),
+ )
+ .with_prop("profile", ShowProfileEvent(friend).send_value_on::())
+ .with_prop(
+ "accept",
+ On::::new(move |mut client: ResMut, mut commands: Commands| {
+ let Some(client) = client.0.as_mut() else {
+ warn!("no client");
+ return;
+ };
+
+ let _ = client.accept_request(friend);
+ commands.fire_event(FriendshipEvent(None));
+ }),
+ )
+ .with_prop(
+ "reject",
+ On::::new(move |mut client: ResMut, mut commands: Commands| {
+ let Some(client) = client.0.as_mut() else {
+ warn!("no client");
+ return;
+ };
+
+ let _ = client.reject_request(friend);
+ commands.fire_event(FriendshipEvent(None));
+ }),
+ ),
+ )
+ .unwrap();
+
+ commands
+ .entity(components.named("name"))
+ .insert(PendingProfileName(friend))
+ .insert(BoldUnread(friend));
+ components.root
+ })
+ .collect::>();
+
+ let mut recd_pending = commands.entity(components.named("received-friends"));
+ recd_pending.despawn_descendants();
+ recd_pending.try_push_children(&new_recd);
+ }
+ }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn update_conversations(
+ mut client: ResMut,
+ tab: Query<&TabSelection, With>,
+ chatbox: Query>,
+ mut private_chats: Query<&mut PrivateChat>,
+ mut last_chat: Local>,
+ mut text_entry: Query<&mut TextEntry, With>,
+ mut new_chats: EventReader,
+ mut new_chats_outbound: EventReader,
+ mut conversation: ConversationManager,
+) {
+ let (Ok(tab), Ok(chatbox)) = (tab.get_single(), chatbox.get_single()) else {
+ return;
+ };
+
+ let new_chats = new_chats.read().collect::>();
+
+ if !new_chats.is_empty() {
+ for mut private_chat in private_chats.iter_mut() {
+ let address = private_chat.address;
+ for chat in new_chats.iter().filter(|c| c.0.partner == address) {
+ private_chat.messages.push(chat.0.clone());
+ }
+ }
+ }
+
+ let Some(private_chat_ent) = tab.selected_entity() else {
+ *last_chat = None;
+ return;
+ };
+ let private_chat_ent = private_chat_ent.root;
+ let Ok(mut private_chat) = private_chats.get_mut(private_chat_ent) else {
+ *last_chat = None;
+ return;
+ };
+
+ if let Some(client) = client.0.as_mut() {
+ client.mark_as_read(private_chat.address);
+ }
+
+ if *last_chat != Some(private_chat.address) {
+ // init
+ *last_chat = Some(private_chat.address);
+
+ conversation.clear(chatbox);
+ text_entry.single_mut().enabled = true;
+
+ if private_chat.wants_history_count == 0
+ && !(private_chat.history_receiver.is_closed()
+ && private_chat.history_receiver.is_empty())
+ {
+ // add button
+ conversation.add_history_button(chatbox, private_chat_ent);
+ }
+
+ // add current messages
+ for message in &private_chat.messages {
+ debug!("make conv");
+ if message.me_speaking {
+ conversation.add_message(
+ chatbox,
+ None,
+ Color::srgb(0.8, 0.8, 1.0),
+ &message.message,
+ false,
+ );
+ } else {
+ conversation.add_message(
+ chatbox,
+ Some(message.partner),
+ Color::srgb(0.8, 1.0, 0.8),
+ &message.message,
+ false,
+ );
+ }
+ }
+ } else {
+ // check for new chats
+ for new_message in new_chats
+ .iter()
+ .filter(|c| c.0.partner == private_chat.address)
+ {
+ if new_message.0.me_speaking {
+ conversation.add_message(
+ chatbox,
+ None,
+ Color::srgb(0.8, 0.8, 1.0),
+ &new_message.0.message,
+ false,
+ );
+ } else {
+ conversation.add_message(
+ chatbox,
+ Some(new_message.0.partner),
+ Color::srgb(0.8, 1.0, 0.8),
+ &new_message.0.message,
+ false,
+ );
+ }
+ }
+ }
+
+ if private_chat.wants_history_count > 0 {
+ if private_chat.history_receiver.is_closed() && private_chat.history_receiver.is_empty() {
+ debug!("out of history");
+ private_chat.wants_history_count = 0;
+ } else {
+ while let Ok(history) = private_chat.history_receiver.try_recv() {
+ debug!("got history: {:?}", history);
+ private_chat.messages.insert(0, history.clone());
+ if history.me_speaking {
+ conversation.add_message(
+ chatbox,
+ None,
+ Color::srgb(0.8, 0.8, 1.0),
+ &history.message,
+ true,
+ );
+ } else {
+ conversation.add_message(
+ chatbox,
+ Some(history.partner),
+ Color::srgb(0.8, 1.0, 0.8),
+ &history.message,
+ true,
+ );
+ }
+ private_chat.wants_history_count -= 1;
+ if private_chat.wants_history_count == 0 {
+ // add button
+ conversation.add_history_button(chatbox, private_chat_ent);
+ break;
+ }
+ }
+ }
+ }
+
+ for chat in new_chats_outbound.read() {
+ if let Some(client) = client.0.as_ref() {
+ client.chat(private_chat.address, chat.0.clone()).unwrap();
+ }
+ }
+}
+
+#[derive(Component)]
+pub struct BoldUnread(Address);
+
+pub fn bold_unread(mut q: Query<(&mut Text, Ref)>, client: Res) {
+ let default = HashMap::default();
+ let unread = client
+ .0
+ .as_ref()
+ .map(|client| client.unread_messages())
+ .unwrap_or(&default);
+ for (mut text, b) in q.iter_mut() {
+ let bold = unread.get(&b.0).copied().unwrap_or(0) > 0;
+ for section in &mut text.sections {
+ section.style.font = user_font(
+ FontName::Sans,
+ if bold {
+ WeightName::Bold
+ } else {
+ WeightName::Regular
+ },
+ );
+ }
+ }
+}
diff --git a/crates/system_ui/src/chat/history.rs b/crates/system_ui/src/chat/history.rs
new file mode 100644
index 00000000..a7905246
--- /dev/null
+++ b/crates/system_ui/src/chat/history.rs
@@ -0,0 +1,253 @@
+use std::collections::VecDeque;
+
+use bevy::prelude::*;
+use bevy_dui::{DuiCommandsExt, DuiProps, DuiRegistry};
+use common::{
+ structs::{ShowProfileEvent, SystemAudio},
+ util::{AsH160, FireEventEx},
+};
+use comms::{global_crdt::ChatEvent, profile::UserProfile};
+use dcl_component::proto_components::social::friendship_event_response::{self, Body};
+use social::{client::DirectChatMessage, DirectChatEvent, FriendshipEvent};
+use ui_core::{
+ bound_node::{BoundedNode, NodeBounds},
+ button::TabManager,
+ focus::Focus,
+ ui_actions::{Click, EventCloneExt, On},
+};
+
+use crate::SystemUiRoot;
+
+use super::{
+ conversation_manager::ConversationManager, friends::ShowConversationEvent, ChatInput, ChatTab,
+ ChatboxContainer,
+};
+
+pub struct ChatHistoryPlugin;
+
+impl Plugin for ChatHistoryPlugin {
+ fn build(&self, app: &mut App) {
+ app.add_systems(
+ OnEnter::(ui_core::State::Ready),
+ setup_chat_history.before(super::setup_chat_popup),
+ );
+ app.add_systems(Update, update_chat_history);
+ }
+}
+
+#[derive(Component, Default)]
+pub struct ChatHistory {
+ current: VecDeque<(Entity, Entity, f32)>,
+}
+
+fn setup_chat_history(mut commands: Commands, root: Res, dui: Res) {
+ let history = commands
+ .entity(root.0)
+ .spawn_template(&dui, "chat-history", DuiProps::new())
+ .unwrap();
+ commands
+ .entity(history.named("chat-content"))
+ .insert(ChatHistory::default());
+}
+
+#[allow(clippy::too_many_arguments)]
+fn update_chat_history(
+ mut commands: Commands,
+ mut q: Query<(Entity, &mut ChatHistory)>,
+ time: Res