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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::keyboard::{KeyPosition, KeyState, VirtualKey};
use crate::systems::System;
use async_trait::async_trait;
use std::sync::Arc;

#[cfg(target_arch = "wasm32")]
mod canvas;

#[cfg(not(target_arch = "wasm32"))]
mod text;

#[cfg(not(target_arch = "wasm32"))]
mod winit;

#[cfg(target_arch = "wasm32")]
pub use self::canvas::{CanvasPlatform, CanvasPlatformProvider};
#[cfg(not(target_arch = "wasm32"))]
pub use self::text::{TextPlatform, TextPlatformProvider};
#[cfg(not(target_arch = "wasm32"))]
pub use self::winit::{WinitPlatform, WinitPlatformProvider};

/// A Platform provides platform-specific functionality to the emulator.
/// It handles starting and ticking the system, and provides a PlatformProvider
/// to the system for screen/keyboard/etc. access.
pub trait Platform {
  /// Return a reference to a provider for systems to interact with this platform.
  fn provider(&self) -> Arc<dyn PlatformProvider>;
}

/// A platform which can be run synchronously.
pub trait SyncPlatform: Platform {
  /// Run the given system within this platform.
  fn run(&mut self, system: Box<dyn System>);
}

/// A platform which can be run asynchronously.
#[async_trait(?Send)]
pub trait AsyncPlatform: Platform {
  /// Set up this platform for use.
  async fn setup(&mut self);

  /// Execute one "step" of this platform. A step is implementation-defined.
  async fn tick(&mut self, system: &mut Box<dyn System>);
}

/// Represents an RGB color with 8 bits per channel.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct Color {
  r: u8,
  g: u8,
  b: u8,
}

impl Color {
  pub fn new(r: u8, g: u8, b: u8) -> Self {
    Self { r, g, b }
  }

  /// Convert the given color to an array of 4 bytes, where the last byte
  /// (alpha) is always 255.
  pub fn to_rgba(&self) -> [u8; 4] {
    [self.r, self.g, self.b, 255]
  }

  /// Convert the given color to a 32-bit integer, where the top 8 bits are
  /// unset (0), the next 8 bits are red, the next 8 bits are green, and the
  /// last 8 bits are blue.
  pub fn to_rgb(&self) -> u32 {
    (self.r as u32) << 16 | (self.g as u32) << 8 | self.b as u32
  }
}

/// Represents the current state of the connected joystick.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct JoystickState {
  pub up: bool,
  pub down: bool,
  pub left: bool,
  pub right: bool,
  pub fire: bool,
}

impl JoystickState {
  /// Create a new JoystickState with all buttons released.
  pub fn empty() -> Self {
    Self {
      up: false,
      down: false,
      left: false,
      right: false,
      fire: false,
    }
  }
}

/// Represents the configuration of a GUI window that the system can request
/// from the platform.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WindowConfig {
  pub width: u32,
  pub height: u32,
  pub scale: f64,
}

impl WindowConfig {
  pub fn new(width: u32, height: u32, scale: f64) -> Self {
    Self {
      width,
      height,
      scale,
    }
  }
}

pub trait PlatformProvider {
  /// Request that the platform create a window of the specified size,
  /// with the specified scale factor. If a window already exists, the platform
  /// should resize it to the new size.
  fn request_window(&self, config: WindowConfig);

  /// Get the current state of the user's physical keyboard.
  fn get_key_state(&self) -> KeyState<KeyPosition>;

  /// Get the state of a virtual keyboard (emulating the target system),
  /// if one is available.
  fn get_virtual_key_state(&self) -> KeyState<VirtualKey>;

  /// Get the current state of the connected joystick.
  /// If no joystick is connected, this should return a default state.
  fn get_joystick_state(&self) -> JoystickState;

  /// Display the given string to the user, "out-of-band" from any other
  /// graphics. This is used for text-mode systems. Implementations may choose
  /// various ways to display this, such as a terminal message or a pop-up.
  fn print(&self, text: &str);

  /// Read a string input from the user, "out-of-band" from any other
  /// graphics. This is used for text-mode systems. Implementations may choose
  /// various ways to prompt for this, such as a terminal prompt or a pop-up
  /// dialog.
  fn input(&self) -> String;

  /// Return a random number between 0 and 255. This exists as some platforms
  /// (such as the web) have a different source of randomness.
  fn random(&self) -> u8;
}