2023-02-06 14:39:04 +00:00
|
|
|
/*
|
|
|
|
Copyright 2023, Savanni D'Gerinel <savanni@luminescent-dreams.com>
|
|
|
|
|
|
|
|
This file is part of the Luminescent Dreams Tools.
|
|
|
|
|
|
|
|
Luminescent Dreams Tools is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
Luminescent Dreams Tools is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along with Lumeto. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2023-02-06 14:36:02 +00:00
|
|
|
use cairo::{Context, Path};
|
|
|
|
use coordinates::{hex_map::parse_data, AxialAddr};
|
|
|
|
use gio::resources_lookup_data;
|
|
|
|
use glib::{subclass::InitializingObject, Object};
|
|
|
|
use gtk::{
|
|
|
|
gdk_pixbuf::Pixbuf, gio, prelude::*, subclass::prelude::*, Application, CompositeTemplate,
|
|
|
|
DrawingArea, Label,
|
|
|
|
};
|
2023-02-12 03:24:54 +00:00
|
|
|
use image::{io::Reader as ImageReader, DynamicImage};
|
2023-02-06 14:36:02 +00:00
|
|
|
use std::{cell::RefCell, io::Cursor, rc::Rc};
|
|
|
|
|
|
|
|
const APP_ID: &'static str = "com.luminescent-dreams.hex-grid";
|
|
|
|
const HEX_RADIUS: f64 = 50.;
|
|
|
|
const MAP_RADIUS: usize = 3;
|
|
|
|
const DRAWING_ORIGIN: (f64, f64) = (1024. / 2., 768. / 2.);
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
2023-02-12 03:24:54 +00:00
|
|
|
enum Terrain {
|
2023-02-06 14:36:02 +00:00
|
|
|
Empty,
|
|
|
|
Mountain,
|
|
|
|
Grasslands,
|
|
|
|
ShallowWater,
|
|
|
|
DeepWater,
|
|
|
|
Badlands,
|
|
|
|
Desert,
|
|
|
|
Swamp,
|
|
|
|
}
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
impl Default for Terrain {
|
2023-02-06 14:36:02 +00:00
|
|
|
fn default() -> Self {
|
|
|
|
Self::Empty
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
impl From<&str> for Terrain {
|
2023-02-06 14:36:02 +00:00
|
|
|
fn from(s: &str) -> Self {
|
|
|
|
match s {
|
|
|
|
"m" => Self::Mountain,
|
|
|
|
"g" => Self::Grasslands,
|
|
|
|
"sw" => Self::ShallowWater,
|
|
|
|
"dw" => Self::DeepWater,
|
|
|
|
"b" => Self::Badlands,
|
|
|
|
"d" => Self::Desert,
|
|
|
|
"s" => Self::Swamp,
|
|
|
|
_ => Self::Empty,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
impl From<String> for Terrain {
|
2023-02-06 14:36:02 +00:00
|
|
|
fn from(s: String) -> Self {
|
|
|
|
Self::from(s.as_ref())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
struct Tile {
|
|
|
|
terrain: Terrain,
|
|
|
|
image: Pixbuf,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Tile {
|
|
|
|
fn new(source: &DynamicImage, terrain: Terrain) -> Tile {
|
|
|
|
let image = match terrain {
|
|
|
|
Terrain::DeepWater => pixbuf_from_image_tile(source.clone().crop(0, 0, 100, 88)),
|
|
|
|
Terrain::ShallowWater => pixbuf_from_image_tile(source.clone().crop(100, 0, 100, 88)),
|
|
|
|
Terrain::Grasslands => pixbuf_from_image_tile(source.clone().crop(200, 0, 100, 88)),
|
|
|
|
Terrain::Desert => pixbuf_from_image_tile(source.clone().crop(300, 0, 100, 88)),
|
|
|
|
Terrain::Mountain => pixbuf_from_image_tile(source.clone().crop(0, 88, 100, 88)),
|
|
|
|
Terrain::Badlands => pixbuf_from_image_tile(source.clone().crop(100, 88, 100, 88)),
|
|
|
|
Terrain::Swamp => pixbuf_from_image_tile(source.clone().crop(0, 176, 100, 88)),
|
|
|
|
Terrain::Empty => pixbuf_from_image_tile(source.clone().crop(300, 176, 100, 88)),
|
|
|
|
};
|
|
|
|
|
|
|
|
Tile { terrain, image }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn render_on_context(&self, context: &Context, translate_x: f64, translate_y: f64) {
|
|
|
|
context.save().unwrap();
|
|
|
|
context.append_path(&hexagon_path(context, translate_x, translate_y, 100., 88.));
|
|
|
|
context.clip();
|
|
|
|
context.set_source_pixbuf(&self.image, translate_x, translate_y);
|
|
|
|
context.paint().expect("paint should succeed");
|
|
|
|
context.restore().unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-06 14:36:02 +00:00
|
|
|
fn main() {
|
|
|
|
gio::resources_register_include!("com.luminescent-dreams.hex-grid.gresource")
|
|
|
|
.expect("Failed to register resources");
|
|
|
|
|
|
|
|
let app = Application::builder().application_id(APP_ID).build();
|
|
|
|
|
|
|
|
app.connect_activate(|app| {
|
|
|
|
let window = HexGridWindow::new(app);
|
|
|
|
window.present();
|
|
|
|
});
|
|
|
|
|
|
|
|
app.run();
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(CompositeTemplate, Default)]
|
|
|
|
#[template(resource = "/com/luminescent-dreams/hex-grid/main.glade")]
|
|
|
|
pub struct HexGridWindowPrivate {
|
|
|
|
#[template_child]
|
|
|
|
pub drawing_area: TemplateChild<DrawingArea>,
|
|
|
|
#[template_child]
|
|
|
|
pub hex_address: TemplateChild<Label>,
|
|
|
|
#[template_child]
|
|
|
|
pub canvas_address: TemplateChild<Label>,
|
|
|
|
|
|
|
|
current_coordinate: Rc<RefCell<Option<AxialAddr>>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[glib::object_subclass]
|
|
|
|
impl ObjectSubclass for HexGridWindowPrivate {
|
|
|
|
const NAME: &'static str = "HexGridWindow";
|
|
|
|
type Type = HexGridWindow;
|
|
|
|
type ParentType = gtk::ApplicationWindow;
|
|
|
|
|
|
|
|
fn class_init(c: &mut Self::Class) {
|
|
|
|
c.bind_template();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn instance_init(obj: &InitializingObject<Self>) {
|
|
|
|
obj.init_template();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ObjectImpl for HexGridWindowPrivate {
|
|
|
|
fn constructed(&self) {
|
|
|
|
self.parent_constructed();
|
|
|
|
|
|
|
|
let map_text_resource = resources_lookup_data(
|
|
|
|
"/com/luminescent-dreams/hex-grid/map.txt",
|
|
|
|
gio::ResourceLookupFlags::NONE,
|
|
|
|
)
|
|
|
|
.expect("map should be in the bundle")
|
|
|
|
.to_vec();
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
let hex_map = parse_data::<Terrain>(String::from_utf8(map_text_resource).unwrap().lines());
|
2023-02-06 14:36:02 +00:00
|
|
|
|
|
|
|
let terrain_data = resources_lookup_data(
|
|
|
|
"/com/luminescent-dreams/hex-grid/terrain.ppm",
|
|
|
|
gio::ResourceLookupFlags::NONE,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
let reader = ImageReader::new(Cursor::new(terrain_data))
|
|
|
|
.with_guessed_format()
|
|
|
|
.unwrap();
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
let image = reader.decode().unwrap();
|
|
|
|
let deep_water = Tile::new(&image, Terrain::DeepWater);
|
|
|
|
let shallow_water = Tile::new(&image, Terrain::ShallowWater);
|
|
|
|
let grasslands = Tile::new(&image, Terrain::Grasslands);
|
|
|
|
let desert = Tile::new(&image, Terrain::Desert);
|
|
|
|
let mountain = Tile::new(&image, Terrain::Mountain);
|
|
|
|
let badlands = Tile::new(&image, Terrain::Badlands);
|
|
|
|
let swamp = Tile::new(&image, Terrain::Swamp);
|
2023-02-06 14:36:02 +00:00
|
|
|
|
|
|
|
let motion_controller = gtk::EventControllerMotion::new();
|
|
|
|
{
|
|
|
|
let canvas_address = self.canvas_address.clone();
|
|
|
|
let hex_address = self.hex_address.clone();
|
|
|
|
let c = self.current_coordinate.clone();
|
|
|
|
motion_controller.connect_motion(move |_, x, y| {
|
|
|
|
let norm_x = x - DRAWING_ORIGIN.0;
|
|
|
|
let norm_y = y - DRAWING_ORIGIN.1;
|
|
|
|
let q = (2. / 3. * norm_x) / HEX_RADIUS;
|
|
|
|
let r = (-1. / 3. * norm_x + (3. as f64).sqrt() / 3. * norm_y) / HEX_RADIUS;
|
|
|
|
|
|
|
|
let (q, r) = axial_round(q, r);
|
|
|
|
let coordinate = AxialAddr::new(q, r);
|
|
|
|
canvas_address.set_label(&format!("{:.0} {:.0}", x, y));
|
|
|
|
|
|
|
|
if coordinate.distance(&AxialAddr::origin()) > MAP_RADIUS {
|
|
|
|
hex_address.set_label(&format!("-----"));
|
|
|
|
*c.borrow_mut() = None;
|
|
|
|
} else {
|
|
|
|
hex_address.set_label(&format!("{:.0} {:.0}", coordinate.q(), coordinate.r()));
|
|
|
|
*c.borrow_mut() = Some(coordinate);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
self.drawing_area.set_draw_func(move |_, context, _, _| {
|
|
|
|
context.set_source_rgb(0., 0., 0.);
|
|
|
|
let _ = context.paint();
|
|
|
|
|
|
|
|
context.set_line_width(2.);
|
|
|
|
|
|
|
|
/*
|
2023-02-12 03:24:54 +00:00
|
|
|
deep_water.render_on_context(&context, 0., 0.);
|
|
|
|
shallow_water.render_on_context(&context, 150., 0.);
|
|
|
|
grasslands.render_on_context(&context, 300., 0.);
|
|
|
|
desert.render_on_context(&context, 450., 0.);
|
|
|
|
mountain.render_on_context(&context, 0., 100.);
|
|
|
|
badlands.render_on_context(&context, 150., 100.);
|
|
|
|
swamp.render_on_context(&context, 0., 200.);
|
|
|
|
*/
|
|
|
|
|
2023-02-06 14:36:02 +00:00
|
|
|
for coordinate in vec![AxialAddr::origin()]
|
|
|
|
.into_iter()
|
|
|
|
.chain(AxialAddr::origin().addresses(MAP_RADIUS))
|
|
|
|
{
|
|
|
|
let center_x =
|
|
|
|
DRAWING_ORIGIN.0 + HEX_RADIUS * (3. / 2. * (coordinate.q() as f64));
|
|
|
|
let center_y = DRAWING_ORIGIN.1
|
|
|
|
+ HEX_RADIUS
|
|
|
|
* ((3. as f64).sqrt() / 2. * (coordinate.q() as f64)
|
|
|
|
+ (3. as f64).sqrt() * (coordinate.r() as f64));
|
2023-02-12 03:24:54 +00:00
|
|
|
let translate_x = center_x - HEX_RADIUS;
|
|
|
|
let translate_y = center_y - (3. as f64).sqrt() * HEX_RADIUS / 2.;
|
|
|
|
|
|
|
|
let tile = match hex_map.get(&coordinate).unwrap() {
|
|
|
|
Terrain::Mountain => &mountain,
|
|
|
|
Terrain::Grasslands => &grasslands,
|
|
|
|
Terrain::ShallowWater => &shallow_water,
|
|
|
|
Terrain::DeepWater => &deep_water,
|
|
|
|
Terrain::Badlands => &badlands,
|
|
|
|
Terrain::Desert => &desert,
|
|
|
|
Terrain::Swamp => &swamp,
|
|
|
|
_ => panic!("unhandled terrain type"),
|
|
|
|
};
|
|
|
|
tile.render_on_context(context, translate_x, translate_y);
|
|
|
|
// draw_hexagon(context, center_x, center_y, HEX_RADIUS);
|
2023-02-06 14:36:02 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
self.drawing_area.add_controller(&motion_controller);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl WidgetImpl for HexGridWindowPrivate {}
|
|
|
|
impl WindowImpl for HexGridWindowPrivate {}
|
|
|
|
impl ApplicationWindowImpl for HexGridWindowPrivate {}
|
|
|
|
|
|
|
|
glib::wrapper! {
|
|
|
|
pub struct HexGridWindow(ObjectSubclass<HexGridWindowPrivate>) @extends gtk::ApplicationWindow, gtk::Window, gtk::Widget,
|
|
|
|
@implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl HexGridWindow {
|
|
|
|
pub fn new(app: &Application) -> Self {
|
|
|
|
Object::builder().property("application", app).build()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn draw_hexagon(context: &Context, center_x: f64, center_y: f64, radius: f64) {
|
|
|
|
let ul_x = center_x - radius;
|
|
|
|
let ul_y = center_y - (3. as f64).sqrt() * radius / 2.;
|
|
|
|
let points: Vec<(f64, f64)> = hexagon(radius * 2., (3. as f64).sqrt() * radius);
|
|
|
|
context.new_path();
|
|
|
|
context.move_to(ul_x + points[0].0, ul_y + points[0].1);
|
|
|
|
context.line_to(ul_x + points[1].0, ul_y + points[1].1);
|
|
|
|
context.line_to(ul_x + points[2].0, ul_y + points[2].1);
|
|
|
|
context.line_to(ul_x + points[3].0, ul_y + points[3].1);
|
|
|
|
context.line_to(ul_x + points[4].0, ul_y + points[4].1);
|
|
|
|
context.line_to(ul_x + points[5].0, ul_y + points[5].1);
|
|
|
|
context.close_path();
|
|
|
|
}
|
|
|
|
|
2023-02-12 03:24:54 +00:00
|
|
|
fn hexagon_path(
|
|
|
|
context: &Context,
|
|
|
|
translate_x: f64,
|
|
|
|
translate_y: f64,
|
|
|
|
width: f64,
|
|
|
|
height: f64,
|
|
|
|
) -> Path {
|
2023-02-06 14:36:02 +00:00
|
|
|
context.new_path();
|
|
|
|
let points = hexagon(width, height);
|
2023-02-12 03:24:54 +00:00
|
|
|
context.move_to(translate_x + points[0].0, translate_y + points[0].1);
|
|
|
|
context.line_to(translate_x + points[1].0, translate_y + points[1].1);
|
|
|
|
context.line_to(translate_x + points[2].0, translate_y + points[2].1);
|
|
|
|
context.line_to(translate_x + points[3].0, translate_y + points[3].1);
|
|
|
|
context.line_to(translate_x + points[4].0, translate_y + points[4].1);
|
|
|
|
context.line_to(translate_x + points[5].0, translate_y + points[5].1);
|
2023-02-06 14:36:02 +00:00
|
|
|
context.copy_path().expect("to successfully copy a path")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn hexagon(width: f64, height: f64) -> Vec<(f64, f64)> {
|
|
|
|
let center_x = width / 2.;
|
|
|
|
let center_y = height / 2.;
|
|
|
|
let radius = width / 2.;
|
|
|
|
|
|
|
|
vec![
|
|
|
|
(center_x + radius, center_y),
|
|
|
|
(
|
|
|
|
center_x + radius / 2.,
|
|
|
|
center_y + (3. as f64).sqrt() * radius / 2.,
|
|
|
|
),
|
|
|
|
(
|
|
|
|
center_x - radius / 2.,
|
|
|
|
center_y + (3. as f64).sqrt() * radius / 2.,
|
|
|
|
),
|
|
|
|
(center_x - radius, center_y),
|
|
|
|
(
|
|
|
|
center_x - radius / 2.,
|
|
|
|
center_y - (3. as f64).sqrt() * radius / 2.,
|
|
|
|
),
|
|
|
|
(
|
|
|
|
center_x + radius / 2.,
|
|
|
|
center_y - (3. as f64).sqrt() * radius / 2.,
|
|
|
|
),
|
|
|
|
]
|
|
|
|
}
|
|
|
|
|
|
|
|
fn axial_round(q_f64: f64, r_f64: f64) -> (i32, i32) {
|
|
|
|
let s_f64 = -q_f64 - r_f64;
|
|
|
|
let mut q = q_f64.round();
|
|
|
|
let mut r = r_f64.round();
|
|
|
|
let s = s_f64.round();
|
|
|
|
|
|
|
|
let q_diff = (q - q_f64).abs();
|
|
|
|
let r_diff = (r - r_f64).abs();
|
|
|
|
let s_diff = (s - s_f64).abs();
|
|
|
|
|
|
|
|
if q_diff > r_diff && q_diff > s_diff {
|
|
|
|
q = -r - s;
|
|
|
|
} else if r_diff > s_diff {
|
|
|
|
r = -q - s;
|
|
|
|
}
|
|
|
|
unsafe { (q.to_int_unchecked::<i32>(), r.to_int_unchecked::<i32>()) }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pixbuf_from_image_tile(image: image::DynamicImage) -> Pixbuf {
|
|
|
|
Pixbuf::from_bytes(
|
|
|
|
&glib::Bytes::from(image.as_bytes()),
|
|
|
|
gtk::gdk_pixbuf::Colorspace::Rgb,
|
|
|
|
false,
|
|
|
|
8,
|
|
|
|
image.width() as i32,
|
|
|
|
image.height() as i32,
|
|
|
|
image.to_rgb8().sample_layout().height_stride as i32,
|
|
|
|
)
|
|
|
|
}
|