path: root/game.py

#!/usr/bin/env python

# Copyright (C) 2012 Agustin Zubiaga <aguz@sugarlabs.org>
# Copyright (C) 2012 Cristhofer Travieso <cristhofert97@gmail.com>

# This program 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 2 of the License, or
# (at your option) any later version.
#
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import cairo
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GObject
from sugar3.graphics import style

LINE_WIDTH = 12
SIZE = style.zoom(150)
BETWEEN_LINE_SPACE = style.zoom(200)

MODE_CIRCLE = 0
MODE_CROSS = 1

TICTACTOE_COLOR = (1, 1, 1)
CROSS_COLOR = (0, 0.921568, 0.0627450)
CIRCLE_COLOR = (1, 0.556862, 0)
BACKGROUND_COLOR = (0.352941, 0.349019, 0.709803)


class Canvas(Gtk.DrawingArea):

    __gsignals__ = {'cross-added': (GObject.SignalFlags.RUN_FIRST, None, [int]),
                    'circle-added': (GObject.SignalFlags.RUN_FIRST,
                                     None, [int])}

    def __init__(self):
        Gtk.DrawingArea.__init__(self)

        self._mode = MODE_CROSS
        self.circles = []
        self.crosses = []
        self.squares = []
        self.cursor = None

        self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK |
                        Gdk.EventMask.POINTER_MOTION_MASK)

        self.connect('draw', self._draw_cb)
        self.connect('button-press-event', self._click_cb)
        self.connect('motion-notify-event', self._motion_notify_cb)

        self.show_all()

    def set_mode(self, mode=MODE_CROSS):
        self._mode = mode

    def clear(self):
        self.circles = []
        self.crosses = []
        self.queue_draw()

    def _draw_cb(self, widget, context):
        alloc = self.get_allocation()

        # Background
        context.rectangle(0, 0, alloc.width, alloc.height)
        context.set_source_rgb(*BACKGROUND_COLOR)
        context.fill()

        # Tic-Tac-Toe
        context.set_source_rgb(*TICTACTOE_COLOR)
        context.set_line_width(LINE_WIDTH)
        context.set_line_cap(cairo.LINE_CAP_ROUND)

        x = (alloc.width - BETWEEN_LINE_SPACE * 3) / 2
        y = (alloc.height - BETWEEN_LINE_SPACE * 3) / 2

        y += BETWEEN_LINE_SPACE
        lx = (BETWEEN_LINE_SPACE + (LINE_WIDTH * 8.2)) * 3
        context.move_to(x, y)
        context.line_to(lx, y)

        size = SIZE / 2 + style.zoom(25)

        cx1 = x + size
        cx2 = x + BETWEEN_LINE_SPACE + size
        cx3 = x + (BETWEEN_LINE_SPACE * 2) + size

        x += BETWEEN_LINE_SPACE
        y -= BETWEEN_LINE_SPACE
        screen_width = Gdk.Screen.width()
        infactor = 1.5 + ((screen_width - 1024) / 100.0)
        ly = (BETWEEN_LINE_SPACE + (LINE_WIDTH * infactor)) * 3
        context.move_to(x, y)
        context.line_to(x, ly)

        cy1 = y + size
        cy2 = y + BETWEEN_LINE_SPACE + size
        cy3 = y + (BETWEEN_LINE_SPACE * 2) + size

        y += BETWEEN_LINE_SPACE * 2
        x -= BETWEEN_LINE_SPACE
        context.move_to(x, y)
        context.line_to(lx, y)

        x += BETWEEN_LINE_SPACE * 2
        y -= BETWEEN_LINE_SPACE * 2
        context.move_to(x, y)
        context.line_to(x, ly)
        context.stroke()

        # Save center squares coords
        if not cx1 < 0:
            self.squares = []
            self.squares.extend([(cx1, cy1), (cx2, cy1), (cx3, cy1)])
            self.squares.extend([(cx1, cy2), (cx2, cy2), (cx3, cy2)])
            self.squares.extend([(cx1, cy3), (cx2, cy3), (cx3, cy3)])

        # Draw circles and crosses
        context.set_source_rgb(*CIRCLE_COLOR)
        for circle in self.circles:
            if circle == self.cursor:
                self.cursor = None
            x, y = circle
            context.arc(x, y, SIZE / 2, 0, 360)
            context.stroke()

        context.set_source_rgb(*CROSS_COLOR)
        for cross in self.crosses:
            if cross == self.cursor:
                self.cursor = None
            x, y = cross
            a = SIZE / 2
            context.move_to(x - a, y - a)
            context.line_to(x + a, y + a)

            context.move_to(x + a, y - a)
            context.line_to(x - a, y + a)
            context.stroke()

        # Draw cursor dot
        try:
            context.set_source_rgb(*TICTACTOE_COLOR)
            cx, cy = self.cursor
            context.arc(cx, cy, 9, 0, 360)
            context.fill_preserve()
            context.stroke()
        except:
            pass

    def _motion_notify_cb(self, widget, event):
        self.cursor = self.get_pos(event.x, event.y)
        self.queue_draw()

    def add_cross(self, square, emit_signal=True):
        self.crosses.append(
              square if type(square) == tuple else self.squares[square])
        if emit_signal:
            self.emit('cross-added', self.squares.index(square))
        self.queue_draw()

    def add_circle(self, square, emit_signal=True):
        self.circles.append(
              square if type(square) == tuple else self.squares[square])
        if emit_signal:
            self.emit('circle-added', self.squares.index(square))
        self.queue_draw()

    def _click_cb(self, widget, event):
        pos = self.get_pos(event.x, event.y)

        if self._mode == MODE_CROSS and pos:
            self.add_cross(pos)
        elif self._mode == MODE_CIRCLE and pos:
            self.add_circle(pos)

    def get_pos(self, mx, my):
        try:
            ypos = 0
            xpos = 0
            all_x = [s[0] for s in self.squares]
            all_y = [s[1] for s in self.squares]

            size = SIZE / 2 + style.zoom(25)

            if mx > all_x[0] and not mx > all_x[-1]:
                count = 0
                for x in all_x:
                    if not xpos:
                        count += 1
                        next_x = all_x[count]
                        if mx >= (x - size) and mx <= (next_x - size):
                            xpos = x

            elif mx < all_x[0]:
                xpos = all_x[0]

            elif mx > all_x[-1]:
                xpos = all_x[-1]

            if my > all_y[0] and not my > all_y[-1]:
                count = 0
                for y in all_y:
                    if not ypos:
                        count += 1
                        next_y = all_y[count]
                        if my >= (y - size) and my <= (next_y - size):
                            ypos = y

            elif my < all_y[0]:
                ypos = all_y[0]

            elif my > all_y[-1]:
                ypos = all_y[-1]

            pos = xpos, ypos
            if pos in self.crosses and pos in self.circles:
                pos = None
            return pos

        except IndexError:
            return None

if __name__ == "__main__":
    window = Gtk.Window()
    window.connect('destroy', lambda w: Gtk.main_quit())
    window.add(Canvas())
    window.maximize()
    window.show_all()
    Gtk.main()