Struct FileProperties

Source

pub struct FileProperties {
    pub transparent: bool,
    pub name: &'static str,
    pub num_tiles: usize,
}

Fields§

§transparent: bool§name: &'static str§num_tiles: usize

Implementations§

Source §

impl FileProperties

Source

pub fn get_all() -> Vec<Self>

Examples found in repository ?

examples/tilestopng.rs (line 30)

27fn main() -> Result<()> {
28    let args = Arguments::parse();
29
30    let file_properties = FileProperties::get_all();
31    let max_tiles =
32        file_properties.iter().map(|p| p.num_tiles).sum::<usize>();
33
34    let tilecache = TileCache::load_from_path(&args.directory)?;
35
36    create_dir_all(&args.destination)?;
37
38    for i in 0..max_tiles {
39        let tile = tilecache.get_tile(i).unwrap();
40        let filename = format!("tile_{:04}.png", i);
41        tile.save(args.destination.join(filename))
42            .map_err(Error::msg)?;
43    }
44    Ok(())
45}

More examples

Hide additional examples

examples/tilecache.rs (line 24)

21fn main() -> Result<()> {
22    const VERSION: &str = env!("CARGO_PKG_VERSION");
23
24    let file_properties = FileProperties::get_all();
25    let max_tiles =
26        file_properties.iter().map(|p| p.num_tiles).max().unwrap();
27
28    let settings = Settings::load_or_create();
29    let sdl_context = sdl2::init().map_err(Error::msg)?;
30    let video_subsystem = sdl_context.video().map_err(Error::msg)?;
31    let ttf_context = sdl2::ttf::init()?;
32    let mut event_pump = sdl_context.event_pump().map_err(Error::msg)?;
33
34    let sizes = DefaultSizes;
35    let window = game::create_window(
36        (max_tiles + 2) as u32 * sizes.width(),
37        (file_properties.len() as u32 + 2) * sizes.height(),
38        settings.fullscreen,
39        &format!("Freenukum {} tilecache example", VERSION),
40        &video_subsystem,
41    )?;
42
43    let mut canvas = window.into_canvas().present_vsync().build()?;
44    canvas.set_draw_color(Color::RGB(0, 0, 0));
45    canvas.clear();
46    canvas.present();
47    let texture_creator = canvas.texture_creator();
48
49    game::check_episodes(
50        &mut canvas,
51        &load_default_font(&ttf_context)?,
52        &texture_creator,
53        &mut event_pump,
54    )?;
55    let tilecache = TileCache::load_from_path(&original_data_dir())?;
56
57    let mut dest = Point::new(sizes.width() as i32, 0);
58
59    let mut renderer = CanvasRenderer {
60        canvas: &mut canvas,
61        texture_creator: &texture_creator,
62        tileprovider: &tilecache,
63    };
64
65    let blithex = |value: usize,
66                   dest: Point,
67                   renderer: &mut dyn Renderer|
68     -> Result<()> {
69        let mut renderer = MovePositionRenderer {
70            offset_x: dest.x(),
71            offset_y: dest.y(),
72            upstream: renderer,
73        };
74        text::render(&mut renderer, &format!("{:02X}", value))
75    };
76
77    for x in 0..max_tiles {
78        blithex(x, dest, &mut renderer)?;
79        dest.x += sizes.width() as i32;
80    }
81    dest.x = 0;
82    dest.y += sizes.height() as i32;
83
84    let mut i = 0;
85    for (row, file) in FileProperties::get_all().iter().enumerate() {
86        blithex(row, dest, &mut renderer)?;
87        dest.x += sizes.width() as i32;
88        for _ in 0..file.num_tiles {
89            renderer.place_tile(i, dest)?;
90            dest.x += sizes.width() as i32;
91            i += 1;
92        }
93        dest.x = (sizes.width() * (max_tiles as u32 + 1)) as i32;
94        blithex(row, dest, &mut renderer)?;
95        dest.x = 0;
96        dest.y += sizes.height() as i32;
97    }
98    dest.x += sizes.width() as i32;
99    for x in 0..max_tiles {
100        blithex(x, dest, &mut renderer)?;
101        dest.x += sizes.width() as i32;
102    }
103
104    canvas.present();
105
106    'event_loop: loop {
107        match event_pump.wait_event() {
108            Event::Quit { .. }
109            | Event::KeyDown {
110                keycode: Some(Keycode::Escape),
111                ..
112            }
113            | Event::KeyDown {
114                keycode: Some(Keycode::Q),
115                ..
116            } => break 'event_loop,
117            Event::Window {
118                win_event: WindowEvent::Exposed,
119                ..
120            }
121            | Event::Window {
122                win_event: WindowEvent::Shown,
123                ..
124            } => canvas.present(),
125            _ => {}
126        }
127    }
128    Ok(())
129}