from typing import Callable
from pytamaro import Graphic, Color, transparent, graphic_width
from pytamaro import rectangle, empty_graphic
from pytamaro import beside, above, pin, compose, overlay
from pytamaro import top_center


# error messages
from error_messages import arguments_error_message, CastleType

# helper functions
from color_functions import set_value, get_value

# measurements
from measurements import support_height_cm, support_count, support_width_cm, wall_side_cm, battlement_height_cm
from measurements import merlon_count, merlon_height_cm, merlon_width_cm

### helper functions

def beside_list_gap(l: list[Graphic], gap_width: float) -> Graphic:
    """gaps are placed between graphics, not before nor after"""
    gap = rectangle(gap_width, 0, transparent)
    result = empty_graphic()
    for i in range(len(l) * 2):
        result = beside(
            result, l[i // 2] if i % 2 == 0 else gap if i != len(l) * 2 - 1 else empty_graphic()
        )
    return result


### supports

def support_piece(width: float, height: float, color: Color) -> Graphic:
    dark_color = set_value(color, get_value(color) * 0.85)
    small_height = height * 0.15
    return above(
        rectangle(width, height - small_height, color),
        rectangle(width, small_height, dark_color)
    )


def support(width: float, height: float, lighter_color: Color) -> Graphic:
    piece_count = 3
    result = empty_graphic()
    for i in range(piece_count):
        new_color = set_value(lighter_color, get_value(
            lighter_color) / (1.1 + i * 0.3))
        result = above(
            result,
            support_piece(
                width, height / piece_count,
                new_color)
        )
    return result


def supports(pix_per_cm: float, lighter_color: Color) -> Graphic:
    support_width = support_width_cm * pix_per_cm
    support_height = support_height_cm * pix_per_cm
    gap_width = 2 * support_width
    shade_color = set_value(lighter_color, get_value(lighter_color) * 0.75)
    supports = [support(support_width, support_height,
                        lighter_color)] * support_count
    return compose(
        pin(top_center, beside_list_gap(supports, gap_width)),
        pin(top_center, rectangle(wall_side_cm *
            pix_per_cm, support_height / 3, shade_color))
    )


# the battlement

def battlement(color: Color, merlon_function: Callable[[float, Color], Graphic]) -> Graphic:
    # ensure that the first parameter is a color
    assert isinstance(color, Color), arguments_error_message(battlement, 0, CastleType.COLOR)
    # ensure that the second parameter is a merlon
    assert isinstance(merlon_function, Callable), arguments_error_message(battlement, 1, CastleType.MERLON)

    pix_per_cm = 1
    # measurements
    height = battlement_height_cm * pix_per_cm
    width = wall_side_cm * pix_per_cm
    merlon_height = merlon_height_cm * pix_per_cm
    merlon_width = merlon_width_cm * pix_per_cm
    # components
    merlon = merlon_function(pix_per_cm, color)
    #  return empty_graphic if merlon function is no_merlon
    if graphic_width(merlon) == 0:
        return empty_graphic()
    merlons = [merlon] * merlon_count
    bottom_wall = rectangle(width, height - merlon_height, color)
    bottom_wall = overlay(supports(pix_per_cm, color), bottom_wall)
    return above(
        beside_list_gap(merlons, merlon_width),
        bottom_wall
    )



battlement.py


# wall border states

con_bordi = True
senza_bordi = False

bordi_muro.py

from pytamaro import Graphic, Color, Point
from pytamaro import rectangle, empty_graphic
from pytamaro import pin, compose, graphic_height
from pytamaro import bottom_left, bottom_right, top_left, top_right, center_left, center_right

# helper functions
from color_functions import get_value, set_value


### helper functions

def compose_list_point(point: Point, list: list[Graphic]) -> Graphic:
    """ composes given list pinned in given point, first element goes on background """
    result = empty_graphic()
    for element in list:
        result = compose(
            pin(point, element),
            pin(point, result)
        )
    return result


### the brick border

# returns a brick with a shadow underneath and on the side,
# depending if it goes on the left or right border of the wall
def brick(width: float, height: float, color: Color, left: bool) -> Graphic:
    dark_color = set_value(color, get_value(color) * 0.7)
    outline_thickness = height / 7
    result = compose_list_point(
        top_left if left else top_right, [
            rectangle(width, height, dark_color),
            rectangle(width - outline_thickness,
                      height - outline_thickness, color)
        ])
    return result


# creates a border of the given height, with bricks of the given height,
# which goes on the left if `left` is True, otherwise it is mirrored to go on the right
def brick_border(height: float, brick_height: float, color: Color, left: bool) -> Graphic:
    # constants
    brick_count = int(height // brick_height)
    wide_brick_width = brick_height * 1.8
    narrow_brick_width = wide_brick_width * 0.7
    # components
    wide_brick = brick(wide_brick_width, brick_height, color, left)
    narrow_brick = brick(narrow_brick_width, brick_height, color, left)
    result = empty_graphic()
    for i in range(brick_count):
        result = compose(
            pin(bottom_left if left else bottom_right, result),
            pin(top_left if left else top_right, narrow_brick if i %
                2 == 0 else wide_brick)
        )
    return compose(
        pin(center_left if left else center_right, result),
        pin(center_left if left else center_right,
            rectangle(narrow_brick_width, height, color))
    )


# adds brick borders on the sides of the given graphics, as specified by boolean parameters
# `left_border` and `right_border`
def add_brick_borders(graphic: Graphic, brick_height: float, color: Color, left_border: bool, right_border: bool) -> Graphic:
    result = graphic
    if left_border:
        result = compose_list_point(
            center_left, [
                result,
                brick_border(graphic_height(graphic), brick_height, color, True)]
        )
    if right_border:
        result = compose_list_point(
            center_right, [
                result,
                brick_border(graphic_height(graphic), brick_height, color, False)]
        )
    return result

brick_border.py

from roof import roof as dach
from battlement import battlement as brustwehr
from wall import wall as mauer
from drawbridge import drawbridge as zugbruecke

burg_komponenten.py

from roof import roof as tetto
from battlement import battlement as merlatura
from wall import wall as muro
from drawbridge import drawbridge as ponte_levatoio

castello.py

from roof import roof
from battlement import battlement
from wall import wall
from drawbridge import drawbridge

castle_components.py

from pytamaro import Color, hsv_color

# RGB to HSV

def min_max_rgb(color: Color) -> tuple[float, float]:
    components = [color.red / 255, color.green / 255, color.blue / 255]
    return min(components), max(components)

def to_hsv(color: Color) -> tuple[float, float, float]:
    min_value, max_value = min_max_rgb(color)
    if min_value == max_value:
        return 0, 0, max_value
    else:
        s = (max_value - min_value) / max_value
        r = color.red / 255
        g = color.green / 255
        b = color.blue / 255
        if max_value == r:
            h = 60 * ((g - b) / (max_value - min_value))
        elif max_value == g:
            h = 60 * (2 + (b - r) / (max_value - min_value))
        else:
            h = 60 * (4 + (r - g) / (max_value - min_value))
        if h < 0:
            h += 360
        return h, s, max_value

def get_hue(color: Color) -> float:
    return to_hsv(color)[0]

def get_saturation(color: Color) -> float:
    return to_hsv(color)[1]

def get_value(color: Color) -> float:
    return to_hsv(color)[2]

def get_opacity(color: Color) -> float:
    return color.alpha


# Manipulation on HSV

def set_value(color: Color, value: float) -> Color:
    h, s, v = to_hsv(color)
    v = value
    # Cap value in range [0-1]
    if v < 0:
        v = 0
    elif v > 1:
        v = 1
    return hsv_color(h, s, v, get_opacity(color))


def set_hue(color: Color, hue: int) -> Color:
    h, s, v = to_hsv(color)
    h = hue
    # Cap hue in range [0-359]
    if h < 0:
        h = 0
    elif h > 359:
        h = 359
    return hsv_color(h, s, v, get_opacity(color))


def set_saturation(color: Color, saturation: int) -> Color:
    h, s, v = to_hsv(color)
    s = saturation
    # Cap saturation in range [0-1]
    if s < 0:
        s = 0
    elif s > 1:
        s = 1
    return hsv_color(h, s, v, get_opacity(color))


### generate property colors based on wall color

def light_leaf_color(wall_color: Color) -> Color:
    h = 130
    s = 0.6
    v = 0.5
    if get_saturation(wall_color) == 0 and get_value(wall_color) < 0.3:
        # if wall is black make it darker
        v = 0.35
    return hsv_color(h, s, v)


def dark_leaf_color(wall_color: Color) -> Color:
    light_color = light_leaf_color(wall_color)
    return set_value(light_color, get_value(light_color) * 0.75)


# inside of windows, open doors, ...
def hole_color(wall_color: Color) -> Color:
    if get_saturation(wall_color) == 0 and get_value(wall_color) < 0.3:
        # if wall is black make it darker
        return hsv_color(0, 0, 0.07)
    return hsv_color(0, 0, 0.1)


def light_wood_color(wall_color: Color) -> Color:
    h = 30
    s = 0.7
    v = 0.6
    if get_saturation(wall_color) == 0 and get_value(wall_color) < 0.3:
        # if wall is black make it darker
        v = 0.5
    return hsv_color(h, s, v)

def dark_wood_color(wall_color: Color) -> Color:
    light_color = light_wood_color(wall_color)
    return set_value(light_color, get_value(light_color) * 0.7)
    

color_functions.py

from colors import red as rosso
from colors import yellow as giallo
from colors import green as verde
from colors import cyan as ciano
from colors import blue as blu
from colors import purple as viola
from colors import pink as rosa
from colors import grey as grigio
from colors import black as nero
from colors import brown as marrone

colori.py

from pytamaro import hsv_color

# colors

saturation = 0.7
red = hsv_color(0, saturation, 1)
yellow = hsv_color(60, saturation, 1)
green = hsv_color(135, saturation, 1)
cyan = hsv_color(180, saturation, 1)
blue = hsv_color(225, saturation, 1)
purple = hsv_color(270, saturation, 1)
pink = hsv_color(315, saturation, 1)
grey = hsv_color(0, 0, 0.5)
black = hsv_color(0, 0, 0.15)
brown = hsv_color(25, 0.7, 0.5)

colors.py

from composition import above_list as sopra_lista
from composition import beside_list as accanto_lista

comporre.py

from pytamaro import (
    Graphic,
    empty_graphic,
    above, compose, pin, overlay,
    bottom_left, bottom_right
)

# error messages
from error_messages import arguments_error_message, CastleType


def above_list(l: list[Graphic]) -> Graphic:
    # ensure that the first parameter is list of castle pieces
    assert isinstance(l, list), arguments_error_message(above_list, 0, CastleType.LIST)

    result = empty_graphic()
    for g in l:
        result = above(result, g)
    return result


def beside_list(l: list[Graphic]) -> Graphic:
    """this actually composes by alligning on the bottom!"""
    # ensure that the first parameter is list of castle pieces
    assert isinstance(l, list), arguments_error_message(beside_list, 0, CastleType.LIST)

    result = empty_graphic()
    for g in l:
        result = compose(
            pin(bottom_right, result),
            pin(bottom_left, g)
        )
    return result


def overlay_list(l: list[Graphic]) -> Graphic:
    result = empty_graphic()
    for g in l:
        result = overlay(result, g)
    return result

composition.py


# drawbridge states

opened = True
closed = False

drawbridge_states.py

from pytamaro import Color, Graphic, hsv_color, black, graphic_height, graphic_width
from functools import reduce
from pytamaro import rectangle, circular_sector, empty_graphic, triangle
from pytamaro import pin, compose, overlay, above, rotate, beside, transparent
from pytamaro import top_right, bottom_left, top_left, bottom_center, top_center, center, bottom_right, center_left


# error messages
from error_messages import arguments_error_message, CastleType


from wall import wall
from wall_properties import ivy, nothing, bricks
from composition import above_list  
from color_functions import set_value, get_value
from color_functions import light_wood_color, dark_wood_color, hole_color
from colors import grey


ivy_wall = wall(grey, True, ivy)
normal_wall = wall(grey, False, nothing)
brick_wall = wall(grey, True, bricks)



# Helper Functions

def beside_list(l: list[Graphic]) -> Graphic:
    result = empty_graphic()
    for g in l:
        result = beside(result, g)
    return result


# THE CHAIN

def link_bar(width: float, height: float, line_thickness: float, color: Color, dark_color: Color) -> Graphic:
    assert width > 2 * line_thickness
    return overlay(
        rectangle(width - 2 * line_thickness, height, color),
        rectangle(width, height, dark_color)
    )


def round_bar(width: float, line_thickness: float, color: Color, dark_color, linked: bool) -> Graphic:
    radius = width / 2
    result = compose(
        pin(bottom_center, circular_sector(radius - line_thickness, 180, color)),
        pin(bottom_center, circular_sector(radius, 180, dark_color))
    )
    if not linked:
        return result
    else:
        side_link_width = width / 3
        side_link = link_bar(side_link_width, radius, line_thickness, color, dark_color)
        return overlay(side_link, result)


def link_center(width: float, height: float, line_thickness: float,
                color: Color, dark_color: Color, linked_up: bool, linked_down: bool) -> Graphic:
    bar_width = width / 3
    side = link_bar(bar_width, height, line_thickness, color, dark_color)
    link_end = round_bar(bar_width, line_thickness, color, dark_color, False)

    central_piece = rectangle(bar_width, height, transparent)
    if linked_up:
        central_piece = compose(
            pin(top_center, rotate(180, link_end)),
            pin(top_center, central_piece)
        )
    if linked_down:
        central_piece = compose(
            pin(bottom_center, link_end),
            pin(bottom_center, central_piece)
        )
    return beside_list([side, central_piece, side])


def link(width: float, height: float, line_thickness: float, color: Color, dark_color: Color, linked_up: bool, linked_down: bool) -> Graphic:
    assert height >= width
    return above(
        round_bar(width, line_thickness, color, dark_color, linked_up),
        above(
            link_center(width, height - width, line_thickness, color, dark_color, linked_up, linked_down),
            rotate(180, round_bar(width, line_thickness, color, dark_color, linked_down))
        )
    )


def chain(width: float, height: float, color: Color) -> Graphic:
    link_height = width / 2 * 3
    side_link_height = link_height - width
    link_count = int((height + side_link_height) // (link_height + side_link_height))

    actual_height = link_count * link_height + (link_count - 1) * side_link_height
    height_difference = height - actual_height
    height_increase = height_difference / (2 * link_count - 1)

    link_height += height_increase
    side_link_height += height_increase
    dark_color = set_value(color, get_value(color) * 0.25)
    line_thickness = width / 15
    # fill the extra space by spacing out front links by the needed amount
    side_link_height = (height - link_count * link_height) / (link_count - 1)
    side_link = link_bar(width / 3, side_link_height, line_thickness, color, dark_color)
    result = empty_graphic()
    for i in range(link_count):
        linked_up = i != 0
        linked_down = i != link_count - 1
        result = above(
            result,
            above(
                link(width, link_height, line_thickness, color, dark_color, linked_up, linked_down),
                side_link if linked_down else empty_graphic()
            )
        )
    return result


# THE ARCH



# CONSTANTS
dark_grey = set_value(grey, get_value(grey) * 0.8)
dark_dark_grey = set_value(dark_grey, get_value(dark_grey) * 0.8)

from measurements import wall_side_cm, pix_per_cm


def arch(color: Color) -> Graphic:
    # colors
    empty_color = hole_color(color)
    frame_color = set_value(color, get_value(color) * 0.8)

    width = pix_per_cm * wall_side_cm * 0.8
    height = pix_per_cm * wall_side_cm
    radius = width / 2
    frame_thickness = width / 7
    hole_width = width - 2 * frame_thickness
    hole_radius = radius - frame_thickness

    background = rectangle(height, height, color)

    top_hole = circular_sector(hole_radius, 180, empty_color)
    bottom_hole = rectangle(hole_width, height - radius, empty_color)
    hole = pin(bottom_center, above(top_hole, bottom_hole))
    frame = above(top_frame(radius, frame_color), bottom_frame(width, height - radius, frame_color))
    frame = pin(bottom_center, frame)
    background = pin(bottom_center, background)

    return compose(hole, compose(frame, background))


def bottom_frame(width: float, height: float, color: Color) -> Graphic:
    dark_color = set_value(color, get_value(color) * 0.6)
    brick_count = 4
    separator_height = height / 20
    brick_height = (height - brick_count * separator_height) / brick_count
    brick = above(
        rectangle(width, brick_height, color),
        rectangle(width, separator_height, dark_color)
    )
    result = empty_graphic()
    for _ in range(brick_count):
        result = above(result, brick)
    return result


def top_frame(radius: float, color: Color) -> Graphic:
    background = circular_sector(radius, 180, color)
    dark_color = set_value(color, get_value(color) * 0.6)
    brick_count = 6
    separator_angle = 5
    rotation_angle = (180 / brick_count)

    separator = circular_sector(radius, separator_angle, dark_color)
    result = background
    for i in range(brick_count):
            result = compose(rotate(i*rotation_angle, separator), result)
    return compose(
        rotate(180 - separator_angle, separator),
        result
    )


# THE DRAWBRIDGE

def compose_beside(graphics: list[Graphic], bottom_pin: bool = False) -> Graphic:
    result = empty_graphic()
    for graphic in graphics:
        result = pin(bottom_right if bottom_pin else top_right, result)
        result = compose(result, pin(bottom_left if bottom_pin else top_left, graphic))
    return pin(center, result)


def borderer(g: Graphic, color: Color, border_thickness: int, top_border: bool = True, right_border: bool = True, bottom_border: bool = True, left_border: bool = True) -> Graphic:
    """Returns a graphic with a border of the given color. The width and height remain the same"""

    if top_border:
        top_border = pin(
            top_left,
            rectangle(graphic_width(g), border_thickness, color)
        )
    if bottom_border:
        bottom_border = pin(
            bottom_left,
            rectangle(graphic_width(g), border_thickness, color)
        )
    if left_border:
        left_border = pin(
            top_left,
            rectangle(border_thickness, graphic_height(g), color)
        )
    if right_border:
        right_border = pin(
            top_right,
            rectangle(border_thickness, graphic_height(g), color)
        )
    
    result = g
    if top_border:
        result = compose(top_border, pin(top_left, result))
    if bottom_border:
        result = compose(bottom_border, pin(bottom_left, result))
    if left_border:
        result = compose(left_border, pin(top_left, result))
    if right_border:
        result = compose(right_border, pin(top_right, result))

    return result


def latch_body(width: float, height: float, color: Color) -> Graphic:
    return rectangle(width, height, color)


def latch_with_point(height: float, color: Color) -> Graphic:
    triangular_body_height = height * 2

    triangular_body = above(
        rotate(90, triangle(height / 2, triangular_body_height, 90, color)),
        rotate(180, triangle(triangular_body_height, height / 2, 90, color))
    )

    triangular_body = pin(center_left, triangular_body)

    heart_square = pin(top_right, rectangle(height, height, color))
    heart_ear = pin(bottom_right, circular_sector(height / 2, 180, color))
    heart = compose(
        heart_square,
        heart_ear
    )

    heart = compose(
        heart,
        pin(top_left, rotate(-90, heart_ear))
    )

    heart = rotate(-45, heart)

    body_with_heart = compose(
        pin(center, heart),
        triangular_body
    )

    return compose(
        circular_sector(height / 4, 360, black),
        body_with_heart
    )


def latch(width: float, height: float, color: Color) -> Graphic:
    return beside(
        latch_with_point(height, color),
        latch_body(width, height, color)
    )


# A bar is one of the branches constituting the rhombus shape in the final Graphic
def bar(bar_width: float, bar_height: float, color: Color) -> Graphic:
    triangle_bar = triangle(bar_height, bar_height, 90, color)
    rectangle_bar = rectangle(bar_width, bar_height, color)
    graphic = compose(pin(top_left, compose(pin(top_left, rotate(-90, triangle_bar)), pin(top_right, rectangle_bar))), pin(top_right, rotate(180, triangle_bar)))
    return graphic


def rhombus(width: float, height: float, color: Color):
    bar_element = bar(width, height / 4, color)
    rhombus_base = compose(
    rotate(90, pin(top_right, bar_element)),
    pin(top_left, bar_element)
    )
    rhombus_final = compose(
    pin(bottom_left, rhombus_base),
    pin(bottom_left, rotate(180, rhombus_base))
    )
    return rhombus_final


def cross(width: float, height: float, color: Color) -> Graphic:
    frame_width = width / 10.0
    shade_1 = above_list(
    [rectangle(width, frame_width * 1.2, hsv_color(1, 0.9, 0.16, 0.9)),
    rectangle(width, frame_width / 4.0, hsv_color(1, 0.9, 0.16,  0.7)),
    rectangle(width, frame_width / 5.0, hsv_color(1, 0.9, 0.16,  0.3))]
    )
    shade_2 = above_list(
    [rectangle(width, frame_width / 5.0, hsv_color(1, 0.9, 0.16, 0.9)),
    rectangle(width, frame_width / 5.0, hsv_color(1, 0.9, 0.16,  0.7)),
    rectangle(width, frame_width / 6.0, hsv_color(1, 0.9, 0.16,  0.3))]
    )

    cross_vertical = compose(
    pin(top_center, rectangle(width / 11.0, height, color)),
    pin(top_center, shade_1)
    )
    cross_horizontal = above(
    rectangle(width, width / 11.0, color),
    shade_2
    )
    cross = overlay(cross_vertical, cross_horizontal)
    return cross


def plank(bridge_width: float, bridge_height: float, color: Color, number_of_planks: int) -> Graphic:
    plank_height = bridge_height / number_of_planks
    plank_width = bridge_width
    plank_width_outline = plank_width - (plank_height / 15.0)
    plank_height_outline = plank_height - (plank_height / 15.0)
    plank = overlay(rectangle(plank_width_outline, plank_height_outline, color), rectangle(plank_width, plank_height, black))
    return plank


def closed_drawbridge(width: float, height: float, color_background: Color, color_foreground: Color, number_of_planks: float) -> Graphic:
    metal_color = hsv_color(27, 0.48, 0.3)
    
    frame_width = width / 10.0
    plank_element = plank(width, height, color_background, number_of_planks)
    background_bridge = reduce(above, [plank_element] * number_of_planks, empty_graphic())
    with_cross = overlay(cross(width, height, color_foreground), background_bridge)
    latch_element = latch(width / 30.0, width / 30.0, metal_color)
    bridge_base = overlay(rotate(45, rhombus(width / 4, height / 4, color_foreground)), with_cross)
    bridge_framed = borderer(bridge_base, color_foreground, frame_width)
    bridge_final = compose(
    pin(top_center, rotate(90, latch_element)),
    pin(top_center, compose(pin(bottom_center, rotate(-90, latch_element)), pin(bottom_center, bridge_framed)))
    )
    return bridge_final


def drawbridge(open: bool) -> Graphic:
    # ensure that the first parameter is a drawbridge state
    assert isinstance(open, bool), arguments_error_message(drawbridge, 0, CastleType.DRAWBRIDGE_STATE)

    light_color = light_wood_color(grey)
    dark_color = dark_wood_color(grey)
    plank_count = 8
    
    height = pix_per_cm * wall_side_cm * 0.9
    width = height * 0.8

    bridge_thickness = height / 15
    arch_bridge = arch(grey)
    if not open:
        d = compose(
            pin(bottom_center, closed_drawbridge(width, height, dark_color, light_color, plank_count)),
            pin(bottom_center, arch_bridge)
        ) 
    else:
        chain_width = width / 15
        beam = rectangle(chain_width * 1.5, chain_width * 1.7, light_color)
        my_chain = compose(
            pin(top_center, beam),
            pin(top_center, chain(chain_width, height - bridge_thickness, hsv_color(0, 0, 0.3)))
            )
        
        open_bridge_from_front = rectangle(width, bridge_thickness, light_color)
        intermediate = compose(
            pin(top_right, my_chain),
            pin(top_right, compose(
                pin(bottom_left, my_chain),
                pin(top_left, open_bridge_from_front)
            ))
        )
        d = compose(
            pin(bottom_center, intermediate),
            pin(bottom_center, arch_bridge)
        )

    return d
        



drawbridge.py

# to get the function name dinamically
from enum import Enum


# this file contains functions that generate custom error messages to use in assertions


#  defining possible types for parameters
class CastleType(Enum):
    COLOR = 0
    MERLON = 1
    LIST = 2
    DRAWBRIDGE_STATE = 3
    WALL_BORDER = 4
    WALL_PROPERTY = 5

class Language(Enum):
    ENGLISH = 0
    ITALIAN = 1
    GERMAN = 2


##### mapping types to names in any language

def get_name(castle_type: CastleType, language: Language) -> str:
    if language == Language.GERMAN:
        # to translate in german
        names = {
            CastleType.COLOR: "color",
            CastleType.MERLON: "merlon",
            CastleType.LIST : "list of castle pieces",
            CastleType.DRAWBRIDGE_STATE: "drawbridge state",
            CastleType.WALL_BORDER: "wall border",
            CastleType.WALL_PROPERTY: "wall property"
        }
    elif language == Language.ITALIAN:
        names = {
            CastleType.COLOR: "colore",
            CastleType.MERLON: "merlo",
            CastleType.LIST : "lista di pezzi di castello",
            CastleType.DRAWBRIDGE_STATE: "stato del ponte levatoio",
            CastleType.WALL_BORDER: "bordo per muro",
            CastleType.WALL_PROPERTY: "proprietà muro"
        }
    else:
        names = {
            CastleType.COLOR: "color",
            CastleType.MERLON: "merlon",
            CastleType.LIST : "list of castle pieces",
            CastleType.DRAWBRIDGE_STATE: "drawbridge state",
            CastleType.WALL_BORDER: "wall border",
            CastleType.WALL_PROPERTY: "wall property"
        }
    return names[castle_type]



###### mapping types to examples in any language

def get_examples(castle_type: CastleType, language: Language) -> str:
    if language == Language.GERMAN:
        # to translate in german
        examples = {
            CastleType.COLOR: "grey, red, blue, ...",
            CastleType.MERLON: "split_merlon, rounded_merlon, rectangular_merlon",
            CastleType.LIST: "[element_1, element_2, element_3]",
            CastleType.DRAWBRIDGE_STATE: "opened, closed",
            CastleType.WALL_BORDER: "borders, no_borders",
            CastleType.WALL_PROPERTY: "ivy, window, door, nothing, ..."
        }
    elif language == Language.ITALIAN:
        examples = {
            CastleType.COLOR: "grigio, rosso, blu, ...",
            CastleType.MERLON: "merlo_diviso, merlo_arrotondato, merlo_rettangolare",
            CastleType.LIST: "[elemento_1, elemento_2, elemento_3]",
            CastleType.DRAWBRIDGE_STATE: "aperto, chiuso",
            CastleType.WALL_BORDER: "con_bordi, senza_bordi",
            CastleType.WALL_PROPERTY: "edera, finestra, porta, niente, ..."
        }
    else:
        # english version
        examples = {
            CastleType.COLOR: "grey, red, blue, ...",
            CastleType.MERLON: "split_merlon, rounded_merlon, rectangular_merlon",
            CastleType.LIST: "[element_1, element_2, element_3]",
            CastleType.DRAWBRIDGE_STATE: "opened, closed",
            CastleType.WALL_BORDER: "borders, no_borders",
            CastleType.WALL_PROPERTY: "ivy, window, door, nothing, ..."
        }
    return examples[castle_type]


##### cardinal numbers in any language (up to six)

def get_cardinal_number(num: int, language: Language) -> str:
    if language == Language.GERMAN:
        cardinal_numbers = ["first", "second", "third", "fourth", "fifth", "sixth"]
    elif language == Language.ITALIAN:
        cardinal_numbers = ["primo", "secondo", "terzo", "quarto", "quinto", "sesto"]
    else:
        cardinal_numbers = ["first", "second", "third", "fourth", "fifth", "sixth"]
    return cardinal_numbers[num]



# generates an error message stating that function `func` expects 
# a type `castle_type` as parameter `parameter_position`
# `argument_position` is an integer number and should be 0 for the first parameter
# `castle_type` is one of CastleType (CastleType.COLOR, ...)
# `language` should be one of Languages
def arguments_error_message(func, argument_position: int, castle_type: CastleType) -> str:
    # always in english for now
    func_name = func.__name__
    error_msg = "Invalid arguments in " + func_name + ": \n"

    error_msg += "The " + get_cardinal_number(argument_position, Language.ENGLISH) + " argument should be a " + get_name(castle_type, Language.ENGLISH) + ".\n"
    error_msg +=  "Valid examples: " + get_examples(castle_type, Language.ENGLISH)
    return error_msg


error_messages.py

from colors import red as rot
from colors import yellow as gelb
from colors import green as gruen
from colors import cyan
from colors import blue as blau
from colors import purple as lila
from colors import pink as rosarot
from colors import grey as grau
from colors import black as schwarz
from colors import brown as braun

farben.py

from composition import above_list as ueber_liste
from composition import beside_list as neben_liste

komposition.py

from wall_properties import bricks as ziegel
from wall_properties import ivy as efeu
from wall_properties import crack as riss
from wall_properties import nothing as nichts
from wall_properties import door as tuer
from wall_properties import double_door as tor
from wall_properties import window as fenster
from wall_properties import arched_window as rundbogen_fenster

# old version - kept in order to avoid errors if someone has an older version
from wall_properties import arched_window as rundes_fenster

mauer_eigenschaften.py


# wall border states

mit_raendern = True
ohne_raender = False

mauer_seiten.py

# wall
wall_side_cm = 200
pix_per_cm = 1

# doors
door_height_cm = wall_side_cm * 0.8
door_width_cm = wall_side_cm / 2

# window
window_height_cm = wall_side_cm * 0.6

# merlon
merlon_count = 3  # number of merlons in a battlement piece
merlon_width_cm = wall_side_cm / (merlon_count * 2)
merlon_height_cm = merlon_width_cm * 1.3

# battlement
battlement_height_cm = wall_side_cm / 2
support_count = 6  # number of supports in a battlement piece
support_width_cm = wall_side_cm / (support_count * 3)
support_height_cm = (battlement_height_cm - merlon_height_cm) * 0.6

# roof
roof_width = wall_side_cm * pix_per_cm
roof_height = roof_width / 3

measurements.py

from merlons import rectangular_merlon as merlo_rettangolare
from merlons import rounded_merlon as merlo_arrotondato
from merlons import split_merlon as merlo_diviso

merli.py

from pytamaro import Graphic, Color
from pytamaro import circular_sector, rectangle
from pytamaro import rotate, beside, above

# constants
from measurements import merlon_width_cm, merlon_height_cm


# helper functions

def round_part(width: float, color: Color, concave: bool) -> Graphic:
    radius = width / 2
    quarter = circular_sector(radius, 90, color)
    if concave:
        return beside(quarter, rotate(90, quarter))
    else:
        return beside(rotate(90, quarter), quarter)
    

def rounded_merlon_generic(pix_per_cm: float, color: Color, concave: bool = True) -> Graphic:
    width = merlon_width_cm * pix_per_cm
    height = merlon_height_cm * pix_per_cm

    bottom_part_height = height - width / 2
    bottom_part = rectangle(width, bottom_part_height, color)
    return above(round_part(width, color, concave), bottom_part)



# the merlons

# split merlon
def split_merlon(pix_per_cm: float, color: Color) -> Graphic:
    return rounded_merlon_generic(pix_per_cm, color, True)


# rounded merlon
def rounded_merlon(pix_per_cm: float, color: Color) -> Graphic:
    return rounded_merlon_generic(pix_per_cm, color, False)


# rectangular merlon
def rectangular_merlon(pix_per_cm: float, color: Color) -> Graphic:
    width = merlon_width_cm * pix_per_cm
    height = merlon_height_cm * pix_per_cm
    return rectangle(width, height, color)

merlons.py

from premade_pieces import plain_wall as muro_vuoto
from premade_pieces import entrance as entrata
from premade_pieces import icy_wall as muro_ghiacciato
from premade_pieces import magical_wall as muro_magico
from premade_pieces import simple_battlement as merlatura_semplice
from premade_pieces import magical_battlement as merlatura_magica

# to avoid errors if people have old versions and not reset cells
from castello import ponte_levatoio

pezzi_prefabbricati.py

# premade walls
from castle_components import wall
from colors import grey, cyan, red, pink
from wall_borders import borders
from wall_properties import nothing, door, crack, ivy, bricks

plain_wall = wall(grey, borders, nothing)
entrance = wall(red, borders, door)
icy_wall = wall(cyan, borders, crack)
magical_wall = wall(pink, borders, ivy)


# premade battlements
from castle_components import battlement
from merlons import rectangular_merlon, split_merlon

simple_battlement = battlement(grey, rectangular_merlon)
magical_battlement = battlement(pink, split_merlon)


# to avoid errors if people have old versions and not reset cells
from castle_components import drawbridge

premade_pieces.py

from wall_properties import bricks as mattoni
from wall_properties import ivy as edera
from wall_properties import crack as crepa
from wall_properties import nothing as niente
from wall_properties import door as porta
from wall_properties import double_door as portone
from wall_properties import window as finestra
from wall_properties import arched_window as finestra_arcuata

# old version - kept in order to avoid errors if someone has an older version
from wall_properties import arched_window as finestra_arrotondata

proprieta_muro.py

from pytamaro import (
    Color, rectangle, empty_graphic, beside, above,
    hsv_color, compose, pin, bottom_right, Graphic
)

# error messages
from error_messages import arguments_error_message, CastleType

# helper functions
from color_functions import set_value, get_value

# measurements
from measurements import roof_width, roof_height



# helper functions

def beside_list(l: list[Graphic]) -> Graphic:
    result = empty_graphic()
    for g in l:
        result = beside(result, g)
    return result

# Roof

def new_brick(width: float, height: float, line_thickness: float, color: Color, dark_color: Color):
    brick_foreground = rectangle(width - line_thickness, height - line_thickness, color)
    brick_background = rectangle(width, height, dark_color)
    brick = compose(
        pin(bottom_right, brick_foreground), 
        pin(bottom_right, brick_background))
    return brick


def row(width: float, height: float, line_thickness: float, color: Color, dark_color: Color, brick_count: int) -> Graphic:
    brick = new_brick((width - line_thickness) / brick_count, height, line_thickness, color, dark_color)
    last_border = rectangle(line_thickness, height, dark_color)
    result = empty_graphic()
    for _ in range(brick_count):
        result = beside(result, brick)
    result = beside(result, last_border)
    return result


def new_roof(width: float, height: float, n_bricks: int, n_rows: int, color: Color):
    assert n_bricks >= n_rows
    line_thickness = width / n_bricks * 0.09
    brick_height = (height  - line_thickness) / n_rows
    brick_width = (width - line_thickness) / n_bricks
    color_line = set_value(color, get_value(color) * 0.6)
    brick = new_brick(brick_width, brick_height, line_thickness, color, color_line)
    bottom_line = rectangle(width, line_thickness, color_line)
    side_line = rectangle(line_thickness, brick_height, color_line)
    roof = empty_graphic()
    for i in range(n_rows):
        row = beside_list([brick] * (n_bricks - i))
        row = beside(row, side_line)
        roof = above(row, roof)
    return above(roof, bottom_line)


# generates a rood function in the specified language 
# (this is needed for custom error messages)
def roof(color: Color) -> Graphic:
    # ensure that the first parameter is a color
    assert isinstance(color, Color), arguments_error_message(roof, 0, CastleType.COLOR)

    return new_roof(roof_width, roof_height, 9, 9, color)


roof.py


# drawbridge states

aperto = True
chiuso = False

stati_ponte_levatoio.py

from premade_pieces import plain_wall as einfache_mauer
from premade_pieces import entrance as eingang
from premade_pieces import icy_wall as eismauer
from premade_pieces import magical_wall as magische_mauer
from premade_pieces import simple_battlement as einfache_brustwehr
from premade_pieces import magical_battlement as magische_brustwehr


# to avoid errors if people have old versions and not reset cells
from burg_komponenten import zugbruecke

vorgefertigte_teile.py


# wall border states

borders = True
no_borders = False

wall_borders.py

wall_properties.py

from typing import Callable
from pytamaro import Graphic, Color
from pytamaro import rectangle, overlay

# error messages
from error_messages import arguments_error_message, CastleType

from color_functions import set_value, get_value
from brick_border import add_brick_borders

# constants
from measurements import wall_side_cm, pix_per_cm


### the wall function

def wall(color: Color, borders: bool, texture: Callable[[float, Color], Graphic]) -> Graphic:
    # ensure that the first parameter is a color
    assert isinstance(color, Color), arguments_error_message(wall, 0, CastleType.COLOR)
    # ensure that the first parameter is a wall border
    assert isinstance(borders, bool), arguments_error_message(wall, 1, CastleType.WALL_BORDER)
    # ensure that the third parameter is a wall property
    assert isinstance(texture, Callable), arguments_error_message(wall, 2, CastleType.WALL_PROPERTY)


    height = wall_side_cm * pix_per_cm
    width = wall_side_cm * pix_per_cm
    brick_height = height / 15
    brick_color = set_value(color, get_value(color) * 0.85)
    # plain wall
    result = rectangle(width, height, color)
    # add borders
    if borders:
        result = add_brick_borders(
            result, brick_height, brick_color,
            True, True
        )
    # add texture
    return overlay(
        texture(width, color),
        result
    )

wall.py

from merlons import rectangular_merlon as rechteckige_zinnen
from merlons import rounded_merlon as runde_zinnen
from merlons import split_merlon as gespaltene_zinnen

zinnen.py


# drawbridge states

offen = True
geschlossen = False

zugbruecken_zustaende.py

Show a Magical Battlement

Visualizza una Merlatura Magica

Magische Brustwehr Anzeigen

Eine Funktion aufrufen um einen bestimmten Wert auszugeben.

Ausgabe durchführen

Unterscheiden zwischen Kommentaren und ausführbarem Code.

Kommentare unterscheiden

Argumente übergeben

Eine Funktion auffordern, ihre Berechnungen durchzuführen und das Ergebnis zurückzugeben.

Funktion aufrufen

Erhalten eines Rückgabewerts von einer Funktion.

Rückgabewert erhalten

Verwende Import-Anweisungen, um Namen aus Bibliotheken zu importieren.

Namen importieren

Greife auf den an einen Namen gebundenen Wert zu, durch Verwendung des Namens in einem Ausdruck.

Namen verwenden

Führe einen Namen für etwas ein, damit du dich dann mit diesem Namen auf diese Sache beziehen kannst.