minor changes to events

src/deno_ops/events/events.ts

@@ -3,6 +3,8 @@ import { TaskPID } from "../../../deno_bindings/TaskPID.ts";
 import * as InstanceControl from "../instance_control/instance_control.ts"
 import { InstanceEvent } from "../../../deno_bindings/InstanceEvent.ts";
 import { InstanceState } from "../../../deno_bindings/InstanceState.ts";
+import { ProgressionStartValue } from "../../../deno_bindings/ProgressionStartValue.ts";
+import { ProgressionEndValue } from "../../../deno_bindings/ProgressionEndValue.ts";
 
 // re-exports 
 export type { ClientEvent, TaskPID, InstanceControl, InstanceEvent, InstanceState };
@@ -63,3 +65,14 @@ export function emitStateChange(state: InstanceState, instanceName: string, inst
  ops.emit_state_change(instanceUuid, instanceName, state);
 }
 
+export function emitProgressionEventStart(progressionName : string, total : number | null, inner : ProgressionStartValue | null) : string {
+ return ops.emit_progression_event_start(progressionName, total, inner);
+}
+
+export function emitProgressiontEventUpdate(eventId : string, progressMessage : string, progress : number) {
+ ops.emit_progression_event_update(eventId, progressMessage, progress);
+}
+
+export function emitProgressionEventEnd(eventId : string, success : boolean, message : string | null, inner : ProgressionEndValue | null) {
+ ops.emit_progression_event_end(eventId, success, message, inner);
+}

src/deno_ops/events/mod.rs

@@ -6,8 +6,11 @@ use deno_core::{
 };
 
 use crate::{
- event_broadcaster::{EventBroadcaster, PlayerMessage},
- events::{Event, InstanceEvent},
+ event_broadcaster::{EventBroadcaster, PlayerChange, PlayerMessage},
+ events::{
+ CausedBy, Event, InstanceEvent, ProgressionEndValue, ProgressionEventID,
+ ProgressionStartValue,
+ },
  macro_executor::MacroPID,
  traits::t_server::State,
  types::InstanceUuid,
@@ -72,6 +75,17 @@ async fn next_instance_system_message(
  .await
 }
 
+#[op]
+async fn next_instance_player_change(
+ state: Rc<RefCell<OpState>>,
+ instance_uuid: InstanceUuid,
+) -> PlayerChange {
+ let event_broadcaster = state.borrow().borrow::<EventBroadcaster>().clone();
+ event_broadcaster
+ .next_instance_player_change(&instance_uuid)
+ .await
+}
+
 #[op]
 fn emit_detach(state: Rc<RefCell<OpState>>, macro_pid: MacroPID) {
  let tx = state.borrow().borrow::<EventBroadcaster>().clone();
@@ -108,6 +122,49 @@ fn emit_state_change(
  ))
 }
 
