RustyStriker/open_tavern
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

allow texture streaming(png, jpeg for now) and use texture url instead of passing textures in base64

Browse source
This commit is contained in:
Rusty Striker 2025-06-20 16:47:55 +03:00
parent 1d63e3d983
commit d29a2a8590
Signed by: RustyStriker
GPG key ID: 9DBDBC7C48FC3C31
5 changed files with 47 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/lib.rs
View file

@ -144,15 +144,13 @@ impl GameServer {
api::Request::GetTokens { scene } => {
for token_id in self.game.available_tokens(scene) {
if let Some(ti) = self.game.token_info(0, token_id) {
let bits = std::fs::read(&ti.img_source).expect("FAILED READING TOKEN IMAGE");
let img = base64::Engine::encode(&base64::prelude::BASE64_STANDARD, &bits);
_ = broadcast.send((
Some(id.clone()),
api::Response::SpawnToken(SpawnToken {
token_id: token_id,
x: ti.x,
y: ti.y,
img,
img: ti.img_source.clone(),
}),
));
}
@ -160,7 +158,7 @@ impl GameServer {
}
api::Request::GetCurrentScene => {
let scene = self.game.current_scene();
let mut scene_tokens = self
let scene_tokens = self
.game
.available_tokens(scene)
.iter()
@ -173,10 +171,6 @@ impl GameServer {
img: info.img_source.clone(),
})
.collect::<Vec<_>>();
for spawn in scene_tokens.iter_mut() {
let bits = std::fs::read(&spawn.img).expect("FAILED READING TOKEN IMAGE");
spawn.img = base64::Engine::encode(&base64::prelude::BASE64_STANDARD, &bits);
}
_ = broadcast.send((
Some(id.clone()),
api::Response::ShowScene {
@ -193,11 +187,9 @@ impl GameServer {
img_path,
} => {
let token_id = self.game.create_token(map_id, character, img_path.clone(), x, y);
let bits = std::fs::read(&img_path).expect("FAILED READING TOKEN IMAGE");
let img = base64::Engine::encode(&base64::prelude::BASE64_STANDARD, &bits);
_ = broadcast.send((
Some(id.clone()),
api::Response::SpawnToken(SpawnToken { token_id, x, y, img }),
api::Response::SpawnToken(SpawnToken { token_id, x, y, img: img_path.clone() }),
));
}
api::Request::MoveToken { token_id, x, y } => {

31
src/main.rs
View file

@ -1,7 +1,5 @@
use axum::{
Router,
extract::ws::{self, Message},
response, routing,
extract::ws::{self, Message}, http::StatusCode, response::{self, IntoResponse}, routing, Router
};
use futures_util::{
SinkExt, StreamExt,
@ -9,6 +7,7 @@ use futures_util::{
};
use open_tavern::api::{Request, RequestError, Response};
use tokio::sync::{broadcast, mpsc};
use tokio_util::io::ReaderStream;
#[tokio::main]
async fn main() {
@ -20,6 +19,7 @@ async fn main() {
.route("/tavern.js", routing::get(socket))
.route("/app.js", routing::get(app_js))
.route("/style.css", routing::get(style))
.route("/assets/{*asset}", routing::get(get_asset))
.route(
"/ws",
routing::get(move |w| ws_handler(w, msend, bsend2.clone().subscribe())),
@ -191,3 +191,28 @@ async fn style() -> impl response::IntoResponse {
std::fs::read_to_string("./assets/web/style.css").unwrap(),
)
}
async fn get_asset(asset: axum::extract::Path<String>) -> impl IntoResponse {
println!("Asset requested: {}", asset.0);
let supported_file_types = [
(".jpg", "image/jpeg"), (".jpeg", "image/jpeg"), (".png", "image/png")
];
let mime = match supported_file_types.iter()
.filter(|t| asset.0.ends_with(t.0))
.map(|t| t.1)
.next() {
Some(t) => t,
None => return Err((StatusCode::UNSUPPORTED_MEDIA_TYPE, "Unsupported file type".to_string())),
};
let file = match tokio::fs::File::open(format!("assets/{}", asset.0)).await {
Ok(f) => f,
Err(err) => return Err((StatusCode::NOT_FOUND, format!("File not found: {}", err))),
};
let stream = ReaderStream::new(file);
let body = axum::body::Body::from_stream(stream);
let headers = [
(axum::http::header::CONTENT_TYPE, mime)
];
Ok((headers, body))
}