~euchre-team/euchre/trunk

/*
 * Copyright (C) 2013 Robert Ancell <robert.ancell@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 3 of the License, or (at your option) any later
 * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
 * license.
 */

import QtQuick 2.0
import Ubuntu.Components 1.1

MainView {
    applicationName: "com.ubuntu.developer.robert-ancell.euchre"
    automaticOrientation: true

    width: units.gu (40)
    height: units.gu (71)

    Page {
        anchors.fill: parent
        id: table

        // Background
        Rectangle {
            anchors.fill: parent
            color: "#4e9a06"
        }

        // Labels to show score
        EuchreLabel {
            id: ns_score_label
            opacity: 0
            horizontalAlignment: Text.AlignHCenter
            verticalAlignment: Text.AlignVCenter
        }
        EuchreLabel {
            id: ew_score_label
            opacity: 0
            horizontalAlignment: Text.AlignHCenter
            verticalAlignment: Text.AlignVCenter
        }

        // Label to show trump suit
        EuchreLabel {
            id: trump_label
            opacity: 0
            horizontalAlignment: Text.AlignHCenter
            verticalAlignment: Text.AlignVCenter
        }
        Item {
            id: maker_arrow
            opacity: 0

            Icon {
                name: "chevron"
                color: "white"
                anchors {
                    top: parent.top
                    bottom: parent.bottom
                    right: parent.right
                }
                width: height
            }
        }

        // Label to inform player
        EuchreLabel {
            id: prompt_label
            opacity: 0
            horizontalAlignment: Text.AlignHCenter
            verticalAlignment: Text.AlignBottom
        }

        // Button to pass
        Rectangle {
            id: pass_button
            color: "white"
            opacity: 0
            border.color: "black"
            border.width: 1
            antialiasing: true

            signal selected ()

            Text {
                id: pass_label
                anchors.fill: parent
                text: "Pass"
                font.pixelSize: height * 0.6
                horizontalAlignment: Text.AlignHCenter
                verticalAlignment: Text.AlignVCenter
            }
            Behavior on opacity {
                NumberAnimation {
                    duration: 300
                    easing.type: Easing.InOutCubic
                }
            }
            Behavior on x {
                NumberAnimation {
                    duration: 300
                    easing.type: Easing.InOutCubic
                }
            }
            Behavior on y {
                NumberAnimation {
                    duration: 300
                    easing.type: Easing.InOutCubic
                }
            }
            Behavior on width {
                NumberAnimation {
                    duration: 300
                    easing.type: Easing.InOutCubic
                }
            }
            Behavior on height {
                NumberAnimation {
                    duration: 300
                    easing.type: Easing.InOutCubic
                }
            }
            MouseArea {
                anchors.fill: parent
                enabled: parent.opacity > 0
                onPressed: pass_button.selected ()
            }
        }

        // Timer to delay AI decisions
        Timer {
            id: timer
            interval: 1500
            signal done ()
            onTriggered: done ()
        }

        Component.onCompleted: {
            var card_component = Qt.createComponent ("PlayingCard.qml")
            //if (card_component.status == Component.Ready)

            // The cards in play
            var numbers = [ "nine", "ten", "jack", "queen", "king", "ace" ]
            var number_symbols = [ "9", "10", "J", "Q", "K", "A" ]
            var suits = [ "Spades", "Clubs", "Hearts", "Diamonds" ]
            var suit_symbols = [ "♠", "♣", "♥", "♦" ]
            var deck = []
            for (var s = 0; s < suits.length; s++) {
                for (var n = 0; n < numbers.length; n++) {
                    var card = card_component.createObject (table)
                    card.number = number_symbols[n]
                    card.suit = suit_symbols[s]
                    card.front_source = numbers[n] + suits[s] + ".png"
                    card.back_source = "back.png"
                    deck.push (card)
                }
            }

            // Cards to pick suit with
            var suit_cards = []
            for (var s = 0; s < suits.length; s++) {
                var card = card_component.createObject (table)
                card.opacity = 0
                card.suit = suit_symbols[s]
                card.front_source = "ace" + suits[s] + ".png"
                suit_cards.push (card)
            }
            var trumpSkip = card_component.createObject (table)
            trumpSkip.opacity = 0
            trumpSkip.suit = ""
            trumpSkip.front_source = "back.png"
            suit_cards.push (trumpSkip)

            // Handle the user clicking on the cards
            for (var i = 0; i < deck.length; i++)
                deck[i].selected.connect (on_select_card)
            pass_button.selected.connect (on_pass)
            for (var i = 0; i < suit_cards.length; i++)
                suit_cards[i].selected.connect (on_select_suit)

            // Game phase:
            // "dealing0", "dealing1", "dealing2", "dealing3", "dealing4", "dealing5" - Dealing cards
            // "ordering" - Players considering ordering dealer
            // "ordering-ai" - AI ordering
            // "ordering-human" - Waiting for human to order
            // "swapping0", "swapping1" - Dealing swapping after being ordered
            // "calling" - Calling for a suit
            // "calling-ai" - AI calling
            // "calling-human" - Waiting for human to call
            // "calling-done" - Finish calling animation
            // "playing" - Playing a trick
            // "playing-human" - Waiting for human to play
            // "collecting-trick" - Won trick being collected
            // "complete" - Game over
            var phase = ""

            // The players hands
            var n_hand = []
            var n_tricks = []
            var e_hand = []
            var e_tricks = []
            var s_hand = []
            var s_tricks = []
            var w_hand = []
            var w_tricks = []

            // The kitty
            var kitty = []

            // The current trick
            var trick = []

            // Player who dealt this round
            var dealer = 0

            // Player that started the current trick
            var lead_player = 0

            // Player moving
            var current_player = 0

            // The player that won the call
            var calling_player = -1

            // Trump suit for this trick
            var trump_suit = ""

            // Game scores
            var ew_score = 0
            var ns_score = 0

            // Relayout on resize
            table.onWidthChanged.connect (layout)
            table.onHeightChanged.connect (layout)

            // Start animation
            for (var i = 0; i < deck.length; i++)
                deck[i].animation_enabled = true
            for (var i = 0; i < suit_cards.length; i++)
                suit_cards[i].animation_enabled = true

            // Start the game!
            start_game ()

            // Get the name of a player
            function player_name (number) {
                if (number == 0)
                    return "South"
                if (number == 1)
                    return "West"
                if (number == 2)
                    return "North"
                if (number == 3)
                    return "East"
            }

            // Get the hand of a player
            function player_hand (number) {
                if (number == 0)
                    return s_hand
                if (number == 1)
                    return w_hand
                if (number == 2)
                    return n_hand
                if (number == 3)
                    return e_hand
            }

            // Get the tricks of a player
            function player_tricks (number) {
                if (number == 0)
                    return s_tricks
                if (number == 1)
                    return w_tricks
                if (number == 2)
                    return n_tricks
                if (number == 3)
                    return e_tricks
            }

            // Position/resize cards to their required location
            function layout () {
                // Minimum space between elements
                var border = 10

                // Use standard card aspect ratio
                var aspect = 56 / 87

                // FIXME: Can overlap on square resoltions

                // Maximum width is being able to fit 5 cards wide
                var max_width = (table.width - border * 4) / 5
                var h = max_width / aspect

                // Maximum height is being able to fit 5 overlapping cards high (cards overlap by one half height)
                var max_height = (table.height - border * 4) / 4

                var card_height = Math.min (max_height, h)
                var card_width = aspect * card_height

                // Stack cards
                var z = 1
                for (var i = 0; i < kitty.length; i++)
                    kitty[i].z = z++
                for (var i = 0; i < s_tricks.length; i++)
                    for (var j = 0; j < s_tricks[i].length; j++)
                        s_tricks[i][j].z = z++
                for (var i = 0; i < w_tricks.length; i++)
                    for (var j = 0; j < w_tricks[i].length; j++)
                        w_tricks[i][j].z = z++
                for (var i = 0; i < n_tricks.length; i++)
                    for (var j = 0; j < n_tricks[i].length; j++)
                        n_tricks[i][j].z = z++
                for (var i = 0; i < e_tricks.length; i++)
                    for (var j = 0; j < e_tricks[i].length; j++)
                        e_tricks[i][j].z = z++
                for (var i = 0; i < s_hand.length; i++)
                    s_hand[i].z = z++
                for (var i = 0; i < w_hand.length; i++)
                    w_hand[i].z = z++
                for (var i = 0; i < n_hand.length; i++)
                    n_hand[i].z = z++
                for (var i = 0; i < e_hand.length; i++)
                    e_hand[i].z = z++
                for (var i = 0; i < trick.length; i++)
                    trick[i].z = z++
                for (var i = 0; i < suit_cards.length; i++)
                    suit_cards[i].z = z++
                prompt_label.z = z++

                // Pass button below deck
                pass_button.x = (table.width - card_width) / 2
                pass_button.y = (table.height + card_height) / 2 + border
                pass_button.width = card_width
                pass_button.height = card_height / 4
                pass_button.radius = 0.1 * pass_button.width

                // Trump label below deck
                trump_label.x = 0
                trump_label.y = (table.height + card_height) / 2 + border
                trump_label.width = table.width
                trump_label.height = card_height / 2
                trump_label.font.pixelSize = card_height / 4

                // Maker arrow
                maker_arrow.x = (table.width - card_width) / 2
                maker_arrow.y = trump_label.y + card_height / 8
                maker_arrow.height = card_height / 4
                maker_arrow.width = card_width

                // Score labels on either side of trump label
                ns_score_label.x = border + card_width
                ns_score_label.y = trump_label.y
                ns_score_label.width = (table.width - card_width) / 2 - card_width - border
                ns_score_label.height = trump_label.height
                ns_score_label.font.pixelSize = card_height / 2
                ew_score_label.x = (table.width + card_width) / 2
                ew_score_label.y = trump_label.y
                ew_score_label.width = table.width - ew_score_label.x - card_width - border
                ew_score_label.height = trump_label.height
                ew_score_label.font.pixelSize = card_height / 2

                // Deck is in the middle or by the dealer
                var deck_x = (table.width - card_width) / 2
                var deck_y = (table.height - card_height) / 2
                if (phase == "dealing0" || phase == "dealing1" || phase == "dealing2" || phase == "dealing3" || phase == "dealing4" || phase == "dealing5") {
                    if (dealer == 0)
                        deck_y = table.height - border - card_height
                    else if (dealer == 1)
                        deck_x = border
                    else if (dealer == 2)
                        deck_y = border
                    else if (dealer == 3)
                        deck_x = table.width - border - card_width
                }

                // Deal cards in order
                var place_n
                var place_s
                var place_e
                var place_w
                var place_kitty
                var n
                if (phase == "dealing0")
                    n = 0
                else if (phase == "dealing1")
                    n = 1
                else if (phase == "dealing2")
                    n = 2
                else if (phase == "dealing3")
                    n = 3
                else if (phase == "dealing4")
                    n = 4
                else
                    n = 5
                if (dealer == 0) {
                    place_w = n > 0
                    place_n = n > 1
                    place_e = n > 2
                    place_kitty = n > 3
                    place_s = n > 4
                }
                else if (dealer == 1) {
                    place_n = n > 0
                    place_e = n > 1
                    place_s = n > 2
                    place_kitty = n > 3
                    place_w = n > 4
                }
                else if (dealer == 2) {
                    place_e = n > 0
                    place_s = n > 1
                    place_w = n > 2
                    place_kitty = n > 3
                    place_n = n > 4
                }
                else if (dealer == 3) {
                    place_s = n > 0
                    place_w = n > 1
                    place_n = n > 2
                    place_kitty = n > 3
                    place_e = n > 4
                }

                for (var i = 0; i < deck.length; i++) {
                    deck[i].x = deck_x
                    deck[i].y = deck_y
                    deck[i].rotation = 0
                    deck[i].width = card_width
                    deck[i].height = card_height
                }

                // Get x co-ordinate to spread 'i'th card in hand of size 'n_cards' with card overlap fraction of 'overlap_fraction'
                function spread_x (n_cards, i, overlap_fraction) {
                    var overlap = overlap_fraction * card_width
                    return (table.width / 2) - (card_width + overlap * (n_cards - 1)) / 2 + overlap * i
                }
                // Get y co-ordinate to spread 'i'th card in hand of size 'n_cards' with card overlap fraction of 'overlap_fraction'
                function spread_y (n_cards, i, overlap_fraction) {
                    var overlap = overlap_fraction * card_height
                    return (table.height / 2) - (card_height + overlap * (n_cards - 1)) / 2 + overlap * i
                }

                if (place_s) {
                    for (var i = 0; i < s_hand.length; i++) {
                        s_hand[i].x = spread_x (s_hand.length, i, 1.0)
                        s_hand[i].y = table.height - card_height - border
                    }
                    for (var i = 0; i < s_tricks.length; i++) {
                        for (var j = 0; j < s_tricks[i].length; j++) {
                            s_tricks[i][j].x = spread_x (s_tricks.length, i, 0.2)
                            s_tricks[i][j].y = table.height - card_height - border - card_height * 0.2
                            s_tricks[i][j].rotation = 5
                        }
                    }
                }
                prompt_label.x = 0
                if (phase == "swapping0" && dealer == 0)
                    prompt_label.y = -card_height * 0.25 // NOTE: This should probably be the height being changed but QML doesn't redraw
                else if (s_tricks.length > 0)
                    prompt_label.y = -card_height * 0.2 // NOTE: This should probably be the height being changed but QML doesn't redraw
                else
                    prompt_label.y = 0
                prompt_label.width = table.width
                prompt_label.height = table.height - card_height - border * 1.5
                prompt_label.font.pixelSize = card_height * 0.2

                // Indicate which player is active in certain phases
                var indicate_ai = phase == "ordering-ai" || phase == "calling-ai" || phase == "calling-done" || phase == "swapping0"
                var indicate_dealer = phase == "ordering" || phase == "ordering-ai" || phase == "ordering-human" || phase == "calling" || phase == "calling-ai" || phase == "calling-human" || phase == "calling-done"

                if (place_w) {
                    var card_offsets = [ 0, 0, 0, 0, 0]
                    if (indicate_dealer && dealer == 1)
                        card_offsets[2] = card_width * 0.1
                    if (indicate_ai && current_player == 1) {
                        card_offsets[1] = card_width * 0.1
                        card_offsets[2] = card_width * 0.2
                        card_offsets[3] = card_width * 0.1
                    }
                    for (var i = 0; i < w_hand.length; i++) {
                        w_hand[i].x = border + card_offsets[i]
                        w_hand[i].y = spread_y (w_hand.length, i, 0.5)
                    }
                    for (var i = 0; i < w_tricks.length; i++) {
                        for (var j = 0; j < w_tricks[i].length; j++) {
                            w_tricks[i][j].x = border + card_width * 0.2
                            w_tricks[i][j].y = spread_y (w_tricks.length, i, 0.2)
                            w_tricks[i][j].rotation = 5
                        }
                    }
                }

                if (place_n) {
                    var card_offsets = [ 0, 0, 0, 0, 0]
                    if (indicate_dealer && dealer == 2)
                        card_offsets[2] = card_height * 0.1
                    if (indicate_ai && current_player == 2) {
                        card_offsets[1] = card_height * 0.1
                        card_offsets[2] = card_height * 0.2
                        card_offsets[3] = card_height * 0.1
                    }
                    for (var i = 0; i < n_hand.length; i++) {
                        n_hand[i].x = spread_x (n_hand.length, i, 1.0)
                        n_hand[i].y = border + card_offsets[i]
                    }
                    for (var i = 0; i < n_tricks.length; i++) {
                        for (var j = 0; j < n_tricks[i].length; j++) {
                            n_tricks[i][j].x = spread_x (n_tricks.length, i, 0.2)
                            n_tricks[i][j].y = border + card_height * 0.2
                            n_tricks[i][j].rotation = 5
                        }
                    }
                }

                if (place_e) {
                    var card_offsets = [ 0, 0, 0, 0, 0]
                    if (indicate_dealer && dealer == 3)
                        card_offsets[2] = card_width * 0.1
                    if (indicate_ai && current_player == 3) {
                        card_offsets[1] = card_width * 0.1
                        card_offsets[2] = card_width * 0.2
                        card_offsets[3] = card_width * 0.1
                    }
                    for (var i = 0; i < e_hand.length; i++) {
                        e_hand[i].x = table.width - card_width - border - card_offsets[i]
                        e_hand[i].y = spread_y (e_hand.length, i, 0.5)
                    }
                    for (var i = 0; i < e_tricks.length; i++) {
                        for (var j = 0; j < e_tricks[i].length; j++) {
                            e_tricks[i][j].x = table.width - card_width - border - card_width * 0.2
                            e_tricks[i][j].y = spread_y (e_tricks.length, i, 0.2)
                            e_tricks[i][j].rotation = 5
                        }
                    }
                }

                if (place_kitty) {
                    for (var i = 0; i < kitty.length; i++) {
                        kitty[i].x = (table.width - card_width) / 2
                        kitty[i].y = (table.height - card_height) / 2
                    }
                }

                // Put card to swap beside hand of player
                if (phase == "swapping0") {
                    if (dealer == 0) {
                        kitty[3].x = (table.width - card_width) / 2
                        kitty[3].y = table.height - 1.25 * card_height - border
                    }
                    else if (dealer == 1) {
                        kitty[3].x = border + 0.25 * card_width
                        kitty[3].y = (table.height - card_height) / 2
                    }
                    else if (dealer == 2) {
                        kitty[3].x = (table.width - card_width) / 2
                        kitty[3].y = border + 0.25 * card_height
                    }
                    else if (dealer == 3) {
                        kitty[3].x = table.width - 1.25 * card_width - border
                        kitty[3].y = (table.height - card_height) / 2
                    }
                }

                function get_trick_x (index) {
                    var p = (lead_player + index) % 4
                    if (p == 1)
                        return (table.width / 2) - card_width
                    if (p == 3)
                        return table.width / 2
                    return (table.width - card_width) / 2
                }

                function get_trick_y (index) {
                    var p = (lead_player + index) % 4
                    if (p == 0)
                        return (table.height / 2)
                    if (p == 2)
                        return (table.height / 2) - card_height
                    return (table.height - card_height) / 2
                }

                // Place current trick in the middle
                if (phase == "playing" || phase == "playing-human") {
                    if (trick.length > 0) {
                        trick[0].x = get_trick_x (0)
                        trick[0].y = get_trick_y (0)
                    }
                    if (trick.length > 1) {
                        trick[1].x = get_trick_x (1)
                        trick[1].y = get_trick_y (1)
                    }
                    if (trick.length > 2) {
                        trick[2].x = get_trick_x (2)
                        trick[2].y = get_trick_y (2)
                    }
                    if (trick.length > 3) {
                        trick[3].x = get_trick_x (3)
                        trick[3].y = get_trick_y (3)
                    }
                }

                // Place the three suits available to pick from
                for (var i = 0; i < suit_cards.length; i++) {
                    suit_cards[i].x = (table.width - card_width) / 2
                    suit_cards[i].y = (table.height - card_height) / 2
                    suit_cards[i].width = card_width
                    suit_cards[i].height = card_height
                }
                if (phase == "calling" || phase == "calling-ai" || phase == "calling-human") {
                    var i = 0
                    for (var x = 0; x < 2; x++) {
                        for (var y = 0; y < 2; y++) {
                            // Can't pick the previously offered trump suit
                            if (suit_cards[i].suit == kitty[3].suit)
                                i++
                            suit_cards[i].x = table.width / 2 + (x - 1) * card_width
                            suit_cards[i].y = table.height / 2 + (y - 1) * card_height
                            i++
                        }
                    }
                }
            }

            // Start a game
            function start_game () {
                console.log ("Start game")

                // Human always deals
                dealer = 0

                // Reset score
                ew_score = 0
                ns_score = 0
                ns_score_label.opacity = 0
                ew_score_label.opacity = 0

                // Remove any prompts
                clear_prompt ()

                // Deal out a round
                deal ()
            }

            // Deal a round
            function deal () {
                phase = "dealing0"
                current_player = dealer
                lead_player = 0
                calling_player = -1
                trump_suit = ""
                trump_label.opacity = 0
                maker_arrow.opacity = 0

                function shuffle (value) {
                    var i = value.length, j, temp
                    if (i === 0)
                        return false
                    while (--i) {
                        j = Math.floor (Math.random() * (i + 1))
                        temp = value[i]
                        value[i] = value[j]
                        value[j] = temp
                    }
                }
                shuffle (deck)

                n_hand = [ deck[0], deck[1], deck[2], deck[3], deck[4] ]
                n_tricks = []
                e_hand = [ deck[5], deck[6], deck[7], deck[8], deck[9] ]
                e_tricks = []
                s_hand = [ deck[10], deck[11], deck[12], deck[13], deck[14] ]
                s_tricks = []
                w_hand = [ deck[15], deck[16], deck[17], deck[18], deck[19] ]
                w_tricks = []
                kitty = [ deck[20], deck[21], deck[22], deck[23] ]
                trick = []

                for (var i = 0; i < deck.length; i++)
                    deck[i].facing = false

                function moved5 () {
                    kitty[0].moved.disconnect (moved5)

                    // Show trump
                    console.log (player_name (dealer) + " deals " + kitty[3].number + kitty[3].suit)
                    kitty[3].facing = true

                    // Show hand
                    for (var i = 0; i < s_hand.length; i++)
                        s_hand[i].facing = true

                    // Start ordering
                    phase = "ordering"
                    layout ()
                    next_turn ()
                }
                function moved4 () {
                    player_hand (dealer)[0].moved.disconnect (moved4)

                    // Deal hand to dealer
                    phase = "dealing5"
                    player_hand (dealer)[0].moved.connect (moved4)
                    layout ()
                }
                function moved3 () {
                    player_hand ((dealer + 3) % 4)[0].moved.disconnect (moved3)

                    // Deal kitty
                    phase = "dealing4"
                    kitty[0].moved.connect (moved5)
                    layout ()
                }
                function moved2 () {
                    player_hand ((dealer + 2) % 4)[0].moved.disconnect (moved2)

                    // Deal hand to next player
                    phase = "dealing3"
                    player_hand ((dealer + 3) % 4)[0].moved.connect (moved3)
                    layout ()
                }
                function moved1 () {
                    player_hand ((dealer + 1) % 4)[0].moved.disconnect (moved1)

                    // Deal hand to next player
                    phase = "dealing2"
                    player_hand ((dealer + 2) % 4)[0].moved.connect (moved2)
                    layout ()
                }
                function moved0 () {
                    kitty[3].moved.disconnect (moved0)

                    // Deal hand to left of the dealer
                    phase = "dealing1"
                    player_hand ((dealer + 1) % 4)[0].moved.connect (moved1)
                    layout ()
                }
                // Put cards by dealer
                kitty[3].moved.connect (moved0)

                // Update layout
                layout ()
            }

            function order_dealer () {
                console.log (player_name (current_player) + " orders")
                if (current_player != 0) {
                    if (current_player == dealer)
                        set_prompt (player_name (current_player) + " takes card")
                    else
                        set_prompt (player_name (current_player) + " orders dealer")
                }

                calling_player = current_player
                trump_suit = kitty[3].suit
                trump_label.opacity = 0.25
                trump_label.text = trump_suit
                maker_arrow.opacity = 0.25
                maker_arrow.rotation = 90 * (calling_player + 1)

                phase = "swapping0"

                // If we dealt then choose which card to swap with
                if (dealer == 0) {
                    console.log ("Waiting for south to swap")
                    set_prompt ("Pick card to swap")
                }
                else {
                    function moved1 () {
                        kitty[3].moved.disconnect (moved1)
                        start_round ()
                    }
                    function done () {
                        timer.done.disconnect (done)

                        // Swap cards
                        console.log (player_name (dealer) + " swaps")
                        var card = ai_pick_swap (dealer)
                        if (card != undefined) {
                            var hand = player_hand (dealer)
                            var hand_index = hand.indexOf (card)
                            hand[hand_index] = kitty[3]
                            kitty[3] = card
                            hand[hand_index].facing = false
                        }

                        phase = "swapping1"
                        kitty[3].moved.connect (moved1)
                        layout ()
                    }
                    function moved0 () {
                        kitty[3].moved.disconnect (moved0)

                        // Wait to show swap occurred
                        timer.done.connect (done)
                        timer.restart ()
                    }

                    // Move card to dealers hand
                    kitty[3].moved.connect (moved0)
                }

                layout ()
            }

            function pass_order () {
                console.log (player_name (current_player) + " passes")

                if (current_player == dealer) {
                    console.log ("Calling for suit")
                    phase = "calling"

                    // Turn over card and offer others
                    kitty[3].facing = false
                    for (var i = 0; i < suit_cards.length; i++) {
                        if (suit_cards[i].suit != kitty[3].suit)
                            suit_cards[i].opacity = 1
                    }
                }

                next_turn ()
            }

            function set_trump (suit) {
                if (suit == "") {
                    console.log (player_name (current_player) + " passes")
                    if (current_player == dealer) {
                        for (var i = 0; i < suit_cards.length; i++)
                            suit_cards[i].opacity = 0

                        console.log ("Redeal")
                        dealer = (dealer + 1) % 4
                        deal ()
                    }
                    else
                        next_turn ()
                }
                else {
                    console.log (player_name (current_player) + " picks " + suit + " as trumps")
                    if (current_player != 0)
                        set_prompt (player_name (current_player) + " picks " + suit + " as trumps")
                    trump_label.opacity = 0.25
                    trump_label.text = suit
                    calling_player = current_player
                    trump_suit = suit
                    maker_arrow.opacity = 0.25
                    maker_arrow.rotation = 90 * (calling_player + 1)

                    // Raise the chosen card to the top and fade out the others
                    for (var i = 0; i < suit_cards.length; i++) {
                        if (suit_cards[i].suit == trump_suit) {
                            var t = suit_cards[i].z
                            suit_cards[i].z = suit_cards[suit_cards.length - 1].z
                            suit_cards[suit_cards.length - 1].z = t
                        }
                        else
                            suit_cards[i].opacity = 0
                    }

                    function done () {
                        timer.done.disconnect (done)
                        // Fade out all the cards
                        for (var i = 0; i < suit_cards.length; i++)
                            suit_cards[i].opacity = 0
                        start_round ()
                    }
                    function moved () {
                        trumpSkip.moved.disconnect (moved)

                        if (calling_player != 0) {
                            timer.done.connect (done)
                            timer.restart ()
                        }
                        else
                            done ()
                    }
                    trumpSkip.moved.connect (moved)

                    phase = "calling-done"
                    layout ()
                }
            }

            // Start playing cards in the trick
            function start_round () {
                phase = "playing"
                current_player = dealer
                lead_player = (dealer + 1) % 4
                next_turn ()
                layout ()
            }

            // Get an estimate on the number of tricks we will win
            function ai_get_hand_strength (player, trump_suit) {
                var hand = player_hand (player)
                function have_card (number, suit) {
                    for (var i = 0; i < hand.length; i++)
                        if (hand[i].number == number && hand[i].suit == suit)
                            return true
                    return false
                }
                function suit_count (suit) {
                    var n =  0
                    for (var i = 0; i < hand.length; i++) {
                        var s = hand[i].suit
                        if (hand[i].number == "J" && hand[i].suit == get_off_suit (trump_suit))
                            s = trump_suit
                        if (s == suit)
                            n++
                    }
                    return n
                }

                // FIXME: Should take into account if a card has been turned down (i.e. treat King offsuit as Ace offsuit if Ace was discarded)

                // Count how many consecutive top trumps we have
                var n_top_trumps = 0
                if (have_card ("J", trump_suit)) {
                    n_top_trumps++
                    if (have_card ("J", get_off_suit (trump_suit))) {
                        n_top_trumps++
                        if (have_card ("A", trump_suit)) {
                            n_top_trumps++
                            if (have_card ("K", trump_suit)) {
                                n_top_trumps++
                                if (have_card ("Q", trump_suit))
                                    n_top_trumps++
                            }
                        }
                    }
                }

                // Might get something with other trumps
                var n_other_trumps = suit_count (trump_suit) - n_top_trumps

                // Count how many Ace off-suits we have
                var n_ace_offsuits = 0
                if (trump_suit != "♠" && have_card ("A", "♠"))
                    n_ace_offsuits++
                if (trump_suit != "♣" && have_card ("A", "♣"))
                    n_ace_offsuits++
                if (trump_suit != "♥" && have_card ("A", "♥"))
                    n_ace_offsuits++
                if (trump_suit != "♦" && have_card ("A", "♦"))
                    n_ace_offsuits++

                // Kings and queens might give something if there are other cards to help
                var n_king_offsuits = 0
                if (trump_suit != "♠" && have_card ("K", "♠") && suit_count ("♠") > 1)
                    n_king_offsuits++
                if (trump_suit != "♣" && have_card ("K", "♣") && suit_count ("♣") > 1)
                    n_king_offsuits++
                if (trump_suit != "♥" && have_card ("K", "♥") && suit_count ("♥") > 1)
                    n_king_offsuits++
                if (trump_suit != "♦" && have_card ("K", "♦") && suit_count ("♦") > 1)
                    n_king_offsuits++
                var n_queen_offsuits = 0
                if (trump_suit != "♠" && have_card ("Q", "♠") && suit_count ("♠") > 2)
                    n_queen_offsuits++
                if (trump_suit != "♣" && have_card ("Q", "♣") && suit_count ("♣") > 2)
                    n_queen_offsuits++
                if (trump_suit != "♥" && have_card ("Q", "♥") && suit_count ("♥") > 2)
                    n_queen_offsuits++
                if (trump_suit != "♦" && have_card ("Q", "♦") && suit_count ("♦") > 2)
                    n_queen_offsuits++

                // FIXME: Should simulate and find the best values for these weightings
                return n_top_trumps + n_other_trumps * 0.5 + n_ace_offsuits + n_king_offsuits * 0.5 + n_queen_offsuits * 0.5
            }

            // Return true if the AI will order the dealer
            function ai_will_order (player) {
                // If the dealer is our partner then expect more from then
                // FIXME: Should simulate and find the best values for these weightings
                var partner_n = 0.5
                if (player == (dealer + 2) % 4) {
                    if (kitty[3].number == "J")
                        partner_n = 1.5
                    else
                        partner_n = 0.75
                }

                // Work out how strong we are with this trump
                var hand = player_hand (player)
                var n
                var swap
                var swap_index
                if (player == dealer) {
                    swap = ai_pick_swap (player)
                    if (swap != undefined) {
                        swap_index = hand.indexOf (swap)
                        hand[swap_index] = kitty[3]
                    }
                }
                n = ai_get_hand_strength (player, kitty[3].suit)
                if (swap != undefined)
                    hand[swap_index] = swap

                // Order if we think we can win this round
                return n + partner_n >= 3
            }

            // Pick a card to swap when ordered
            function ai_pick_swap (player) {
                var hand = player_hand (player)
                var swap_card
                var swap_strength = -1
                for (var i = 0; i < hand.length; i++) {
                    // Temporarily swap card
                    var t = hand[i]
                    hand[i] = kitty[3]

                    var s = ai_get_hand_strength (player, "", kitty[3].suit)
                    if (s > swap_strength) {
                        swap_card = t
                        swap_strength = s
                    }

                    // Swap card back
                    hand[i] = t
                }

                return swap_card
            }

            // Pick a trump suit to play as or "" to pass
            function ai_pick_trump (player) {
                // Try each suit and pick the best one
                var trump_suit = ""
                var best_n = 0
                var n = ai_get_hand_strength (player, "♠")
                if (n > best_n) {
                    trump_suit = "♠"
                    best_n = n
                }
                var n = ai_get_hand_strength (player, "♣")
                if (n > best_n) {
                    trump_suit = "♣"
                    best_n = n
                }
                var n = ai_get_hand_strength (player, "♥")
                if (n > best_n) {
                    trump_suit = "♥"
                    best_n = n
                }
                var n = ai_get_hand_strength (player, "♦")
                if (n > best_n) {
                    trump_suit = "♦"
                    best_n = n
                }

                // FIXME: Should take into account what their opponent has done

                // Pick one we think can win with
                var partner_n = 0.5
                if (best_n + partner_n >= 3)
                    return trump_suit
                else
                    return ""
            }

            // Pick a card for the AI to play
            function ai_pick_card (player) {
                var hand = player_hand (player)

                // Lead with the highest off-suit, or trump if that's all you have!
                if (trick.length == 0) {
                    // FIXME: Take into account which cards have been played, i.e. King might be the highest
                    // FIXME: Pick between suits based on if they have been led, and if you can de-suit
                    var highest_trump
                    var highest_trump_value = -1
                    var highest_non_trump
                    var highest_non_trump_value = -1
                    for (var i = 0; i < hand.length; i++) {
                        var card = hand[i]
                        var v = get_card_value (card)
                        if (is_trump (card)) {
                            if (v > highest_trump_value) {
                                highest_trump = card
                                highest_trump_value = v
                            }
                        }
                        else {
                            if (v > highest_non_trump_value) {
                                highest_non_trump = card
                                highest_non_trump_value = v
                            }
                        }
                    }
                    if (highest_non_trump != undefined)
                        return highest_non_trump
                    else
                        return highest_trump
                }

                // Work out which cards are playable (follow suit or anything)
                var playable_cards = []
                var lead_suit = get_suit (trick[0])
                for (var i = 0; i < hand.length; i++)
                    if (get_suit (hand[i]) == lead_suit)
                        playable_cards.push (hand[i])
                if (playable_cards.length == 0)
                    playable_cards = hand

                var winning_card = get_winning_card ()
                var winning_card_value = get_card_value (winning_card)

                // Work out various useful cards we can play
                var lowest_in_suit
                var lowest_in_suit_value = 8
                var lowest_winning
                var lowest_winning_value = 8
                var highest_winning
                var highest_winning_value = -1
                var lowest_trump
                var lowest_trump_value = 8
                var lowest_non_trump
                var lowest_non_trump_value = 8
                for (var i = 0; i < playable_cards.length; i++) {
                    var card = playable_cards[i]
                    var v = get_card_value (card)

                    if (get_suit (card) == lead_suit) {
                        if (v < lowest_in_suit_value) {
                            lowest_in_suit = card
                            lowest_in_suit_value = v
                        }
                    }

                    if (get_suit (card) == get_suit (winning_card) && v > winning_card_value) {
                        if (v < lowest_winning_value) {
                            lowest_winning = card
                            lowest_winning_value = v
                        }
                        if (v > highest_winning_value) {
                            highest_winning = card
                            highest_winning_value = v
                        }
                    }

                    if (is_trump (card)) {
                        if (v < lowest_trump_value) {
                            lowest_trump = card
                            lowest_trump_value = v
                        }
                    }
                    else {
                        if (v < lowest_non_trump_value) {
                            lowest_non_trump = card
                            lowest_non_trump_value = v
                        }
                    }
                }

                // Can only trump if we can't follow suit
                var lowest_winning_trump
                if (lowest_in_suit == undefined && !is_trump (winning_card))
                    lowest_winning_trump = lowest_trump

                // Get the card we should throw away if can't do anything
                // FIXME: Should try to de-suit
                var discard = lowest_non_trump
                if (discard == undefined)
                    discard = lowest_trump

                // Following opponent - play highest card in that suit or lowest trump
                // FIXME: Shouldn't play a high card if we think it will be more useful later
                if (trick.length == 1) {
                    if (highest_winning != undefined)
                        return highest_winning
                    else if (lowest_winning_trump != undefined)
                        return lowest_winning_trump
                    else
                        return discard
                }

                // Following partner, win if they haven't, otherwise play lowest card
                if (trick.length == 2) {
                    // FIXME: They might be winning but need us to play higher
                    var partner_won = trick[0] == winning_card
                    if (partner_won) {
                        if (lowest_in_suit != undefined)
                            return lowest_in_suit
                        else
                            return discard
                    }
                    else {
                        if (highest_winning != undefined)
                            return highest_winning
                        else if (lowest_winning_trump != undefined)
                            return lowest_winning_trump
                        else
                            return discard
                    }
                }

                // Ending trick, if partner is winning play lowest card, otherwise win with with lowest possible card
                if (trick.length == 3) {
                    var partner_won = trick[1] == winning_card
                    if (partner_won) {
                        if (lowest_in_suit != undefined)
                            return lowest_in_suit
                        else
                            return discard
                    }
                    else {
                        if (lowest_winning != undefined)
                            return lowest_winning
                        if (lowest_winning_trump != undefined)
                            return lowest_winning_trump
                        else
                            return discard
                    }
                }
            }

            // Play the given card
            function play_card (card) {
                function moved () {
                    card.moved.disconnect (moved)

                    if (trick.length == 4)
                        end_trick ()
                    else
                        next_turn ()
                }
                card.moved.connect (moved)
                card.facing = true
                trick.push (card)
                layout ()
            }

            function end_trick () {
                // End trick
                function moved1 () {
                    var tricks = player_tricks (lead_player)
                    tricks[tricks.length - 1][0].moved.disconnect (moved1)

                    if (s_hand.length == 0) {
                        console.log ("Hand complete")

                        // Show labels
                        ns_score_label.opacity = 0.25
                        ew_score_label.opacity = 0.25

                        // Work out winner and points won
                        var ns_tricks = n_tricks.length + s_tricks.length
                        var ew_tricks = e_tricks.length + w_tricks.length
                        if (ns_tricks > ew_tricks) {
                            console.log ("North-South team wins hand " + ns_tricks + "-" + ew_tricks)
                            if (calling_player == 0 || calling_player == 2) {
                                if (ns_tricks == 5)
                                    ns_score += 2
                                else
                                    ns_score += 1
                            }
                            else
                                ns_score += 2
                            ns_score_label.pulse ()
                        }
                        else {
                            console.log ("East-West team wins hand " + ew_tricks + "-" + ns_tricks)
                            if (calling_player == 1 || calling_player == 3) {
                                if (ew_tricks == 5)
                                    ew_score += 2
                                else
                                    ew_score += 1
                            }
                            else
                                ew_score += 2
                            ew_score_label.pulse ()
                        }

                        // Update score labels
                        ns_score_label.text = ns_score
                        ew_score_label.text = ew_score

                        if (ns_score >= 10 || ew_score >= 10) {
                            console.log ("Game over")
                            if (ns_score > ew_score)
                                set_prompt ("You win!")
                            else
                                set_prompt ("You lose")
                            phase = "complete"
                            layout ()
                        }
                        else {
                            dealer = (dealer + 1) % 4
                            deal ()
                        }
                    }
                    else {
                        // Start new trick with this winner
                        phase = "playing"
                        current_player = lead_player - 1
                        next_turn ()
                    }
                    layout ()
                }
                function done () {
                    timer.done.disconnect (done)

                    phase = "collecting-trick"

                    // Turn over card
                    for (var i = 0; i < trick.length; i++)
                        trick[i].facing = false

                    // Give trick to winner
                    var winner = trick_winner ()
                    if (winner == 0)
                        s_tricks.push (trick)
                    else if (winner == 1)
                        w_tricks.push (trick)
                    else if (winner == 2)
                        n_tricks.push (trick)
                    else if (winner == 3)
                        e_tricks.push (trick)
                    trick = []
                    lead_player = winner

                    // Move the trick to the winner
                    var tricks = player_tricks (lead_player)
                    tricks[tricks.length - 1][0].moved.connect (moved1)
                    layout ()
                }
                function moved0 () {
                    trick[0].moved.disconnect (moved0)

                    // Work out the winner
                    var winner = trick_winner ()
                    console.log (player_name (winner) + " wins trick")

                    // Wait to show result
                    if (current_player == 0)
                        done ()
                    else {
                        timer.done.connect (done)
                        timer.restart ()
                    }
                }
                trick[0].moved.connect (moved0)
                layout ()
            }

            // Set a prompt message
            function set_prompt (text) {
                prompt_label.text = text
                prompt_label.color = "white"
                prompt_label.opacity = 1
            }

            // Set an error message
            function set_error (text) {
                prompt_label.text = text
                prompt_label.color = "red"
                prompt_label.opacity = 1
            }

            // Clear prompt/error message
            function clear_prompt ()
            {
                prompt_label.opacity = 0
            }

            // Handle a card being clicked
            function on_select_card (number, suit) {
                // Restart by clicking any card
                if (phase == "complete") {
                    start_game ()
                    return
                }

                // Work out what card this is - QML doesn't seem to be able to give me the object that generated the signal!?
                var card
                for (var i = 0; i < deck.length; i++)
                    if (deck[i].number == number && deck[i].suit == suit)
                        card = deck[i]

                if (phase == "ordering-human") {
                    clear_prompt ()
                    if (card == kitty[3]) {
                        pass_button.opacity = 0
                        order_dealer ()
                    }
                }
                else if (phase == "swapping0") {
                    // Must be a card in our hand
                    if (s_hand.indexOf (card) < 0)
                        return

                    console.log ("South swaps")
                    clear_prompt ()

                    // Swap cards
                    var hand_index = s_hand.indexOf (card)
                    s_hand[hand_index] = kitty[3]
                    kitty[3] = card

                    // Turn over the card we swapped
                    card.facing = false

                    // Move cards
                    layout ()

                    // Start playing
                    start_round ()
                }
                else if (phase == "playing-human") {
                    // Must be a card in our hand
                    if (s_hand.indexOf (card) < 0)
                        return

                    // Must follow suit
                    var playable_cards = []
                    if (trick.length > 0) {
                        var lead_suit = get_suit (trick[0])
                        for (var i = 0; i < s_hand.length; i++)
                            if (get_suit (s_hand[i]) == lead_suit)
                                playable_cards.push (s_hand[i])
                    }
                    if (playable_cards.length > 0 && playable_cards.indexOf (card) < 0) {
                        set_error ("Must follow suit")
                        card.shake ()
                        return
                    }

                    console.log ("South plays " + card.number + card.suit)
                    clear_prompt ()
                    phase = "playing"
                    play_card (card)
                    s_hand.splice (s_hand.indexOf (card), 1)
                    layout ()
                }
            }

            // Handle the suit being selected
            function on_pass () {
                // Only allow calling when in human turn
                if (phase != "ordering-human")
                    return

                phase = "ordering"
                pass_button.opacity = 0
                clear_prompt ()
                pass_order ()
            }

            // Handle the suit being selected
            function on_select_suit (number, suit) {
                // Only allow calling when in human turn
                if (phase != "calling-human")
                    return

                phase = "calling"
                clear_prompt ()
                set_trump (suit)
            }

            // Get the suit that contains the left bower
            function get_off_suit (suit) {
                if (suit == "♠")
                    return "♣"
                if (suit == "♣")
                    return "♠"
                if (suit == "♥")
                    return "♦"
                if (suit == "♦")
                    return "♥"
            }

            // Get the suit of a card taking into account bowers
            function get_suit (card) {
                if (card.suit == get_off_suit (trump_suit) && card.number == "J")
                    return trump_suit
                return card.suit
            }

            // Return true if the card has the given suit
            function is_suit (card, suit) {
                return get_suit (card) == suit
            }

            // Return true if the card is a trump
            function is_trump (card) {
                return get_suit (card) == trump_suit
            }

            // Get the value of a card within it's own suit
            function get_card_value (card) {
                if (card.number == "9")
                    return 0
                if (card.number == "10")
                    return 1
                if (card.number == "J")
                {
                    // Right bower
                    if (card.suit == trump_suit)
                        return 7

                    // Left bower
                    if (card.suit == get_off_suit (trump_suit))
                        return 6

                    // Plain old Jack
                    return 2
                }
                if (card.number == "Q")
                    return 3
                if (card.number == "K")
                    return 4
                if (card.number == "A")
                    return 5

                return -1
            }

            // Start the next turn
            function next_turn () {
                current_player = (current_player + 1) % 4

                if (phase == "ordering")
                    next_turn_order ()
                else if (phase == "calling")
                    next_turn_calling ()
                else if (phase == "playing")
                    next_turn_playing ()
            }

            // Start a turn in the order phase
            function next_turn_order () {
                if (current_player == 0) {
                    // Prompt user to select trump
                    console.log ("Waiting for South to order")
                    if (current_player == dealer)
                        set_prompt ("Take card?")
                    else
                        set_prompt ("Order dealer?")
                    phase = "ordering-human"
                    pass_button.opacity = 1
                    layout ()
                }
                else {
                    var hand = player_hand (current_player)
                    var card = hand[2]
                    function moved () {
                        card.moved.disconnect (moved)

                        // AI chooses if it wants to order the dealer
                        phase = "ordering"
                        if (ai_will_order (current_player))
                            order_dealer ()
                        else
                            pass_order ()
                    }
                    card.moved.connect (moved)
                    phase = "ordering-ai"
                    layout ()
                }
            }

            // Start a turn in the calling phase
            function next_turn_calling () {
                if (current_player == 0) {
                    // Show suit cards to pick from
                    console.log ("Waiting for South to pick a suit")
                    set_prompt ("Pick trump suit")
                    phase = "calling-human"
                    layout ()
                }
                else {
                    var hand = player_hand (current_player)
                    var card = hand[2]
                    function moved () {
                        card.moved.disconnect (moved)

                        // AI chooses if it wants to order the dealer
                        phase = "calling"
                        var suit = ai_pick_trump (current_player)
                        set_trump (suit)
                    }
                    card.moved.connect (moved)

                    phase = "calling-ai"
                    layout ()
                }
            }

            // Get the winning card from the current trick
            function get_winning_card () {
                function compare_card (card0, card1, lead_suit) {
                    if (get_suit (card0) != get_suit (card1))
                    {
                        // Trumps beat non-trumps
                        if (is_suit (card0, trump_suit))
                            return 1
                        if (is_suit (card1, trump_suit))
                            return -1

                        // Lead suit beats off-suit
                        if (is_suit (card0, lead_suit))
                            return 1
                        if (is_suit (card1, lead_suit))
                            return -1
                    }

                    return get_card_value (card0) - get_card_value (card1)
                }
                var lead_suit = trick[0].suit
                var best_card = 0
                for (var i = 1; i < trick.length; i++)
                    if (compare_card (trick[i], trick[best_card], lead_suit, trump_suit) > 0)
                        best_card = i

                return trick[best_card]
            }

            // Get the player currently winning the trick
            function trick_winner () {
                var card = get_winning_card ()
                return (lead_player + trick.indexOf (card)) % 4
            }

            // Start a turn in the playing phase
            function next_turn_playing () {
                if (current_player == 0) {
                    console.log ("Waiting for South to move")
                    set_prompt ("Play card")
                    phase = "playing-human"
                }
                else {
                    // FIXME: Pretend to be thinking
                    var card = ai_pick_card (current_player)
                    console.log (player_name (current_player) + " plays " + card.number + card.suit)
                    play_card (card)
                    var hand = player_hand (current_player)
                    hand.splice (hand.indexOf (card), 1)
                }
            }
        }
    }
}