Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf8
from __future__ import absolute_import, division, print_function
import Tkinter as tk
from collections import defaultdict, namedtuple
from colorsys import hls_to_rgb
from itertools import izip
from math import sqrt
from random import choice, randint, sample
from tkFont import BOLD, Font


def get_colors(count):
    return [
        '#{0[0]:02x}{0[1]:02x}{0[2]:02x}'.format(
            [int(c * 255) for c in hls_to_rgb(i / count, 0.75, 1)]
        )
        for i in xrange(count)
    ]


class Coordinate(namedtuple('Coordinate', 'x y')):

    def __str__(self):
        return '({0.x}, {0.y})'.format(self)

    def __add__(self, other):
        return Coordinate(self.x + other.x, self.y + other.y)

    def adjusted(self, width, height):
        return Coordinate(self.x % width, self.y % height)

    @classmethod
    def random(cls, min_x, max_x, min_y, max_y):
        return cls(randint(min_x, max_x), randint(min_y, max_y))


class PieceType(object):

    def __init__(self, name, moves):
        self.name = name
        self.moves = moves

    def __cmp__(self, other):
        return cmp(self.name, other.name)

    def __hash__(self):
        return hash(self.name)

    def __len__(self):
        return len(self.moves)

    def __getitem__(self, step_number):
        return self.moves[self.get_move_number(step_number)]

    def get_move_number(self, step_number):
        return step_number % len(self)

    @classmethod
    def random(cls, name):
        return cls(
            name,
            [
                Coordinate(randint(-2, 2), randint(-2, 2))
                for _ in xrange(randint(1, 5))
            ]
        )


class FieldCoordinates(object):

    def __init__(self, size):
        self.size = size

    def __len__(self):
        return self.size**2

    def __getitem__(self, index):
        if not 0 <= index < len(self):
            raise IndexError()
        x, y = divmod(index, self.size)
        return Coordinate(x, y)

    def sample(self, count):
        return sample(self, count)