+#[op]
+fn emit_progression_event_start(
+ state: Rc<RefCell<OpState>>,
+ progression_name: String,
+ total: Option<f64>,
+ inner: Option<ProgressionStartValue>,
+) -> ProgressionEventID {
+ let tx = state.borrow().borrow::<EventBroadcaster>().clone();
+ let (event, id) =
+ Event::new_progression_event_start(progression_name, total, inner, CausedBy::System);
+ tx.send(event);
+ id
+}
+
+#[op]
+fn emit_progression_event_update(
+ state: Rc<RefCell<OpState>>,
+ event_id: ProgressionEventID,
+ progress_msg: String,
+ progress: f64,
+) {
+ let tx = state.borrow().borrow::<EventBroadcaster>().clone();
+ tx.send(Event::new_progression_event_update(
+ &event_id,
+ progress_msg,
+ progress,
+ ));
+}
+
+#[op]
+fn emit_progression_event_end(
+ state: Rc<RefCell<OpState>>,
+ event_id: ProgressionEventID,
+ success: bool,
+ message: Option<String>,
+ inner: Option<ProgressionEndValue>,
+) {
+ let tx = state.borrow().borrow::<EventBroadcaster>().clone();
+ tx.send(Event::new_progression_event_end(
+ event_id, success, message, inner,
+ ));
+}
+
 pub fn register_all_event_ops(
  worker_options: &mut deno_runtime::worker::WorkerOptions,
  event_broadcaster: EventBroadcaster,
@@ -124,6 +181,10 @@ pub fn register_all_event_ops(
  next_instance_output::decl(),
  next_instance_player_message::decl(),
  next_instance_system_message::decl(),
+ next_instance_player_change::decl(),
+ emit_progression_event_start::decl(),
+ emit_progression_event_update::decl(),
+ emit_progression_event_end::decl(),
  ])
  .state(|state| {
  state.put(event_broadcaster);

src/event_broadcaster.rs

@@ -1,9 +1,11 @@
+use std::collections::HashSet;
+
 use tokio::sync::broadcast::{Receiver, Sender};
 use tracing::error;
 
 use crate::{
  events::{Event, EventInner, InstanceEvent, InstanceEventInner},
- traits::t_server::State,
+ traits::{t_player::Player, t_server::State},
  types::InstanceUuid,
 };
 
@@ -18,6 +20,13 @@ pub struct PlayerMessage {
  pub message: String,
 }
 
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PlayerChange {
+ player_list: HashSet<Player>,
+ players_joined: HashSet<Player>,
+ players_left: HashSet<Player>,
+}
+
 impl EventBroadcaster {
  pub fn new(capacity: usize) -> (Self, Receiver<Event>) {
  let (event_tx, rx) = tokio::sync::broadcast::channel(capacity);
@@ -105,6 +114,23 @@ impl EventBroadcaster {
  }
  }
  }
+ pub async fn next_instance_player_change(&self, instance_uuid: &InstanceUuid) -> PlayerChange {
+ loop {
+ let event = self.next_instance_event(instance_uuid).await;
+ if let InstanceEventInner::PlayerChange {
+ player_list,
+ players_joined,
+ players_left,
+ } = event.instance_event_inner
+ {
+ return PlayerChange {
+ player_list,
+ players_joined,
+ players_left,
+ };
+ }
+ }
+ }
 }
 
 impl From<EventBroadcaster> for Sender<Event> {

src/events.rs

@@ -219,10 +219,6 @@ pub enum ProgressionEndValue {
 pub enum ProgressionStartValue {
  InstanceCreation {
  instance_uuid: InstanceUuid,
- instance_name: String,
- port: u32,
- flavour: String,
- game_type: String,
  },
  InstanceDelete {
  instance_uuid: InstanceUuid,
@@ -284,6 +280,9 @@ pub fn new_fs_event(operation: FSOperation, target: FSTarget, caused_by: CausedB
  }
 }
 
+#[derive(Serialize, Deserialize, TS)]
+#[serde(transparent)]
+#[ts(export)]
 pub struct ProgressionEventID(Snowflake);
 
 #[derive(Serialize, Deserialize, Clone, Debug, TS, PartialEq)]

src/handlers/instance.rs

@@ -109,8 +109,6 @@ pub async fn create_minecraft_instance(
  let uuid = instance_uuid.clone();
  let instance_name = setup_config.name.clone();
  let event_broadcaster = state.event_broadcaster.clone();
- let port = setup_config.port;
- let flavour = setup_config.flavour.clone();
  let caused_by = CausedBy::User {
  user_id: requester.uid.clone(),
  user_name: requester.username.clone(),
@@ -121,10 +119,6 @@ pub async fn create_minecraft_instance(
  Some(10.0),
  Some(ProgressionStartValue::InstanceCreation {
  instance_uuid: uuid.clone(),
- instance_name: instance_name.clone(),
- port,
- flavour: flavour.to_string(),
- game_type: "minecraft".to_string(),
  }),
  caused_by,
  );