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(), default: &|| "".to_owned(),
}; };
pub fn register_vars(console: &mut console::Console) { pub fn register_vars(vars: &mut console::Vars) {
console.register(CL_USERNAME); vars.register(CL_USERNAME);
console.register(CL_UUID); vars.register(CL_UUID);
console.register(AUTH_TOKEN); vars.register(AUTH_TOKEN);
console.register(AUTH_CLIENT_TOKEN); vars.register(AUTH_CLIENT_TOKEN);
} }

166
src/console/mod.rs
View File

@ -15,6 +15,7 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::collections::HashMap; use std::collections::HashMap;
use std::any::Any; use std::any::Any;
use std::cell::{RefCell, Ref};
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::fs; use std::fs;
use std::io::{BufWriter, Write, BufRead, BufReader}; use std::io::{BufWriter, Write, BufRead, BufReader};
@ -98,32 +99,18 @@ pub trait Var {
fn can_serialize(&self) -> bool; fn can_serialize(&self) -> bool;
} }
pub struct Console { pub struct Vars {
names: HashMap<String, &'static str>, names: HashMap<String, &'static str>,
vars: HashMap<&'static str, Box<Var>>, vars: HashMap<&'static str, Box<Var>>,
var_values: HashMap<&'static str, Box<Any>>, var_values: HashMap<&'static str, RefCell<Box<Any>>>,
history: Vec<Component>,
collection: ui::Collection,
active: bool,
position: f64,
} }
unsafe impl Send for Console {} impl Vars {
pub fn new() -> Vars {
impl Console { Vars {
pub fn new() -> Console {
Console {
names: HashMap::new(), names: HashMap::new(),
vars: HashMap::new(), vars: HashMap::new(),
var_values: 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); panic!("Key registered twice {}", var.name);
} }
self.names.insert(var.name.to_owned(), 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)); 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 where CVar<T>: Var
{ {
// Should never fail // 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 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(); 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 { pub fn is_active(&self) -> bool {
self.active self.active
} }
@ -188,20 +235,12 @@ impl Console {
ui::Mode::Unscaled(scale) => 854.0 / scale, ui::Mode::Unscaled(scale) => 854.0 / scale,
}; };
let mut background = let mut background = ui::Image::new(
ui::Image::new(render::Renderer::get_texture(renderer.get_textures_ref(), render::Renderer::get_texture(renderer.get_textures_ref(), "steven:solid"),
"steven:solid"), 0.0, self.position, w, 220.0,
0.0, 0.0, 0.0, 1.0, 1.0,
self.position, 0, 0, 0
w, );
220.0,
0.0,
0.0,
1.0,
1.0,
0,
0,
0);
background.set_a(180); background.set_a(180);
let background = self.collection.add(ui_container.add(background)); let background = self.collection.add(ui_container.add(background));
@ -211,11 +250,12 @@ impl Console {
if offset >= 210.0 { if offset >= 210.0 {
break; break;
} }
let mut fmt = ui::Formatted::with_width_limit(renderer, let mut fmt = ui::Formatted::with_width_limit(
line.clone(), renderer,
5.0, line.clone(),
5.0 + offset, 5.0, 5.0 + offset,
w - 1.0); w - 1.0
);
fmt.set_parent(&background); fmt.set_parent(&background);
fmt.set_v_attach(ui::VAttach::Bottom); fmt.set_v_attach(ui::VAttach::Bottom);
offset += fmt.get_height(); 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) { fn log(&mut self, record: &log::LogRecord) {
for filtered in FILTERED_CRATES { for filtered in FILTERED_CRATES {
if record.location().module_path().starts_with(filtered) { if record.location().module_path().starts_with(filtered) {

57
src/main.rs
View File

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

29
src/screen/login.rs
View File

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

47
src/screen/settings_menu.rs
View File

@ -3,7 +3,7 @@ use render;
use ui; use ui;
use settings; 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>) { 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); 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 { pub struct SettingsMenu {
console: Arc<Mutex<console::Console>>, vars: Rc<console::Vars>,
elements: Option<UIElements>, elements: Option<UIElements>,
show_disconnect_button: bool show_disconnect_button: bool
} }
impl SettingsMenu { 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 { SettingsMenu {
console: console, vars: vars,
elements: None, elements: None,
show_disconnect_button: show_disconnect_button show_disconnect_button: show_disconnect_button
} }
@ -78,14 +78,14 @@ impl super::Screen for SettingsMenu {
// From top and down // From top and down
let (btn_audio_settings, txt_audio_settings) = new_submenu_button("Audio settings...", renderer, ui_container, -160.0, -50.0); 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, _| { 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(btn_audio_settings);
elements.add(txt_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); 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, _| { 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(btn_video_settings);
elements.add(txt_video_settings); elements.add(txt_video_settings);
@ -166,14 +166,14 @@ impl super::Screen for SettingsMenu {
} }
pub struct VideoSettingsMenu { pub struct VideoSettingsMenu {
console: Arc<Mutex<console::Console>>, vars: Rc<console::Vars>,
elements: Option<UIElements>, elements: Option<UIElements>,
} }
impl VideoSettingsMenu { impl VideoSettingsMenu {
pub fn new(console: Arc<Mutex<console::Console>>) -> VideoSettingsMenu { pub fn new(vars: Rc<console::Vars>) -> VideoSettingsMenu {
VideoSettingsMenu { VideoSettingsMenu {
console: console, vars: vars,
elements: None, elements: None,
} }
} }
@ -193,14 +193,9 @@ impl super::Screen for VideoSettingsMenu {
let background = elements.add(ui_container.add(background)); let background = elements.add(ui_container.add(background));
// Load defaults // Load defaults
let (r_max_fps, r_fov, r_vsync) = { let r_max_fps = *self.vars.get(settings::R_MAX_FPS);
let console = self.console.lock().unwrap(); let r_fov = *self.vars.get(settings::R_FOV);
( let r_vsync = *self.vars.get(settings::R_VSYNC);
console.get(settings::R_MAX_FPS).clone(),
console.get(settings::R_FOV).clone(),
console.get(settings::R_VSYNC).clone()
)
};
// Setting buttons // Setting buttons
// TODO: Slider // 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); 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()); elements.add(txt_vsync.clone());
super::button_action(ui_container, btn_vsync.clone(), Some(txt_vsync.clone()), move | game, ui_container | { 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 = !*game.vars.get(settings::R_VSYNC);
let r_vsync = !console.get(settings::R_VSYNC);
let txt_vsync = ui_container.get_mut(&txt_vsync); let txt_vsync = ui_container.get_mut(&txt_vsync);
txt_vsync.set_text(&game.renderer, get_bool_str!("VSync: {}", r_vsync, "Enabled", "Disabled")); 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); elements.add(btn_vsync);
@ -273,14 +267,14 @@ impl super::Screen for VideoSettingsMenu {
} }
pub struct AudioSettingsMenu { pub struct AudioSettingsMenu {
console: Arc<Mutex<console::Console>>, vars: Rc<console::Vars>,
elements: Option<UIElements> elements: Option<UIElements>
} }
impl AudioSettingsMenu { impl AudioSettingsMenu {
pub fn new(console: Arc<Mutex<console::Console>>) -> AudioSettingsMenu { pub fn new(vars: Rc<console::Vars>) -> AudioSettingsMenu {
AudioSettingsMenu { AudioSettingsMenu {
console: console, vars: vars,
elements: None elements: None
} }
} }
@ -299,12 +293,9 @@ impl super::Screen for AudioSettingsMenu {
background.set_a(100); background.set_a(100);
let background = elements.add(ui_container.add(background)); let background = elements.add(ui_container.add(background));
let master_volume = { let master_volume = *self.vars.get(settings::CL_MASTER_VOLUME);
let console = self.console.lock().unwrap();
(console.get(settings::CL_MASTER_VOLUME).clone())
};
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(btn_master_volume);
elements.add(txt_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;
use world::block; use world::block;
use rand::{self, Rng}; use rand::{self, Rng};
use std::sync::{Arc, RwLock, Mutex}; use std::sync::{Arc, RwLock};
use std::sync::mpsc; use std::sync::mpsc;
use std::thread; use std::thread;
use std::collections::HashMap; use std::collections::HashMap;
use std::hash::BuildHasherDefault; use std::hash::BuildHasherDefault;
use types::hash::FNVHash; use types::hash::FNVHash;
use resources; use resources;
use console;
use render; use render;
use settings::Stevenkey; use settings::Stevenkey;
use auth;
use ecs; use ecs;
use entity; use entity;
use cgmath; use cgmath;
@ -54,7 +52,6 @@ pub struct Server {
tick_time: bool, tick_time: bool,
resources: Arc<RwLock<resources::Manager>>, resources: Arc<RwLock<resources::Manager>>,
console: Arc<Mutex<console::Console>>,
version: usize, version: usize,
// Entity accessors // Entity accessors
@ -104,20 +101,11 @@ macro_rules! handle_packet {
impl Server { 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::pkey;
use openssl::crypto::rand::rand_bytes; use openssl::crypto::rand::rand_bytes;
let mut conn = try!(protocol::Conn::new(address)); 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 host = conn.host.clone();
let port = conn.port; let port = conn.port;
try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake { try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
@ -149,7 +137,7 @@ impl Server {
read.state = protocol::State::Play; read.state = protocol::State::Play;
write.state = protocol::State::Play; write.state = protocol::State::Play;
let rx = Self::spawn_reader(read); 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)), protocol::packet::Packet::LoginDisconnect(val) => return Err(protocol::Error::Disconnect(val.reason)),
val => return Err(protocol::Error::Err(format!("Wrong packet: {:?}", val))), val => return Err(protocol::Error::Err(format!("Wrong packet: {:?}", val))),
@ -199,7 +187,7 @@ impl Server {
let rx = Self::spawn_reader(read); 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>> { fn spawn_reader(mut read: protocol::Conn) -> mpsc::Receiver<Result<packet::Packet, protocol::Error>> {
@ -219,8 +207,8 @@ impl Server {
rx rx
} }
pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>) -> Server { pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>) -> Server {
let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, console, None, None); let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, None, None);
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
for x in -7*16 .. 7*16 { for x in -7*16 .. 7*16 {
for z in -7*16 .. 7*16 { for z in -7*16 .. 7*16 {
@ -257,7 +245,7 @@ impl Server {
fn new( fn new(
username: String, uuid: protocol::UUID, 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>>> conn: Option<protocol::Conn>, read_queue: Option<mpsc::Receiver<Result<packet::Packet, protocol::Error>>>
) -> Server { ) -> Server {
let mut entities = ecs::Manager::new(); let mut entities = ecs::Manager::new();
@ -284,7 +272,6 @@ impl Server {
version: version, version: version,
resources: resources, resources: resources,
console: console,
// Entity accessors // Entity accessors
game_info: game_info, 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_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 const CL_KEYBIND_JUMP: console::CVar<i64> = create_keybind!(Space, "cl_keybind_jump", "Keybinding for jumping");
pub fn register_vars(console: &mut console::Console) { pub fn register_vars(vars: &mut console::Vars) {
console.register(R_MAX_FPS); vars.register(R_MAX_FPS);
console.register(R_FOV); vars.register(R_FOV);
console.register(R_VSYNC); vars.register(R_VSYNC);
console.register(CL_MASTER_VOLUME); vars.register(CL_MASTER_VOLUME);
console.register(CL_KEYBIND_FORWARD); vars.register(CL_KEYBIND_FORWARD);
console.register(CL_KEYBIND_BACKWARD); vars.register(CL_KEYBIND_BACKWARD);
console.register(CL_KEYBIND_LEFT); vars.register(CL_KEYBIND_LEFT);
console.register(CL_KEYBIND_RIGHT); vars.register(CL_KEYBIND_RIGHT);
console.register(CL_KEYBIND_OPEN_INV); vars.register(CL_KEYBIND_OPEN_INV);
console.register(CL_KEYBIND_SNEAK); vars.register(CL_KEYBIND_SNEAK);
console.register(CL_KEYBIND_SPRINT); vars.register(CL_KEYBIND_SPRINT);
console.register(CL_KEYBIND_JUMP); vars.register(CL_KEYBIND_JUMP);
} }
#[derive(Hash, PartialEq, Eq)] #[derive(Hash, PartialEq, Eq)]
@ -93,9 +93,9 @@ impl Stevenkey {
Stevenkey::Sprint, Stevenkey::Jump) 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() { 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) return Some(steven_key)
} }
} }