85 lines
2.4 KiB
Rust
85 lines
2.4 KiB
Rust
|
|
use graphics::*;
|
|
use piston::*;
|
|
use settings;
|
|
|
|
#[deriving(Clone, Eq)]
|
|
pub enum TileState {
|
|
TileStatic,
|
|
/// (t, x, y)
|
|
TileMoving(f64, f64, f64),
|
|
}
|
|
|
|
#[deriving(Clone)]
|
|
pub struct Tile {
|
|
pub score: int,
|
|
pub tile_x: int,
|
|
pub tile_y: int,
|
|
pub status: TileState,
|
|
}
|
|
|
|
impl Tile {
|
|
pub fn new(score: int, tile_x: int, tile_y: int) -> Tile {
|
|
Tile {
|
|
score: score,
|
|
tile_x: tile_x,
|
|
tile_y: tile_y,
|
|
status: TileStatic,
|
|
}
|
|
}
|
|
|
|
fn tile_to_pos(tile_x: int, tile_y: int) -> (f64, f64) {
|
|
let x = settings::BOARD_PADDING + tile_x as f64 * settings::TILE_SIZE + (tile_x + 1) as f64 * settings::TILE_PADDING;
|
|
let y = settings::BOARD_PADDING + settings::BOARD_OFFSET_Y + tile_y as f64 * settings::TILE_SIZE + (tile_y + 1) as f64 * settings::TILE_PADDING;
|
|
(x, y)
|
|
}
|
|
|
|
pub fn start_moving(&mut self, destination_tile_x: int, destination_tile_y: int) {
|
|
let (x, y) = Tile::tile_to_pos(self.tile_x, self.tile_y);
|
|
self.status = TileMoving(settings::TILE_MOVE_TIME, x, y);
|
|
self.tile_x = destination_tile_x;
|
|
self.tile_y = destination_tile_y;
|
|
}
|
|
|
|
pub fn update(&mut self, dt: f64) {
|
|
match self.status {
|
|
TileMoving(t, x, y) => {
|
|
if dt >= t {
|
|
self.status = TileStatic;
|
|
} else {
|
|
let (dx, dy) = Tile::tile_to_pos(self.tile_x, self.tile_y);
|
|
let factor = dt / t;
|
|
self.status = TileMoving(t - dt, x + factor * (dx - x), y + factor * (dy - y));
|
|
}
|
|
},
|
|
TileStatic => {},
|
|
}
|
|
}
|
|
|
|
pub fn render(&self, c: &Context, gl: &mut Gl) {
|
|
let mut pos = (0.0, 0.0);
|
|
match self.status {
|
|
TileMoving(_, x, y) => {
|
|
pos = (x, y);
|
|
},
|
|
TileStatic => {
|
|
pos = Tile::tile_to_pos(self.tile_x, self.tile_y);
|
|
},
|
|
}
|
|
let (x, y) = pos;
|
|
let color = self.get_color();
|
|
c.view()
|
|
.rect(x, y, settings::TILE_SIZE, settings::TILE_SIZE)
|
|
.rgba(color[0], color[1], color[2], color[3]).fill(gl);
|
|
}
|
|
|
|
fn get_color(&self) -> [f32, ..4] {
|
|
let i = (self.score as f64).log2() as uint;
|
|
if i > 0 && i < settings::TILES_COLOR.len() {
|
|
settings::TILES_COLOR[i]
|
|
} else {
|
|
settings::TILE_UNKNOW_COLOR
|
|
}
|
|
}
|
|
}
|
|
|