mirrors/stevenarella
mirrors
/
stevenarella
mirror of https://github.com/iceiix/stevenarella.git
1
0
Fork 0
Code Issues 1 Projects Releases Wiki Activity

Separate the console and console vars. Removes the need to lock on the console to read vars

This commit is contained in:
Thinkofname 2016-04-21 11:40:50 +01:00
parent 380a844272
commit edf6f34a0b
8 changed files with 173 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/auth.rs
View File

@ -55,9 +55,9 @@ Used to identify this client vs others."#,
default: &|| "".to_owned(),
};
pub fn register_vars(console: &mut console::Console) {
console.register(CL_USERNAME);
console.register(CL_UUID);
console.register(AUTH_TOKEN);
console.register(AUTH_CLIENT_TOKEN);
pub fn register_vars(vars: &mut console::Vars) {
vars.register(CL_USERNAME);
vars.register(CL_UUID);
vars.register(AUTH_TOKEN);
vars.register(AUTH_CLIENT_TOKEN);
}

166
src/console/mod.rs
View File

@ -15,6 +15,7 @@
use std::marker::PhantomData;
use std::collections::HashMap;
use std::any::Any;
use std::cell::{RefCell, Ref};
use std::sync::{Arc, Mutex};
use std::fs;
use std::io::{BufWriter, Write, BufRead, BufReader};
@ -98,32 +99,18 @@ pub trait Var {
fn can_serialize(&self) -> bool;
}
pub struct Console {
pub struct Vars {
names: HashMap<String, &'static str>,
vars: HashMap<&'static str, Box<Var>>,
var_values: HashMap<&'static str, Box<Any>>,
history: Vec<Component>,
collection: ui::Collection,
active: bool,
position: f64,
var_values: HashMap<&'static str, RefCell<Box<Any>>>,
}
unsafe impl Send for Console {}
impl Console {
pub fn new() -> Console {
Console {
impl Vars {
pub fn new() -> Vars {
Vars {
names: HashMap::new(),
vars: HashMap::new(),
var_values: HashMap::new(),
history: vec![Component::Text(TextComponent::new("")); 200],
collection: ui::Collection::new(),
active: false,
position: -220.0,
}
}
@ -134,24 +121,84 @@ impl Console {
panic!("Key registered twice {}", var.name);
}
self.names.insert(var.name.to_owned(), var.name);
self.var_values.insert(var.name, Box::new((var.default)()));
self.var_values.insert(var.name, RefCell::new(Box::new((var.default)())));
self.vars.insert(var.name, Box::new(var));
}
pub fn get<T: Sized + Any>(&self, var: CVar<T>) -> &T
pub fn get<'a, T: Sized + Any>(&'a self, var: CVar<T>) -> Ref<'a, T>
where CVar<T>: Var
{
// Should never fail
self.var_values.get(var.name).unwrap().downcast_ref::<T>().unwrap()
let var = self.var_values.get(var.name).unwrap().borrow();
Ref::map(var, |v| v.downcast_ref::<T>().unwrap())
}
pub fn set<T: Sized + Any>(&mut self, var: CVar<T>, val: T)
pub fn set<T: Sized + Any>(&self, var: CVar<T>, val: T)
where CVar<T>: Var
{
self.var_values.insert(var.name, Box::new(val));
// self.var_values.insert(var.name, Box::new(val));
*self.var_values.get(var.name).unwrap().borrow_mut() = Box::new(val);
self.save_config();
}
pub fn load_config(&mut self) {
if let Ok(file) = fs::File::open("conf.cfg") {
let reader = BufReader::new(file);
for line in reader.lines() {
let line = line.unwrap();
if line.starts_with('#') || line.is_empty() {
continue;
}
let parts = line.splitn(2, ' ').map(|v| v.to_owned()).collect::<Vec<String>>();
let (name, arg) = (&parts[0], &parts[1]);
if let Some(var_name) = self.names.get(name) {
let var = self.vars.get(var_name).unwrap();
let val = var.deserialize(&arg);
if var.can_serialize() {
self.var_values.insert(var_name, RefCell::new(val));
}
}
}
}
}
pub fn save_config(&self) {
let mut file = BufWriter::new(fs::File::create("conf.cfg").unwrap());
for (name, var) in &self.vars {
if !var.can_serialize() {
continue;
}
for line in var.description().lines() {
write!(file, "# {}\n", line).unwrap();
}
write!(file,
"{} {}\n\n",
name,
var.serialize(&self.var_values.get(name).unwrap().borrow()))
.unwrap();
}
}
}
pub struct Console {
history: Vec<Component>,
collection: ui::Collection,
active: bool,
position: f64,
}
impl Console {
pub fn new() -> Console {
Console {
history: vec![Component::Text(TextComponent::new("")); 200],
collection: ui::Collection::new(),
active: false,
position: -220.0,
}
}
pub fn is_active(&self) -> bool {
self.active
}
@ -188,20 +235,12 @@ impl Console {
ui::Mode::Unscaled(scale) => 854.0 / scale,
};
let mut background =
ui::Image::new(render::Renderer::get_texture(renderer.get_textures_ref(),
"steven:solid"),
0.0,
self.position,
w,
220.0,
0.0,
0.0,
1.0,
1.0,
0,
0,
0);
let mut background = ui::Image::new(
render::Renderer::get_texture(renderer.get_textures_ref(), "steven:solid"),
0.0, self.position, w, 220.0,
0.0, 0.0, 1.0, 1.0,
0, 0, 0
);
background.set_a(180);
let background = self.collection.add(ui_container.add(background));
@ -211,11 +250,12 @@ impl Console {
if offset >= 210.0 {
break;
}
let mut fmt = ui::Formatted::with_width_limit(renderer,
line.clone(),
5.0,
5.0 + offset,
w - 1.0);
let mut fmt = ui::Formatted::with_width_limit(
renderer,
line.clone(),
5.0, 5.0 + offset,
w - 1.0
);
fmt.set_parent(&background);
fmt.set_v_attach(ui::VAttach::Bottom);
offset += fmt.get_height();
@ -226,46 +266,6 @@ impl Console {
}
}
pub fn load_config(&mut self) {
if let Ok(file) = fs::File::open("conf.cfg") {
let reader = BufReader::new(file);
for line in reader.lines() {
let line = line.unwrap();
if line.starts_with('#') || line.is_empty() {
continue;
}
let parts = line.splitn(2, ' ').map(|v| v.to_owned()).collect::<Vec<String>>();
let (name, arg) = (&parts[0], &parts[1]);
if let Some(var_name) = self.names.get(name) {
let var = self.vars.get(var_name).unwrap();
let val = var.deserialize(&arg);
if var.can_serialize() {
self.var_values.insert(var_name, val);
}
} else {
println!("Missing prop");
}
}
}
}
pub fn save_config(&self) {
let mut file = BufWriter::new(fs::File::create("conf.cfg").unwrap());
for (name, var) in &self.vars {
if !var.can_serialize() {
continue;
}
for line in var.description().lines() {
write!(file, "# {}\n", line).unwrap();
}
write!(file,
"{} {}\n\n",
name,
var.serialize(self.var_values.get(name).unwrap()))
.unwrap();
}
}
fn log(&mut self, record: &log::LogRecord) {
for filtered in FILTERED_CRATES {
if record.location().module_path().starts_with(filtered) {

57
src/main.rs
View File

@ -59,9 +59,11 @@ pub mod model;
pub mod entity;
use std::sync::{Arc, RwLock, Mutex};
use std::rc::Rc;
use std::marker::PhantomData;
use std::thread;
use std::sync::mpsc;
use protocol::mojang;
const CL_BRAND: console::CVar<String> = console::CVar {
ty: PhantomData,
@ -78,6 +80,7 @@ pub struct Game {
screen_sys: screen::ScreenSystem,
resource_manager: Arc<RwLock<resources::Manager>>,
console: Arc<Mutex<console::Console>>,
vars: Rc<console::Vars>,
should_close: bool,
server: server::Server,
@ -93,9 +96,13 @@ impl Game {
self.connect_reply = Some(rx);
let address = address.to_owned();
let resources = self.resource_manager.clone();
let console = self.console.clone();
let profile = mojang::Profile {
username: self.vars.get(auth::CL_USERNAME).clone(),
id: self.vars.get(auth::CL_UUID).clone(),
access_token: self.vars.get(auth::AUTH_TOKEN).clone(),
};
thread::spawn(move || {
tx.send(server::Server::connect(resources, console, &address)).unwrap();
tx.send(server::Server::connect(resources, profile, &address)).unwrap();
});
}
@ -151,14 +158,15 @@ impl Game {
fn main() {
let con = Arc::new(Mutex::new(console::Console::new()));
let mut vsync = {
let mut con = con.lock().unwrap();
con.register(CL_BRAND);
auth::register_vars(&mut con);
settings::register_vars(&mut con);
con.load_config();
con.save_config();
*con.get(settings::R_VSYNC)
let (vars, mut vsync) = {
let mut vars = console::Vars::new();
vars.register(CL_BRAND);
auth::register_vars(&mut vars);
settings::register_vars(&mut vars);
vars.load_config();
vars.save_config();
let vsync = *vars.get(settings::R_VSYNC);
(Rc::new(vars), vsync)
};
let proxy = console::ConsoleProxy::new(con.clone());
@ -204,16 +212,17 @@ fn main() {
let frame_time = (time::Duration::seconds(1).num_nanoseconds().unwrap() as f64) / 60.0;
let mut screen_sys = screen::ScreenSystem::new();
screen_sys.add_screen(Box::new(screen::Login::new(con.clone())));
screen_sys.add_screen(Box::new(screen::Login::new(vars.clone())));
let textures = renderer.get_textures();
let mut game = Game {
server: server::Server::dummy_server(resource_manager.clone(), con.clone()),
server: server::Server::dummy_server(resource_manager.clone()),
focused: false,
renderer: renderer,
screen_sys: screen_sys,
resource_manager: resource_manager.clone(),
console: con,
vars: vars,
should_close: false,
chunk_builder: chunk_builder::ChunkBuilder::new(resource_manager, textures),
connect_reply: None,
@ -234,15 +243,13 @@ fn main() {
let delta = (diff.num_nanoseconds().unwrap() as f64) / frame_time;
let (width, height) = window.drawable_size();
let fps_cap = {
let console = game.console.lock().unwrap();
let vsync_changed = *console.get(settings::R_VSYNC);
if vsync != vsync_changed {
vsync = vsync_changed;
sdl_video.gl_set_swap_interval(if vsync { 1 } else { 0 });
}
*console.get(settings::R_MAX_FPS)
};
let vsync_changed = *game.vars.get(settings::R_VSYNC);
if vsync != vsync_changed {
vsync = vsync_changed;
sdl_video.gl_set_swap_interval(if vsync { 1 } else { 0 });
}
let fps_cap = *game.vars.get(settings::R_MAX_FPS);
game.tick(delta);
game.server.tick(&mut game.renderer, delta);
@ -339,7 +346,7 @@ fn handle_window_event(window: &sdl2::video::Window,
if game.focused {
mouse.set_relative_mouse_mode(false);
game.focused = false;
game.screen_sys.replace_screen(Box::new(screen::SettingsMenu::new(game.console.clone(), true)));
game.screen_sys.replace_screen(Box::new(screen::SettingsMenu::new(game.vars.clone(), true)));
} else if game.screen_sys.is_current_closable() {
mouse.set_relative_mouse_mode(true);
game.focused = true;
@ -351,8 +358,7 @@ fn handle_window_event(window: &sdl2::video::Window,
}
Event::KeyDown{keycode: Some(key), ..} => {
if game.focused {
let console = game.console.lock().unwrap();
if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &console) {
if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &game.vars) {
game.server.key_press(true, steven_key);
}
} else {
@ -361,8 +367,7 @@ fn handle_window_event(window: &sdl2::video::Window,
}
Event::KeyUp{keycode: Some(key), ..} => {
if game.focused {
let console = game.console.lock().unwrap();
if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &console) {
if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &game.vars) {
game.server.key_press(false, steven_key);
}
} else {

29
src/screen/login.rs
View File

@ -12,8 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use std::sync::{Arc, Mutex};
use std::cell::Cell;
use std::rc::Rc;
use std::sync::mpsc;
@ -30,7 +28,7 @@ use auth;
pub struct Login {
elements: Option<UIElements>,
console: Arc<Mutex<console::Console>>,
vars: Rc<console::Vars>,
}
struct UIElements {
@ -51,8 +49,8 @@ struct UIElements {
impl Login {
pub fn new(console: Arc<Mutex<console::Console>>) -> Login {
Login { elements: None, console: console }
pub fn new(vars: Rc<console::Vars>) -> Login {
Login { elements: None, vars: vars }
}
}
@ -126,11 +124,10 @@ impl super::Screen for Login {
warn.set_h_attach(ui::HAttach::Right);
elements.add(ui_container.add(warn));
let console = self.console.lock().unwrap();
let profile = mojang::Profile {
username: console.get(auth::CL_USERNAME).clone(),
id: console.get(auth::CL_UUID).clone(),
access_token: console.get(auth::AUTH_TOKEN).clone(),
username: self.vars.get(auth::CL_USERNAME).clone(),
id: self.vars.get(auth::CL_UUID).clone(),
access_token: self.vars.get(auth::AUTH_TOKEN).clone(),
};
let refresh = profile.is_complete();
try_login.set(refresh);
@ -178,13 +175,12 @@ impl super::Screen for Login {
let txt = ui_container.get_mut(&elements.login_btn_text);
txt.set_text(renderer, "Logging in...");
}
let mut console = self.console.lock().unwrap();
let mut client_token = console.get(auth::AUTH_CLIENT_TOKEN).clone();
let mut client_token = self.vars.get(auth::AUTH_CLIENT_TOKEN).clone();
if client_token.is_empty() {
client_token = rand::thread_rng().gen_ascii_chars().take(20).collect::<String>();
console.set(auth::AUTH_CLIENT_TOKEN, client_token);
self.vars.set(auth::AUTH_CLIENT_TOKEN, client_token);
}
let client_token = console.get(auth::AUTH_CLIENT_TOKEN).clone();
let client_token = self.vars.get(auth::AUTH_CLIENT_TOKEN).clone();
let username = {
let txt = ui_container.get(&elements.username_txt);
txt.get_input()
@ -217,10 +213,9 @@ impl super::Screen for Login {
}
match res {
Ok(val) => {
let mut console = self.console.lock().unwrap();
console.set(auth::CL_USERNAME, val.username.clone());
console.set(auth::CL_UUID, val.id.clone());
console.set(auth::AUTH_TOKEN, val.access_token.clone());
self.vars.set(auth::CL_USERNAME, val.username.clone());
self.vars.set(auth::CL_UUID, val.id.clone());
self.vars.set(auth::AUTH_TOKEN, val.access_token.clone());
elements.profile = val;
return Some(Box::new(super::ServerList::new(None)));
},

2
src/screen/server_list.rs
View File

@ -388,7 +388,7 @@ impl super::Screen for ServerList {
cog.set_v_attach(ui::VAttach::Middle);
cog.set_h_attach(ui::HAttach::Center);
super::button_action(ui_container, re.clone(), None, | game, _ | {
game.screen_sys.add_screen(Box::new(super::SettingsMenu::new(game.console.clone(), false)));
game.screen_sys.add_screen(Box::new(super::SettingsMenu::new(game.vars.clone(), false)));
});
elements.add(re);
elements.add(ui_container.add(cog));

47
src/screen/settings_menu.rs
View File

@ -3,7 +3,7 @@ use render;
use ui;
use settings;
use std::sync::{Arc, Mutex};
use std::rc::Rc;
pub fn new_submenu_button(text: &str, renderer: &mut render::Renderer, ui_container: &mut ui::Container, x: f64, y: f64) -> (ui::ElementRef<ui::Button>, ui::ElementRef<ui::Text>) {
let (mut btn, mut txt) = super::new_button_text(renderer, text, x, y, 300.0, 40.0);
@ -47,15 +47,15 @@ pub struct UIElements {
}
pub struct SettingsMenu {
console: Arc<Mutex<console::Console>>,
vars: Rc<console::Vars>,
elements: Option<UIElements>,
show_disconnect_button: bool
}
impl SettingsMenu {
pub fn new(console: Arc<Mutex<console::Console>>, show_disconnect_button: bool) -> SettingsMenu {
pub fn new(vars: Rc<console::Vars>, show_disconnect_button: bool) -> SettingsMenu {
SettingsMenu {
console: console,
vars: vars,
elements: None,
show_disconnect_button: show_disconnect_button
}
@ -78,14 +78,14 @@ impl super::Screen for SettingsMenu {
// From top and down
let (btn_audio_settings, txt_audio_settings) = new_submenu_button("Audio settings...", renderer, ui_container, -160.0, -50.0);
super::button_action(ui_container, btn_audio_settings.clone(), Some(txt_audio_settings.clone()), move |game, _| {
game.screen_sys.add_screen(Box::new(AudioSettingsMenu::new(game.console.clone())));
game.screen_sys.add_screen(Box::new(AudioSettingsMenu::new(game.vars.clone())));
});
elements.add(btn_audio_settings);
elements.add(txt_audio_settings);
let (btn_video_settings, txt_video_settings) = new_submenu_button("Video settings...", renderer, ui_container, 160.0, -50.0);
super::button_action(ui_container, btn_video_settings.clone(), Some(txt_video_settings.clone()), move |game, _| {
game.screen_sys.add_screen(Box::new(VideoSettingsMenu::new(game.console.clone())));
game.screen_sys.add_screen(Box::new(VideoSettingsMenu::new(game.vars.clone())));
});
elements.add(btn_video_settings);
elements.add(txt_video_settings);
@ -166,14 +166,14 @@ impl super::Screen for SettingsMenu {
}
pub struct VideoSettingsMenu {
console: Arc<Mutex<console::Console>>,
vars: Rc<console::Vars>,
elements: Option<UIElements>,
}
impl VideoSettingsMenu {
pub fn new(console: Arc<Mutex<console::Console>>) -> VideoSettingsMenu {
pub fn new(vars: Rc<console::Vars>) -> VideoSettingsMenu {
VideoSettingsMenu {
console: console,
vars: vars,
elements: None,
}
}
@ -193,14 +193,9 @@ impl super::Screen for VideoSettingsMenu {
let background = elements.add(ui_container.add(background));
// Load defaults
let (r_max_fps, r_fov, r_vsync) = {
let console = self.console.lock().unwrap();
(
console.get(settings::R_MAX_FPS).clone(),
console.get(settings::R_FOV).clone(),
console.get(settings::R_VSYNC).clone()
)
};
let r_max_fps = *self.vars.get(settings::R_MAX_FPS);
let r_fov = *self.vars.get(settings::R_FOV);
let r_vsync = *self.vars.get(settings::R_VSYNC);
// Setting buttons
// TODO: Slider
@ -211,11 +206,10 @@ impl super::Screen for VideoSettingsMenu {
let (btn_vsync, txt_vsync) = new_submenu_button(get_bool_str!("VSync: {}", r_vsync, "Enabled", "Disabled"), renderer, ui_container, -160.0, 0.0);
elements.add(txt_vsync.clone());
super::button_action(ui_container, btn_vsync.clone(), Some(txt_vsync.clone()), move | game, ui_container | {
let mut console = game.console.lock().unwrap();
let r_vsync = !console.get(settings::R_VSYNC);
let r_vsync = !*game.vars.get(settings::R_VSYNC);
let txt_vsync = ui_container.get_mut(&txt_vsync);
txt_vsync.set_text(&game.renderer, get_bool_str!("VSync: {}", r_vsync, "Enabled", "Disabled"));
console.set(settings::R_VSYNC, r_vsync);
game.vars.set(settings::R_VSYNC, r_vsync);
});
elements.add(btn_vsync);
@ -273,14 +267,14 @@ impl super::Screen for VideoSettingsMenu {
}
pub struct AudioSettingsMenu {
console: Arc<Mutex<console::Console>>,
vars: Rc<console::Vars>,
elements: Option<UIElements>
}
impl AudioSettingsMenu {
pub fn new(console: Arc<Mutex<console::Console>>) -> AudioSettingsMenu {
pub fn new(vars: Rc<console::Vars>) -> AudioSettingsMenu {
AudioSettingsMenu {
console: console,
vars: vars,
elements: None
}
}
@ -299,12 +293,9 @@ impl super::Screen for AudioSettingsMenu {
background.set_a(100);
let background = elements.add(ui_container.add(background));
let master_volume = {
let console = self.console.lock().unwrap();
(console.get(settings::CL_MASTER_VOLUME).clone())
};
let master_volume = *self.vars.get(settings::CL_MASTER_VOLUME);
let (btn_master_volume, txt_master_volume) = new_centered_button(master_volume.to_string().as_ref(), renderer, ui_container, -150.0, ui::VAttach::Middle);
let (btn_master_volume, txt_master_volume) = new_centered_button(&master_volume.to_string(), renderer, ui_container, -150.0, ui::VAttach::Middle);
elements.add(btn_master_volume);
elements.add(txt_master_volume);

27
src/server/mod.rs
View File

@ -16,17 +16,15 @@ use protocol::{self, mojang, packet};
use world;
use world::block;
use rand::{self, Rng};
use std::sync::{Arc, RwLock, Mutex};
use std::sync::{Arc, RwLock};
use std::sync::mpsc;
use std::thread;
use std::collections::HashMap;
use std::hash::BuildHasherDefault;
use types::hash::FNVHash;
use resources;
use console;
use render;
use settings::Stevenkey;
use auth;
use ecs;
use entity;
use cgmath;
@ -54,7 +52,6 @@ pub struct Server {
tick_time: bool,
resources: Arc<RwLock<resources::Manager>>,
console: Arc<Mutex<console::Console>>,
version: usize,
// Entity accessors
@ -104,20 +101,11 @@ macro_rules! handle_packet {
impl Server {
pub fn connect(resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>, address: &str) -> Result<Server, protocol::Error> {
pub fn connect(resources: Arc<RwLock<resources::Manager>>, profile: mojang::Profile, address: &str) -> Result<Server, protocol::Error> {
use openssl::crypto::pkey;
use openssl::crypto::rand::rand_bytes;
let mut conn = try!(protocol::Conn::new(address));
let profile = {
let console = console.lock().unwrap();
mojang::Profile {
username: console.get(auth::CL_USERNAME).clone(),
id: console.get(auth::CL_UUID).clone(),
access_token: console.get(auth::AUTH_TOKEN).clone(),
}
};
let host = conn.host.clone();
let port = conn.port;
try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
@ -149,7 +137,7 @@ impl Server {
read.state = protocol::State::Play;
write.state = protocol::State::Play;
let rx = Self::spawn_reader(read);
return Ok(Server::new(val.username, protocol::UUID::from_str(&val.uuid), resources, console, Some(write), Some(rx)));
return Ok(Server::new(val.username, protocol::UUID::from_str(&val.uuid), resources, Some(write), Some(rx)));
}
protocol::packet::Packet::LoginDisconnect(val) => return Err(protocol::Error::Disconnect(val.reason)),
val => return Err(protocol::Error::Err(format!("Wrong packet: {:?}", val))),
@ -199,7 +187,7 @@ impl Server {
let rx = Self::spawn_reader(read);
Ok(Server::new(username, protocol::UUID::from_str(&uuid), resources, console, Some(write), Some(rx)))
Ok(Server::new(username, protocol::UUID::from_str(&uuid), resources, Some(write), Some(rx)))
}
fn spawn_reader(mut read: protocol::Conn) -> mpsc::Receiver<Result<packet::Packet, protocol::Error>> {
@ -219,8 +207,8 @@ impl Server {
rx
}
pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>) -> Server {
let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, console, None, None);
pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>) -> Server {
let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, None, None);
let mut rng = rand::thread_rng();
for x in -7*16 .. 7*16 {
for z in -7*16 .. 7*16 {
@ -257,7 +245,7 @@ impl Server {
fn new(
username: String, uuid: protocol::UUID,
resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>,
resources: Arc<RwLock<resources::Manager>>,
conn: Option<protocol::Conn>, read_queue: Option<mpsc::Receiver<Result<packet::Packet, protocol::Error>>>
) -> Server {
let mut entities = ecs::Manager::new();
@ -284,7 +272,6 @@ impl Server {
version: version,
resources: resources,
console: console,
// Entity accessors
game_info: game_info,

30
src/settings.rs
View File

@ -59,19 +59,19 @@ pub const CL_KEYBIND_SNEAK: console::CVar<i64> = create_keybind!(LShift, "cl_key
pub const CL_KEYBIND_SPRINT: console::CVar<i64> = create_keybind!(LCtrl, "cl_keybind_sprint", "Keybinding for sprinting");
pub const CL_KEYBIND_JUMP: console::CVar<i64> = create_keybind!(Space, "cl_keybind_jump", "Keybinding for jumping");
pub fn register_vars(console: &mut console::Console) {
console.register(R_MAX_FPS);
console.register(R_FOV);
console.register(R_VSYNC);
console.register(CL_MASTER_VOLUME);
console.register(CL_KEYBIND_FORWARD);
console.register(CL_KEYBIND_BACKWARD);
console.register(CL_KEYBIND_LEFT);
console.register(CL_KEYBIND_RIGHT);
console.register(CL_KEYBIND_OPEN_INV);
console.register(CL_KEYBIND_SNEAK);
console.register(CL_KEYBIND_SPRINT);
console.register(CL_KEYBIND_JUMP);
pub fn register_vars(vars: &mut console::Vars) {
vars.register(R_MAX_FPS);
vars.register(R_FOV);
vars.register(R_VSYNC);
vars.register(CL_MASTER_VOLUME);
vars.register(CL_KEYBIND_FORWARD);
vars.register(CL_KEYBIND_BACKWARD);
vars.register(CL_KEYBIND_LEFT);
vars.register(CL_KEYBIND_RIGHT);
vars.register(CL_KEYBIND_OPEN_INV);
vars.register(CL_KEYBIND_SNEAK);
vars.register(CL_KEYBIND_SPRINT);
vars.register(CL_KEYBIND_JUMP);
}
#[derive(Hash, PartialEq, Eq)]
@ -93,9 +93,9 @@ impl Stevenkey {
Stevenkey::Sprint, Stevenkey::Jump)
}
pub fn get_by_keycode(keycode: Keycode, console: &console::Console) -> Option<Stevenkey> {
pub fn get_by_keycode(keycode: Keycode, vars: &console::Vars) -> Option<Stevenkey> {
for steven_key in Stevenkey::values() {
if keycode as i64 == *console.get(steven_key.get_cvar()) {
if keycode as i64 == *vars.get(steven_key.get_cvar()) {
return Some(steven_key)
}
}