tilecache/
tilecache.rs

1// SPDX-License-Identifier: AGPL-3.0-or-later
2// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
3
4use anyhow::{Error, Result};
5use freenukum::data::original_data_dir;
6use freenukum::graphics::load_default_font;
7use freenukum::rendering::{
8    CanvasRenderer, MovePositionRenderer, Renderer,
9};
10use freenukum::settings::Settings;
11use freenukum::text;
12use freenukum::tilecache::{FileProperties, TileCache};
13use freenukum::{game, DefaultSizes, Sizes};
14use sdl2::{
15    event::{Event, WindowEvent},
16    keyboard::Keycode,
17    pixels::Color,
18    rect::Point,
19};
20
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}