sander/rust-2048
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Format code

Browse source
This commit is contained in:
Yannick Armand (PifyZ) 2015-05-25 20:05:51 +02:00
parent 97d3ed94ff
commit c1984f4e16
6 changed files with 114 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/app.rs
View file

@ -1,4 +1,4 @@
use std::path::{Path, PathBuf};
use std::path::{ Path, PathBuf };
use graphics::*;
use piston::input::Button;
@ -7,11 +7,7 @@ use piston::event::*;
use board::Board;
use number_renderer::NumberRenderer;
use settings::Settings;
use opengl_graphics::{
GlGraphics,
Texture,
};
use opengl_graphics::{ GlGraphics, Texture };
pub struct App<'a> {
board: Board<'a>,
@ -94,7 +90,6 @@ impl<'a> App<'a> {
}
pub fn render(&mut self, args: &RenderArgs, gl: &mut GlGraphics) {
let ref c = Context::abs(args.width as f64, args.height as f64);
let w_bg_col = self.window_background_color;

94
src/board.rs
View file

@ -1,17 +1,10 @@
use std::collections::HashSet;
// use std::iter::range_step_inclusive;
use rand::random;
use graphics::*;
use opengl_graphics::{
GlGraphics,
};
use opengl_graphics::{ GlGraphics };
use number_renderer::NumberRenderer;
use settings::Settings;
use tile::{
Tile,
TileState,
};
use tile::{ Tile, TileState };
fn rgb2rgba(c: [f32; 3]) -> [f32; 4] { [c[0], c[1], c[2], 1.0] }
@ -41,6 +34,7 @@ impl<'a> Board<'a> {
loop {
let x = (random::<u32>() % self.settings.tile_width as u32) as i32;
let y = (random::<u32>() % self.settings.tile_height as u32) as i32;
if self.get_tile(x, y).is_none() {
self.tiles.push(Tile::new(self.settings, 2, x, y));
break;
@ -56,16 +50,21 @@ impl<'a> Board<'a> {
if self.is_locking() {
return;
}
let mut score_to_added = 0;
let mut tiles_need_removed = HashSet::<usize>::new();
let mut tiles_need_added = Vec::<Tile>::new();
for i in 0..self.tiles.len() {
let tile1 = &self.tiles[i];
if tile1.status != TileState::TileStatic {
continue;
}
for j in i+1..self.tiles.len() {
let tile2 = &self.tiles[j];
if tile2.status != TileState::TileStatic
|| tile1.tile_x != tile2.tile_x
|| tile1.tile_y != tile2.tile_y {
@ -82,15 +81,18 @@ impl<'a> Board<'a> {
if tiles_need_removed.len() > 0 {
let mut tiles = Vec::<Tile>::new();
for i in 0..self.tiles.len() {
if !tiles_need_removed.contains(&i) {
tiles.push(self.tiles[i].clone());
}
}
// better but unstable: tiles.append(&mut tiles_need_added);
while let Some(tile_to_add) = tiles_need_added.pop() {
tiles.push(tile_to_add);
}
self.tiles = tiles;
self.add_score(score_to_added);
}
@ -98,11 +100,11 @@ impl<'a> Board<'a> {
pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
number_renderer.render(
self.score as u32,
self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,
self.settings.best_rect[1] + self.settings.best_rect[3] / 2.0,
self.settings.best_rect[2],
self.settings.text_light_color, c, gl);
self.score as u32,
self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,
self.settings.best_rect[1] + self.settings.best_rect[3] / 2.0,
self.settings.best_rect[2],
self.settings.text_light_color, c, gl);
self.render_board(c, gl);
self.render_tiles(number_renderer, c, gl);
@ -123,14 +125,22 @@ impl<'a> Board<'a> {
println!("return");
return;
}
let mut need_generate = false;
let mut steps: Vec<i32> = Vec::with_capacity(self.settings.tile_height as usize);
let mut next_step = y_start;
if y_step < 0 {
while next_step > y_end { steps.push(next_step); next_step += y_step }
while next_step > y_end {
steps.push(next_step); next_step += y_step
}
} else {
while next_step < y_end { steps.push(next_step); next_step += y_step }
};
while next_step < y_end {
steps.push(next_step); next_step += y_step
}
}
loop {
// move all tiles to right place
for col in 0 .. self.settings.tile_width {
@ -182,6 +192,7 @@ impl<'a> Board<'a> {
}
}
}
if found {
need_generate = true;
did_merged = true;
@ -195,6 +206,7 @@ impl<'a> Board<'a> {
break;
}
}
if need_generate {
self.generate_tile();
}
@ -218,16 +230,21 @@ impl<'a> Board<'a> {
let mut need_generate = false;
let mut steps: Vec<i32> = Vec::with_capacity(self.settings.tile_width as usize);
let mut next_step = x_start;
if x_step < 0 {
while next_step > x_end { steps.push(next_step); next_step += x_step }
while next_step > x_end {
steps.push(next_step); next_step += x_step
}
} else {
while next_step < x_end { steps.push(next_step); next_step += x_step }
};
while next_step < x_end {
steps.push(next_step); next_step += x_step
}
}
loop {
// move all tiles to right place
for row in 0..self.settings.tile_height {
for col in steps.to_vec() {
match self.get_mut_tile(col, row) {
None => {
match self.get_mut_next_tile(col, row, x_step, 0) {
@ -274,6 +291,7 @@ impl<'a> Board<'a> {
}
}
}
if found {
need_generate = true;
did_merged = true;
@ -325,6 +343,7 @@ impl<'a> Board<'a> {
while x >= 0 && x < self.settings.tile_width
&& y >= 0 && y < self.settings.tile_height {
let tile = self.get_tile(x, y);
if tile.is_some() {
found = true;
break;
@ -334,7 +353,7 @@ impl<'a> Board<'a> {
}
if found {
self.get_mut_tile(x, y)
self.get_mut_tile(x, y)
} else {
None
}
@ -346,6 +365,7 @@ impl<'a> Board<'a> {
return Some(tile);
}
}
None
}
@ -355,6 +375,7 @@ impl<'a> Board<'a> {
return Some(tile);
}
}
None
}
@ -365,31 +386,36 @@ impl<'a> Board<'a> {
count += 1;
}
}
count
}
fn render_board(&self, c: &Context, gl: &mut GlGraphics) {
Rectangle::new(rgb2rgba(self.settings.label_color))
.draw([self.settings.board_padding,
self.settings.board_padding + self.settings.board_offset_y,
self.settings.board_size[0],
self.settings.board_size[1]],
default_draw_state(),
c.transform,
gl);
.draw(
[self.settings.board_padding,
self.settings.board_padding + self.settings.board_offset_y,
self.settings.board_size[0],
self.settings.board_size[1]],
default_draw_state(),
c.transform,
gl);
let mut x = self.settings.board_padding + self.settings.tile_padding;
let mut y = self.settings.board_padding + self.settings.board_offset_y + self.settings.tile_padding;
for _ in 0..self.settings.tile_height {
for _ in 0..self.settings.tile_width {
Rectangle::new(rgb2rgba(self.settings.tiles_colors[0]))
.draw([x, y, self.settings.tile_size, self.settings.tile_size],
default_draw_state(),
c.transform,
gl);
Rectangle::new(
rgb2rgba(self.settings.tiles_colors[0]))
.draw([x, y, self.settings.tile_size, self.settings.tile_size],
default_draw_state(),
c.transform,
gl);
x += self.settings.tile_padding + self.settings.tile_size;
}
x = self.settings.board_padding + self.settings.tile_padding;
y += self.settings.tile_padding + self.settings.tile_size;
}

32
src/main.rs
View file

@ -7,9 +7,9 @@ extern crate opengl_graphics;
extern crate sdl2_window;
use piston::event::*;
use piston::window::{WindowSettings, Size};
use piston::window::{ WindowSettings, Size };
use sdl2_window::Sdl2Window;
use opengl_graphics::{GlGraphics,OpenGL};
use opengl_graphics::{ GlGraphics, OpenGL };
mod app;
mod board;
@ -32,45 +32,23 @@ fn main() {
app.load();
/*
let game_iter_settings = GameIteratorSettings {
updates_per_second: 120,
max_frames_per_second: 60,
};
*/
let mut gl = GlGraphics::new(OpenGL::_3_2);
for e in window.events() {
use piston::event::{ RenderEvent, PressEvent };
if let Some(ref args) = e.render_args() {
app.render(args, &mut gl);
}
if let Some(ref args) = e.update_args() {
if let Some(ref args) = e.update_args() {
// TODO: only update if necessary
// println!("update");
app.update(args);
}
if let Some(ref args) = e.press_args() {
app.key_press(args);
}
}
/*
for e in GameIterator::new(&mut window, &game_iter_settings) {
match e {
Render(ref args) => {
app.render(args);
},
Update(ref args) => {
app.update(args);
},
KeyPress(ref args) => {
app.key_press(args);
},
_ => {},
}
}
*/
}

10
src/number_renderer.rs
View file

@ -1,10 +1,6 @@
use std::path::Path;
use graphics::*;
use opengl_graphics::{
GlGraphics,
Texture,
};
use opengl_graphics::{ GlGraphics, Texture };
static DIGITS_WIDTH: f64 = 20.0;
static DIGITS_HEIGHT: f64 = 26.0;
@ -42,6 +38,7 @@ impl NumberRenderer {
default_draw_state(),
c.transform,
gl);
x += width;
}
}
@ -49,15 +46,18 @@ impl NumberRenderer {
fn number_to_digits(number: u32) -> Vec<u32> {
let mut digits = Vec::<u32>::new();
if number == 0 {
digits.push(0);
return digits;
}
let mut n = number;
while n != 0 {
digits.insert(0, n % 10);
n /= 10;
}
digits
}

69
src/settings.rs
View file

@ -3,11 +3,7 @@ use std::env::current_exe;
use std::io::{BufWriter, BufReader, Write};
use std::fs::{File};
use std::path::Path;
use rustc_serialize::{
json,
Encodable,
Decodable,
};
use rustc_serialize::{ json, Encodable, Decodable };
static SETTING_FILENAME: &'static str = "settings.json";
@ -47,10 +43,10 @@ impl Settings {
let board_size = [
s.tile_size * s.tile_width as f64 + s.tile_padding * (s.tile_width + 1) as f64,
s.tile_size * s.tile_height as f64 + s.tile_padding * (s.tile_height + 1) as f64,
];
let mut tiles_colors = Vec::<[f32; 3]>::new();
for color in s.tiles_colors.iter() {
tiles_colors.push([
color[0] / 255.0,
@ -58,6 +54,7 @@ impl Settings {
color[2] / 255.0,
]);
}
Settings {
asset_folder: s.asset_folder.clone(),
comment1_offset_y: s.comment1_offset_y,
@ -213,44 +210,52 @@ impl SettingsInJson {
pub fn load() -> SettingsInJson {
let exe_path = current_exe();
if exe_path.is_err() {
return SettingsInJson::default_settings();
}
let mut exe_path = exe_path.unwrap();
exe_path.pop();
let path = exe_path.join(Path::new(SETTING_FILENAME));
// FIXME: use this if possible (.exists() is unstable in Rust 1.0.0)
/* if !path.as_path().exists() || !path.is_file() {
println!("Configuration file not found. Generating a default one.");
let default = SettingsInJson::default_settings();
default.save();
return default;
}
let file = File::open(&path).unwrap();
let mut reader = BufReader::new(file);
*/
let file = File::open(&path);
match file {
Err(e) => {
println!("Configuration file can't be open ({}). Try to generate a default one.", e);
let default = SettingsInJson::default_settings();
default.save();
return default;
},
_ => {}
}
let mut reader = BufReader::new(file.unwrap());
// End FIXME
// FIXME: use this if possible (.exists() is unstable in Rust 1.0.0)
/* if !path.as_path().exists() || !path.is_file() {
println!("Configuration file not found. Generating a default one.");
let default = SettingsInJson::default_settings();
default.save();
return default;
}
let file = File::open(&path).unwrap();
let mut reader = BufReader::new(file);
*/
let file = File::open(&path);
match file {
Err(e) => {
println!("Configuration file can't be open ({}). Try to generate a default one.", e);
let default = SettingsInJson::default_settings();
default.save();
return default;
},
_ => {}
}
let mut reader = BufReader::new(file.unwrap());
// End FIXME
let mut decoder = json::Decoder::new(json::Json::from_reader(&mut reader).unwrap());
Decodable::decode(&mut decoder).unwrap()
}
pub fn save(&self) {
let exe_path = current_exe();
if exe_path.is_err() {
println!("WARNING: Failed to save settings: can't find exe path.");
return;
}
let path = exe_path.unwrap();
let file = File::create(&path.with_file_name(SETTING_FILENAME)).unwrap();
let mut writer = BufWriter::new(file);
@ -260,14 +265,10 @@ impl SettingsInJson {
if let Err(e) = writer.write(encoded.as_bytes()) {
println!("WARNING: Failed to save settings: {}", e);
}
}, Err(e) => {
},
Err(e) => {
println!("WARNING: Failed to save settings: {}", e);
}
}
// match self.encode(&mut encoder) {
// Ok(()) => (),
// Err(e) => { println!("WARNING: Failed to save settings: {}", e); },
// }
}
}

4
src/tile.rs
View file

@ -1,4 +1,3 @@
use graphics::*;
use opengl_graphics::GlGraphics;
use number_renderer::NumberRenderer;
@ -106,6 +105,7 @@ impl<'a> Tile<'a> {
pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
let mut pos = self.tile_to_pos(self.tile_x, self.tile_y);
let mut size = (self.settings.tile_size, self.settings.tile_size);
match self.status {
TileState::TileMoving(_, x, y, _, _) => {
pos = (x, y);
@ -118,6 +118,7 @@ impl<'a> Tile<'a> {
},
_ => {},
}
let (x, y) = pos;
let (w, h) = size;
let color = self.get_color();
@ -135,6 +136,7 @@ impl<'a> Tile<'a> {
} else {
self.settings.text_dark_color
};
number_renderer.render(self.score as u32, x + self.settings.tile_size / 2.0, y + self.settings.tile_size / 2.0, self.settings.tile_size, color, c, gl);
}