path: root/PascalTriangle.activity/pascaltriangle.py

# coding=utf-8
#
# Pascal Triangle
# Copyright (C) Philip Withnall 2013 <philip@tecnocode.co.uk>
#
# Pascal Triangle 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.
#
# Pascal Triangle 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 Pascal Triangle.  If not, see <http://www.gnu.org/licenses/>.

from sugar3.activity import activity, widgets
from sugar3.graphics.alert import Alert
from sugar3.graphics.icon import Icon
from sugar3.graphics.toolbarbox import ToolbarBox
from sugar3.graphics.toolbutton import ToolButton
from sugar3.graphics.toggletoolbutton import ToggleToolButton
import math, random
from gi.repository import Gtk, Gdk
import cairo
from gettext import gettext as _

class PascalTriangleActivity(activity.Activity):
    def __init__(self, handle):
        activity.Activity.__init__(self, handle, False)

        # Create the standard activity toolbox.
        toolbar_box = ToolbarBox()
        self.set_toolbar_box(toolbar_box)
        toolbar_box.show()

        activity_toolbar = widgets.ActivityToolbar(self)
        toolbar_box.add(activity_toolbar)
        activity_toolbar.show()

        activity_toolbar.share.props.visible = False

        new_game_button = NewGameButton(self)
        new_game_button.show()
        activity_toolbar.insert(new_game_button, 0)

        hint_button = HintButton(self)
        hint_button.show()
        activity_toolbar.insert(hint_button, 1)

        stop_button = widgets.StopButton(self)
        stop_button.show()
        activity_toolbar.insert(stop_button, -1)

        # Create a new GTK+ drawing area
        drawing_area = Gtk.DrawingArea()
        drawing_area.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | \
                                Gdk.EventMask.KEY_PRESS_MASK)
        drawing_area.set_can_focus(True)
        drawing_area.connect('button-press-event',
                             self._drawing_area_button_press_cb, None)
        drawing_area.connect('key-press-event',
                             self._drawing_area_key_press_cb, None)
        drawing_area.connect('draw', self._drawing_area_draw_cb, None)

        # Create an overlay and a slider to allow the triangle size to be
        # adjusted. This is the number of cells on the triangle's base
        # (equivalently, the number of rows in the triangle).
        overlay = Gtk.Overlay()
        overlay.add(drawing_area)
        overlay.show()

        slider = Gtk.VScale()
        slider.props.digits = 0 # integers only
        slider.props.draw_value = False
        slider.props.has_origin = False
        slider.set_range(2, 10)
        slider.set_increments(1, 2)
        slider.set_value(5) # initial triangle size

        slider.props.halign = Gtk.Align.START
        slider.props.valign = Gtk.Align.START
        slider.set_size_request(70, 150)
        slider.show()
        overlay.add_overlay(slider)

        self._triangle_size = int(slider.get_value())
        slider.connect('value-changed', self._slider_value_changed_cb, None)

        # Parent and show the drawing area.
        self.set_canvas(overlay)
        drawing_area.show()
        self._drawing_area = drawing_area

        # Start with hints off and no 'game over' alert.
        self._show_hints = False
        self._alert = None

        # Start a new game.
        self._start_game()


    """
    Start a new game, clearing the previous game.
    """
    def _start_game(self):
        # Focus the drawing area so it can receive keyboard events.
        self._drawing_area.grab_focus()

        # Clear any alerts from the previous game.
        if self._alert:
            self.remove_alert(self._alert)
            self._alert = None

        # Padding around the edge of the drawing area.
        self._padding = 10.0 # Cairo units

        # Set the currently selected cell (which the user's clicked on).
        # Default to no selection (-1, -1).
        self._current_cell = (-1, -1)
        self._current_cell_text = ''

        # Generate a list of blank cells which the user needs to fill in.
        self._blank_cells = self._generate_blank_cell_list()

        self._drawing_area.queue_draw()


    def _update_current_cell(self, index):
        if index != self._current_cell:
            self._current_cell = index
            self._current_cell_text = ''
            widget.queue_draw()


    """
    Calculate the number of cells in the triangle. This is the Nth triangle
    number, where N is the triangle_size. The formula for this is 1/2*N*(N+1).
    """
    def _calculate_number_of_cells(self):
        return self._triangle_size * (self._triangle_size + 1) / 2


    def _generate_blank_cell_list(self):
        blank_cells = []

        # Generate a number of coordinates for blank cells, between 1 cell and
        # the entire triangle.
        num_blanks = random.randint(1, self._calculate_number_of_cells())
        for _ in range(num_blanks):
            row_index = random.randint(0, self._triangle_size - 1)
            column_index = random.randint(0, row_index)
            blank_cells.append((row_index, column_index))

        # Remove duplicates from the list. We're guaranteed to have a non-empty
        # list after this.
        return list(set(blank_cells))


    """
    Calculate the Pascal number for the (row, column) cell, where row and column
    are both 0-based. This is equivalent to calculating the Binomial coefficient
    of (row choose column).
    """
    def _calculate_pascal_number(self, index):
        row = index[0]
        column = index[1]

        num = math.factorial(row)
        denom = math.factorial(column) * math.factorial(row - column)
        return num / denom


    def _drawing_area_button_press_cb(self, widget, event, data = None):
        # Check whether the click fell within a cell; if so, change the cell
        # selection.
        if event.type != Gdk.EventType.BUTTON_PRESS:
            return

        # There may be a more efficient way of doing this, but this works and
        # is simple enough. Iterate through the cells and check whether the
        # click was within a given radius of the cell centre.
        widget_height = widget.get_allocated_height()
        base_width = widget.get_allocated_width() - 2.0 * self._padding
        triangle_height = widget_height - 2.0 * self._padding
        cell_width = base_width / self._triangle_size
        cell_height = 3.0 * (triangle_height / (2 * self._triangle_size + 1))

        radius = min(cell_width, cell_height) / 2.0

        for row_index in range(self._triangle_size):
            row_order = row_index + 1
            for column_index in range(row_order):
                index = (row_index, column_index)
                (cell_x, cell_y) = self._calculate_cell_position(base_width,
                    cell_width, cell_height, index)

                actual_radius_sq = (cell_x - event.x) ** 2 + \
                                   (cell_y - event.y) ** 2

                if actual_radius_sq <= radius ** 2:
                    # Found the cell.
                    self._update_current_cell(index)
                    return True

        # No cell found? Clear the current cell.
        self._update_current_cell((-1, -1))
        return True


    def _drawing_area_key_press_cb(self, widget, event, data = None):
        if event.type != Gdk.EventType.KEY_PRESS:
            return False

        # Give up if any modifiers are set.
        if event.state != 0:
            return True

        digit_keyvals = [
            Gdk.KEY_0,
            Gdk.KEY_1,
            Gdk.KEY_2,
            Gdk.KEY_3,
            Gdk.KEY_4,
            Gdk.KEY_5,
            Gdk.KEY_6,
            Gdk.KEY_7,
            Gdk.KEY_8,
            Gdk.KEY_9,
        ]
        control_keyvals = [
            # Only backspace is supported at the moment.
            Gdk.KEY_BackSpace,
        ]

        # Handle digit presses. Note we don't currently support infix editing
        # and we clamp to 2 digits.
        if event.keyval in digit_keyvals:
            if len(self._current_cell_text) < 2:
                digit = digit_keyvals.index(event.keyval)
                self._current_cell_text += '%i' % digit
                widget.queue_draw()

            # Check whether the answer is correct.
            self._check_current_cell_text(widget)

            return True
        # Otherwise, handle the control character
        elif event.keyval in control_keyvals:
            if event.keyval == Gdk.KEY_BackSpace:
                self._current_cell_text = self._current_cell_text[:-1]
                widget.queue_draw()
            return True

        # If the key pressed wasn't a digit or control character, ignore it.
        return True


    def _drawing_area_draw_cb(self, widget, ctx, data = None):
        # Widget allocation and sizes. The cell_height is calculated weirdly
        # because the cells interlock as they tesselate; so for 2 rows, the
        # bottom third of the top row overlaps with the top third of the bottom
        # row.
        widget_height = widget.get_allocated_height()
        base_width = widget.get_allocated_width() - 2.0 * self._padding
        triangle_height = widget_height - 2.0 * self._padding
        cell_width = base_width / self._triangle_size
        cell_height = 3.0 * (triangle_height / (2 * self._triangle_size + 1))

        # Set up drawing style.
        ctx.set_line_width(4)
        ctx.set_line_join(cairo.LINE_JOIN_ROUND)

        # Draw the triangle rows from the top down. The row_order is the number
        # of cells in the row (increasing from 1 to triangle_size, inclusive).
        for row_index in range(self._triangle_size):
            row_order = row_index + 1
            for column_index in range(row_order):
                index = (row_index, column_index)

                # Calculate the cell position.
                (cell_x, cell_y) = self._calculate_cell_position(base_width,
                    cell_width, cell_height, index)

                # Move to the cell position and draw the cell.
                ctx.move_to(cell_x, cell_y)
                self._draw_cell(ctx, index, cell_width, cell_height)

        return True


    def _calculate_cell_position(self, base_width, cell_width,
                                 cell_height, index):
        # Calculate the cell position. Add an offset every odd row so
        # the triangle is balanced. Each row is only 2/3 of cell_height
        # because the hexagons interlock as they tesselate.
        cell_x = self._padding + \
                 base_width / 2.0 - (cell_width / 2.0 * index[0]) + \
                 cell_width * index[1]
        cell_y = self._padding + cell_height / 2.0 + \
                 (cell_height * index[0] * (2.0 / 3.0))
        return (cell_x, cell_y)


    def _get_cell_background(self, index):
        if index == self._current_cell:
            return cairo.SolidPattern(0.541, 0.886, 0.204) # green
        elif self._show_hints and self._current_cell != (-1, -1) and \
             (self._current_cell[1] == 0 or \
              self._current_cell[1] == self._current_cell[0]) and \
             (index[1] == 0 or index[1] == index[0]):
            return cairo.SolidPattern(0.447, 0.624, 0.812) # blue
        elif self._show_hints and index[0] == self._current_cell[0] - 1 and \
             (index[1] == self._current_cell[1] - 1 or \
              index[1] == self._current_cell[1]):
            return cairo.SolidPattern(0.988, 0.914, 0.310) # yellow
        else:
            return cairo.SolidPattern(1.0, 1.0, 1.0) # white


    def _draw_cell(self, ctx, index, cell_width, cell_height):
        centre = ctx.get_current_point()

        # Draw the cell outline as a hexagon and fill it.
        ctx.rel_move_to(0.0, -cell_height / 2.0)
        ctx.rel_line_to(cell_width / 2.0, cell_height / 3.0)
        ctx.rel_line_to(0.0, cell_height / 3.0)
        ctx.rel_line_to(-cell_width / 2.0, cell_height / 3.0)
        ctx.rel_line_to(-cell_width / 2.0, -cell_height / 3.0)
        ctx.rel_line_to(0.0, -cell_height / 3.0)
        ctx.close_path()

        ctx.set_source_rgb(0.0, 0.0, 0.0)
        ctx.stroke_preserve()

        ctx.set_source(self._get_cell_background(index))
        ctx.fill()

        # Write its number if it's a non-empty cell. If it's an empty cell,
        # write a question mark unless it's the selected cell.
        cell_text = None
        if not index in self._blank_cells:
            cell_text = str(self._calculate_pascal_number(index))
            ctx.set_source_rgb(0.0, 0.0, 0.0) # black
        elif index != self._current_cell:
            # TRANS: This is the text shown in cells which haven't yet
            # been filled in by the user.
            cell_text = _('?')
            ctx.set_source_rgb(0.4, 0.4, 0.4) # grey
        else:
            cell_text = self._current_cell_text
            ctx.set_source_rgb(0.8, 0.0, 0.0) # red

        if cell_text != None:
            # Rule of thumb to scale the font size with the cells.
            font_size = int(50.0 / (float(self._triangle_size) / 5.0))

            extents = ctx.text_extents(cell_text)
            ctx.move_to(centre[0] - extents[2] / 2.0,
                        centre[1] + extents[3] / 2.0)
            ctx.set_font_size(font_size)
            ctx.show_text(cell_text)


    """
    Check whether the user-entered text for the current cell matches the
    expected value. If so, also check to see if the user's filled out all blank
    cells and hence has won.
    """
    def _check_current_cell_text(self, widget):
        # Check whether the answer is correct. If so, change the cell to be
        # uneditable.
        expected_num = self._calculate_pascal_number(self._current_cell)
        if int(self._current_cell_text) == expected_num:
            self._blank_cells.remove(self._current_cell)
            self._update_current_cell((-1, -1))

        # Check whether all blank cells have been filled.
        if len(self._blank_cells) == 0:
            alert = Alert()
            alert.props.title = _('You\'ve won!')
            alert.props.msg = _('Well done! You\'ve completed the Pascal '
                                'Triangle. Do you want to play again?')
            icon = Icon(icon_name = 'emblem-favorite')
            alert.props.icon = icon
            icon.show()

            icon = Icon(icon_name = 'add')
            alert.add_button(Gtk.ResponseType.ACCEPT, _('New Game'), icon)
            icon.show()

            alert.connect('response', self._alert_response_cb)

            alert.show()
            self._alert = alert
            self.add_alert(alert)


    def _alert_response_cb(self, alert, response_id):
        self._start_game()


    def get_show_hints(self):
        return self._show_hints

    def set_show_hints(self, val):
        self._show_hints = val
        self._drawing_area.queue_draw()

    show_hints = property(get_show_hints, set_show_hints)


    def _slider_value_changed_cb(self, widget, data = None):
        new_triangle_size = int(widget.get_value())

        if new_triangle_size != self._triangle_size:
            # Start a new game with the new triangle size.
            self._triangle_size = new_triangle_size
            self._start_game()


