Struct Tile 

pub struct Tile {
    pub colour: HexColour,
    pub name: String,
    /* private fields */
}

A tile contains some number of track segments and cities.

Fields

colour: HexColour

name: String

Implementations

impl Tile

pub fn new<S: Into<String>>( colour: HexColour, name: S, tracks: Vec<Track>, cities: Vec<City>, hex: &Hex, ) -> Self

Creates a new tile and determines the connectivity between track segments, revenue centres, and hex faces.

Note that hex should be the default hexagon, to ensure that track connectivity is valid and consistent. By making this an argument, a single Hex can be used to construct all required tiles, rather than creating a new Hex for each tile.

Examples found in repository

examples/custom_tile.rs (lines 22-28)

fn draw_custom_tile(output_dir: &str) {
    let output_file = "n18tile_custom_tile_1.png";
    let output_path = std::path::Path::new(output_dir).join(output_file);
    let hex = Hex::default();
    let tile = Tile::new(
        Red,
        "Custom1",
        vec![Track::straight(UpperRight), Track::gentle_l(LowerLeft)],
        vec![],
        &hex,
    )
    .with_offboard_faces([UpperRight, LowerRight])
    .label(Label::MapLocation("Custom".to_string()), Top.to_centre(0.1))
    .label(
        Label::PhaseRevenueVert(vec![
            (Yellow, 10, false),
            (Green, 20, true),
            (Brown, 30, false),
            (Grey, 40, false),
        ]),
        HexPosition::Centre(Some(Delta::InDir(Direction::W, 0.35))),
    )
    .hide_tile_name();
    println!("Writing {} ...", output_path.display());
    tile.save_png(&hex, output_path).unwrap();
}

pub fn with_offboard_faces<T>(self, faces: T) -> Self

where T: IntoIterator<Item = HexFace>,

Identifies the tile as an off-board tile that has faces adjacent to on-board tiles.

Examples found in repository

examples/custom_tile.rs (line 29)

fn draw_custom_tile(output_dir: &str) {
    let output_file = "n18tile_custom_tile_1.png";
    let output_path = std::path::Path::new(output_dir).join(output_file);
    let hex = Hex::default();
    let tile = Tile::new(
        Red,
        "Custom1",
        vec![Track::straight(UpperRight), Track::gentle_l(LowerLeft)],
        vec![],
        &hex,
    )
    .with_offboard_faces([UpperRight, LowerRight])
    .label(Label::MapLocation("Custom".to_string()), Top.to_centre(0.1))
    .label(
        Label::PhaseRevenueVert(vec![
            (Yellow, 10, false),
            (Green, 20, true),
            (Brown, 30, false),
            (Grey, 40, false),
        ]),
        HexPosition::Centre(Some(Delta::InDir(Direction::W, 0.35))),
    )
    .hide_tile_name();
    println!("Writing {} ...", output_path.display());
    tile.save_png(&hex, output_path).unwrap();
}

pub fn offboard_faces(&self) -> Option<Vec<HexFace>>

Returns the edges adjacent to on-board tiles, if this tile is an off-board tile, otherwise returns None.

pub fn hide_tile_name(self) -> Self

Do not display the tile name when drawing the tile.

Examples found in repository

examples/custom_tile.rs (line 40)

fn draw_custom_tile(output_dir: &str) {
    let output_file = "n18tile_custom_tile_1.png";
    let output_path = std::path::Path::new(output_dir).join(output_file);
    let hex = Hex::default();
    let tile = Tile::new(
        Red,
        "Custom1",
        vec![Track::straight(UpperRight), Track::gentle_l(LowerLeft)],
        vec![],
        &hex,
    )
    .with_offboard_faces([UpperRight, LowerRight])
    .label(Label::MapLocation("Custom".to_string()), Top.to_centre(0.1))
    .label(
        Label::PhaseRevenueVert(vec![
            (Yellow, 10, false),
            (Green, 20, true),
            (Brown, 30, false),
            (Grey, 40, false),
        ]),
        HexPosition::Centre(Some(Delta::InDir(Direction::W, 0.35))),
    )
    .hide_tile_name();
    println!("Writing {} ...", output_path.display());
    tile.save_png(&hex, output_path).unwrap();
}

pub fn is_tile_name_visible(&self) -> bool

Returns whether the tile name is displayed when drawing the tile.

pub fn connections(&self, from: &Connection) -> Option<&[Connection]>

pub fn all_connections_from<T>(&self, start: T) -> BTreeSet<Connection>

where T: Into<Connection>,

Returns all connections that can be reached from start.

pub fn connected_faces<T>(&self, start: T) -> BTreeSet<HexFace>

where T: Into<Connection>,

Returns the hexagon faces that are connected to start.

pub fn connected_dits<T>(&self, start: T) -> BTreeSet<usize>

where T: Into<Connection>,

Returns the index of each dit that is connected to start.

pub fn connected_cities<T>(&self, start: T) -> BTreeSet<usize>

where T: Into<Connection>,

Returns the index of each city that is connected to start.

pub fn connected_faces_are<T>(&self, start: T, dests: &[HexFace]) -> bool

where T: Into<Connection>,

Returns true if start is connected to each hexagon face in dests, and is not connected to any hexagon face not included in dests.

pub fn no_connected_faces<T>(&self, start: T) -> bool

where T: Into<Connection>,

Returns true if start is not connected to any other hexagon face.

pub fn connected_dits_are<T>( &self, start: T, dits: &[usize], ) -> Option<Vec<usize>>