class Field(object):

    def __init__(self, size):
        self.size = size
        self.coordinates = FieldCoordinates(self.size)
        self.coordinate2piece_types = defaultdict(set)
        self.step_number = 0

    def __getitem__(self, coordinate):
        return self.coordinate2piece_types[coordinate]

    def add_piece(self, type_, coordinate):
        self.coordinate2piece_types[coordinate].add(type_)

    def iter_pieces(self):
        for coordinate, piece_types in self.coordinate2piece_types.iteritems():
            for piece_type in piece_types:
                yield coordinate, piece_type

    def get_piece_types(self):
        return sorted(set(p for c, p in self.iter_pieces()))

    def next_step(self):
        old_pieces = list(self.iter_pieces())
        self.coordinate2piece_types = defaultdict(set)
        for coordinate, piece_type in old_pieces:
            self.add_piece(
                piece_type,
                (
                    coordinate + piece_type[self.step_number]
                ).adjusted(self.size, self.size)
            )
        self.step_number += 1

    @classmethod
    def random(cls, size, names):
        result = cls(size)
        piece_types = [PieceType.random(name) for name in names]
        coordinates = FieldCoordinates(size)
        for coordinate in coordinates.sample(len(coordinates) // 2):
            result.add_piece(choice(piece_types), coordinate)
        return result

# ------------------------------------------------------------------------

class PieceTypeUI(tk.Frame):

    def __init__(self, parent, type_, color):
        tk.Frame.__init__(self, parent, relief=tk.RAISED, borderwidth=1)
        self.type = type_
        font = Font(self)
        font.configure(size=font.actual()['size'] * 2, weight=BOLD)
        label = tk.Label(
            self,
            text=self.type.name,
            width='2',
            font=font,
            background=color,
        )
        label.grid(row=0, column=0, rowspan=2, sticky=tk.NSEW)
        self.step_label = tk.Label(self)
        self.step_label.grid(row=0, column=1, sticky=tk.W)
        self.move_label = tk.Label(self)
        self.move_label.grid(row=1, column=1, sticky=tk.W)
        self.refresh()

    def refresh(self, step_number=0):
        self.step_label['text'] = 'step {0}/{1}'.format(
            self.type.get_move_number(step_number) + 1, len(self.type)
        )
        self.move_label['text'] = 'next move {0}'.format(self.type[step_number])


class PiecesUI(tk.LabelFrame):

    def __init__(self, parent, field, piece_type2color):
        tk.LabelFrame.__init__(self, parent, text='Pieces', padx=3, pady=3)
        self.field = field
        self.info_uis = list()
        for piece_type, color in sorted(piece_type2color.iteritems()):
            info_ui = PieceTypeUI(self, piece_type, color)
            info_ui.pack(side=tk.TOP, fill=tk.X)
            self.info_uis.append(info_ui)

    def refresh(self):
        for info_ui in self.info_uis:
            info_ui.refresh(self.field.step_number)


class CellUI(tk.Frame):

    def __init__(self, parent, field, coordinate, piece_type2color):
        tk.Frame.__init__(self, parent, borderwidth=1, relief=tk.RAISED)
        self.field = field
        self.coordinate = coordinate
        self.piece_type2color = piece_type2color
        piece_types = sorted(self.piece_type2color.iterkeys())
        size = int(sqrt(len(piece_types)) + 0.5)
        self.piece_type2label = list()
        for i, piece_type in enumerate(piece_types):
            label = tk.Label(
                self, text=piece_type.name, width=1, height=1
            )
            row, column = divmod(i, size)
            label.grid(row=row, column=column)
            self.piece_type2label.append((piece_type, label))
        self.refresh()
        self.propagate(False)

    def refresh(self):
        field_piece_types = self.field[self.coordinate]
        for piece_type, label in self.piece_type2label:
            label['background'] = (
                self.piece_type2color[piece_type]
                    if piece_type in field_piece_types
                    else 'gray25'
            )


class FieldUI(tk.Frame):

    def __init__(self, parent, field, piece_type2color):
        tk.Frame.__init__(self, parent)
        self.field = field
        self.cell_uis = list()
        for coordinate in self.field.coordinates:
            cell_ui = CellUI(self, self.field, coordinate, piece_type2color)
            cell_ui.grid(row=coordinate.y, column=coordinate.x, sticky=tk.NSEW)
            self.cell_uis.append(cell_ui)
        self.propagate(False)

    def refresh(self):
        for cell_ui in self.cell_uis:
            cell_ui.refresh()



class MainUI(tk.Frame):

    def __init__(self, parent, field):
        tk.Frame.__init__(self, parent)
        self.field = field
        piece_types = self.field.get_piece_types()
        piece_type2color = dict(izip(piece_types, get_colors(len(piece_types))))
        self.field_ui = FieldUI(self, self.field, piece_type2color)
        self.field_ui.pack(side=tk.LEFT, anchor=tk.N)
        
        frame = tk.Frame(self)
        self.pieces_ui = PiecesUI(frame, self.field, piece_type2color)
        self.pieces_ui.pack(side=tk.TOP, anchor=tk.E)

        step_frame = tk.LabelFrame(frame, text='Current Step', padx=3, pady=3)
        tk.Button(
            step_frame, text='Next', command=self.do_next
        ).pack(side=tk.RIGHT)
        self.step_number_label = tk.Label(step_frame)
        self.step_number_label.pack(side=tk.RIGHT)
        step_frame.pack(side=tk.TOP, fill=tk.X)

        frame.pack(side=tk.LEFT, padx=3, anchor=tk.N)
        self.refresh()

    def refresh(self):
        self.step_number_label['text'] = self.field.step_number
        self.field_ui.refresh()
        self.pieces_ui.refresh()

    def do_next(self):
        self.field.next_step()
        self.refresh()


def main():
    root = tk.Tk()
    root.title('Moving Pieces')
    field = Field.random(20, 'ABCDEFGH')
    main_ui = MainUI(root, field)
    main_ui.pack()
    root.mainloop()


if __name__ == '__main__':
    main()