class NewGameButton(ToolButton):
    def __init__(self, parent_activity, **kwargs):
        ToolButton.__init__(self, 'add', **kwargs)
        self.props.tooltip = _('New Game')
        self.props.accelerator = '<Ctrl>N'
        self.connect('clicked', self.__new_game_button_clicked_cb,
                     parent_activity)

    def __new_game_button_clicked_cb(self, button, parent_activity):
        parent_activity._start_game()


class HintButton(ToggleToolButton):
    def __init__(self, parent_activity, **kwargs):
        ToggleToolButton.__init__(self, 'show-hints', **kwargs)
        #self.props.tooltip = 'Show Hints'
        self.set_tooltip(_('Show Hints'))

        # Add an accelerator. In later versions of Sugar, we can just set the
        # 'accelerator' property instead.
        #self.props.accelerator = '<Ctrl>H'
        accel_group = parent_activity.get_toplevel().sugar_accel_group
        keyval, mask = Gtk.accelerator_parse('<Ctrl>H')
        # the accelerator needs to be set at the child, so the Gtk.AccelLabel
        # in the palette can pick it up.
        accel_flags = Gtk.AccelFlags.LOCKED | Gtk.AccelFlags.VISIBLE
        self.get_child().add_accelerator('clicked', accel_group,
                                         keyval, mask, accel_flags)

        self.connect('clicked', self.__hint_button_clicked_cb, parent_activity)

    def __hint_button_clicked_cb(self, button, parent_activity):
        parent_activity.show_hints = self.get_active()