where T: Into<Connection>,

Returns the index of each dit connected to start, if start is only connected to each dit in dits (identified by their revenue). Otherwise, returns None.

pub fn connected_cities_are<T>( &self, start: T, cities: &[(usize, usize)], ) -> Option<Vec<usize>>

where T: Into<Connection>,

Returns the index of each city connected to start, if start is only connected to each city in cities (identified by their revenue and number of token spaces, respectively). Otherwise, returns None.

pub fn label<P>(self, label: Label, pos: P) -> Self

where P: Into<HexPosition>,

Examples found in repository

examples/custom_tile.rs (line 30)

fn draw_custom_tile(output_dir: &str) {
    let output_file = "n18tile_custom_tile_1.png";
    let output_path = std::path::Path::new(output_dir).join(output_file);
    let hex = Hex::default();
    let tile = Tile::new(
        Red,
        "Custom1",
        vec![Track::straight(UpperRight), Track::gentle_l(LowerLeft)],
        vec![],
        &hex,
    )
    .with_offboard_faces([UpperRight, LowerRight])
    .label(Label::MapLocation("Custom".to_string()), Top.to_centre(0.1))
    .label(
        Label::PhaseRevenueVert(vec![
            (Yellow, 10, false),
            (Green, 20, true),
            (Brown, 30, false),
            (Grey, 40, false),
        ]),
        HexPosition::Centre(Some(Delta::InDir(Direction::W, 0.35))),
    )
    .hide_tile_name();
    println!("Writing {} ...", output_path.display());
    tile.save_png(&hex, output_path).unwrap();
}

pub fn tracks(&self) -> &[Track]

pub fn dits(&self) -> &[Dit]

pub fn cities(&self) -> &[City]

pub fn labels(&self) -> &[LabelAndPos]

pub fn city(&self, space: &TokenSpace) -> Option<&City>

Returns the city that corresponds to the provided token location.

pub fn revenues(&self) -> &[usize]

pub fn only_draw_offboard_track(&self) -> bool

Returns true if this tile is an off-board tile for which special off-board track segments should be drawn, instead of drawing the regular track segments, dits, and cities.

pub fn define_offboard_track_inner_path( &self, ctx: &Context, hex: &Hex, face: &HexFace, ) -> bool

Defines the inner (foreground) layer of the off-board track segment for the specified tile face, if such a segment should be drawn on this face, and returns true.

If no such segment should be drawn, this has no effect and returns false.

pub fn draw_offboard_segment( &self, ctx: &Context, hex: &Hex, face: &HexFace, ) -> bool

Draws the off-board track segment for the specified tile face, if such a segment should be drawn on this face, and returns true.

If no such segment should be drawn, this has no effect and returns false.

pub fn draw(&self, ctx: &Context, hex: &Hex)

pub fn token_spaces(&self) -> Vec<TokenSpace>

pub fn city_token_spaces(&self, city_ix: usize) -> Vec<TokenSpace>

pub fn token_space_count(&self) -> usize

pub fn dit_count(&self) -> usize

pub fn define_token_space( &self, space: &TokenSpace, hex: &Hex, ctx: &Context, ) -> bool

pub fn can_upgrade_to(&self, other: &Tile) -> bool

Check whether a tile can be upgraded to another tile.

pub fn save_png<P: AsRef<Path>>( &self, hex: &Hex, path: P, ) -> Result<(), Box<dyn Error>>

Saves the tile to a PNG file.

Examples found in repository

examples/custom_tile.rs (line 42)

fn draw_custom_tile(output_dir: &str) {
    let output_file = "n18tile_custom_tile_1.png";
    let output_path = std::path::Path::new(output_dir).join(output_file);
    let hex = Hex::default();
    let tile = Tile::new(
        Red,
        "Custom1",
        vec![Track::straight(UpperRight), Track::gentle_l(LowerLeft)],
        vec![],
        &hex,
    )
    .with_offboard_faces([UpperRight, LowerRight])
    .label(Label::MapLocation("Custom".to_string()), Top.to_centre(0.1))
    .label(
        Label::PhaseRevenueVert(vec![
            (Yellow, 10, false),
            (Green, 20, true),
            (Brown, 30, false),
            (Grey, 40, false),
        ]),
        HexPosition::Centre(Some(Delta::InDir(Direction::W, 0.35))),
    )
    .hide_tile_name();
    println!("Writing {} ...", output_path.display());
    tile.save_png(&hex, output_path).unwrap();
}

pub fn save_svg<P: AsRef<Path>>( &self, hex: &Hex, path: P, ) -> Result<(), Box<dyn Error>>

Saves the tile to an SVG file.

pub fn save_pdf<P: AsRef<Path>>( &self, hex: &Hex, path: P, ) -> Result<(), Box<dyn Error>>

Saves the tile to a PDF file.

pub fn write_png<W: Write>( &self, hex: &Hex, stream: &mut W, ) -> Result<(), Box<dyn Error>>

Writes the tile as a PNG image to the provided stream.

pub fn write_svg<W: Write + 'static>( &self, hex: &Hex, stream: W, ) -> Result<(), Box<dyn Error>>

Writes the tile as an SVG image to the provided stream.

pub fn write_pdf<W: Write + 'static>( &self, hex: &Hex, stream: W, ) -> Result<(), Box<dyn Error>>

Writes the tile as a PDF image to the provided stream.

Trait Implementations

impl Clone for Tile

fn clone(&self) -> Tile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Tile

fn eq(&self, other: &Tile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Tile