rust/lib-hedgewars-engine/src/world.rs
changeset 14704 12db7e435ea6
parent 14702 29dbe9ce8b7d
child 14705 19122a329774
equal deleted inserted replaced
14703:81030dcbd2d8 14704:12db7e435ea6
     8     LandGenerator,
     8     LandGenerator,
     9 };
     9 };
    10 use lfprng::LaggedFibonacciPRNG;
    10 use lfprng::LaggedFibonacciPRNG;
    11 use hwphysics as hwp;
    11 use hwphysics as hwp;
    12 
    12 
    13 use crate::render::MapRenderer;
    13 use crate::render::{
       
    14     MapRenderer,
       
    15     camera::Camera
       
    16 };
    14 
    17 
    15 struct GameState {
    18 struct GameState {
    16     land: Land2D<u32>,
    19     land: Land2D<u32>,
    17     physics: hwp::World,
    20     physics: hwp::World,
    18 }
    21 }
    29 pub struct World {
    32 pub struct World {
    30     random_numbers_gen: LaggedFibonacciPRNG,
    33     random_numbers_gen: LaggedFibonacciPRNG,
    31     preview: Option<Land2D<u8>>,
    34     preview: Option<Land2D<u8>>,
    32     game_state: Option<GameState>,
    35     game_state: Option<GameState>,
    33     renderer: MapRenderer,
    36     renderer: MapRenderer,
       
    37     camera: Camera
    34 }
    38 }
    35 
    39 
    36 impl World {
    40 impl World {
    37     pub fn new() -> Self {
    41     pub fn new() -> Self {
    38         Self {
    42         Self {
    39             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    43             random_numbers_gen: LaggedFibonacciPRNG::new(&[]),
    40             preview: None,
    44             preview: None,
    41             game_state: None,
    45             game_state: None,
    42             renderer: MapRenderer::new(512, 512),
    46             renderer: MapRenderer::new(512, 512),
       
    47             camera: Camera::new()
    43         }
    48         }
    44     }
    49     }
    45 
    50 
    46     pub fn set_seed(&mut self, seed: &[u8]) {
    51     pub fn set_seed(&mut self, seed: &[u8]) {
    47         self.random_numbers_gen = LaggedFibonacciPRNG::new(seed);
    52         self.random_numbers_gen = LaggedFibonacciPRNG::new(seed);
    93         self.renderer.init(&texture);
    98         self.renderer.init(&texture);
    94         
    99         
    95         self.game_state = Some(GameState::new(land, physics));
   100         self.game_state = Some(GameState::new(land, physics));
    96     }
   101     }
    97 
   102 
    98     pub fn render(&mut self, x: f32, y: f32, w: f32, h: f32) {
   103     pub fn move_camera(&mut self, position_shift: Point, zoom_shift: f32) {
       
   104         self.camera.position += position_shift;
       
   105         self.camera.zoom += zoom_shift;
       
   106     }
       
   107 
       
   108     pub fn render(&mut self) {
       
   109 
    99         unsafe {
   110         unsafe {
   100             gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
   111             gl::ClearColor(0.4f32, 0f32, 0.2f32, 1f32);
   101             gl::Clear(gl::COLOR_BUFFER_BIT);
   112             gl::Clear(gl::COLOR_BUFFER_BIT);
   102         }
   113         }
   103 
   114 
   104         self.renderer.render(Rect::new(
   115         self.renderer.render(self.camera.viewport());
   105             Point::new(x as _, y as _),
       
   106             Point::new((x + w) as _, (y + h) as _),
       
   107         ));
       
   108     }
   116     }
   109 
   117 
   110     pub fn step(&mut self) {
   118     pub fn step(&mut self) {
   111         if let Some(ref mut state) = self.game_state {
   119         if let Some(ref mut state) = self.game_state {
   112             state.physics.step(fp!(1), &state.land);
   120             state.physics.step(fp!(1), &state.land);