| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "sort" |
| |
| "hearts/direction" |
| "hearts/img/reposition" |
| "hearts/img/staticimg" |
| "hearts/img/texture" |
| "hearts/logic/card" |
| "hearts/logic/table" |
| |
| "golang.org/x/mobile/exp/f32" |
| "golang.org/x/mobile/exp/sprite" |
| ) |
| |
| func loadOpeningView(t *table.Table) { |
| view = Opening |
| scene = &sprite.Node{} |
| eng.Register(scene) |
| eng.SetTransform(scene, f32.Affine{ |
| {1, 0, 0}, |
| {0, 1, 0}, |
| }) |
| texs := texture.LoadTextures(eng) |
| buttonX := (windowSize.X - cardDim.X) / 2 |
| tableButtonY := (windowSize.Y - 2*cardDim.Y - padding) / 2 |
| passButtonY := (windowSize.Y-2*cardDim.Y-padding)/2 + cardDim.Y + padding |
| tableButtonXY := card.MakeVec(buttonX, tableButtonY) |
| passButtonXY := card.MakeVec(buttonX, passButtonY) |
| tableButtonPos := card.MakePosition(tableButtonXY, tableButtonXY, cardDim) |
| passButtonPos := card.MakePosition(passButtonXY, passButtonXY, cardDim) |
| tableButtonImage := texs["BakuSquare.png"] |
| passButtonImage := texs["Clubs-2.png"] |
| tableButton := texture.MakeImgWithAlt(tableButtonImage, tableButtonImage, tableButtonPos, true, eng, scene) |
| passButton := texture.MakeImgWithAlt(passButtonImage, passButtonImage, passButtonPos, true, eng, scene) |
| buttons = append(buttons, tableButton) |
| buttons = append(buttons, passButton) |
| } |
| |
| func loadTableView(t *table.Table) { |
| view = Table |
| cards = make([]*card.Card, 0) |
| backgroundImgs = make([]*staticimg.StaticImg, 0) |
| emptySuitImgs = make([]*staticimg.StaticImg, 0) |
| dropTargets = make([]*staticimg.StaticImg, 0) |
| buttons = make([]*staticimg.StaticImg, 0) |
| scene = &sprite.Node{} |
| eng.Register(scene) |
| eng.SetTransform(scene, f32.Affine{ |
| {1, 0, 0}, |
| {0, 1, 0}, |
| }) |
| texs := texture.LoadTextures(eng) |
| // adding four drop targets for trick |
| dropTargetImage := texs["trickDrop.png"] |
| dropTargetDimensions := cardDim |
| dropTargetX := (windowSize.X - cardDim.X) / 2 |
| var dropTargetY float32 |
| if windowSize.X < windowSize.Y { |
| dropTargetY = windowSize.Y/2 + cardDim.Y/2 + padding |
| } else { |
| dropTargetY = windowSize.Y/2 + padding |
| } |
| dropTargetXY := card.MakeVec(dropTargetX, dropTargetY) |
| dropTargetPos := card.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions) |
| dropTarget := texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, eng, scene) |
| dropTargets = append(dropTargets, dropTarget) |
| // second drop target |
| dropTargetY = (windowSize.Y - cardDim.Y) / 2 |
| if windowSize.X < windowSize.Y { |
| dropTargetX = windowSize.X/2 - cardDim.X - padding |
| } else { |
| dropTargetX = windowSize.X/2 - 3*cardDim.X/2 - padding |
| } |
| dropTargetXY = card.MakeVec(dropTargetX, dropTargetY) |
| dropTargetPos = card.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions) |
| dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, eng, scene) |
| dropTargets = append(dropTargets, dropTarget) |
| // third drop target |
| dropTargetX = (windowSize.X - cardDim.X) / 2 |
| if windowSize.X < windowSize.Y { |
| dropTargetY = windowSize.Y/2 - 3*cardDim.Y/2 - padding |
| } else { |
| dropTargetY = windowSize.Y/2 - padding - cardDim.Y |
| } |
| dropTargetXY = card.MakeVec(dropTargetX, dropTargetY) |
| dropTargetPos = card.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions) |
| dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, eng, scene) |
| dropTargets = append(dropTargets, dropTarget) |
| // fourth drop target |
| dropTargetY = (windowSize.Y - cardDim.Y) / 2 |
| if windowSize.X < windowSize.Y { |
| dropTargetX = windowSize.X/2 + padding |
| } else { |
| dropTargetX = windowSize.X/2 + cardDim.X/2 + padding |
| } |
| dropTargetXY = card.MakeVec(dropTargetX, dropTargetY) |
| dropTargetPos = card.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions) |
| dropTarget = texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, eng, scene) |
| dropTargets = append(dropTargets, dropTarget) |
| overlap := 3 * tableCardDim.X / 4 |
| // adding 4 player icons and device icons |
| playerIconImage := texs["player0.jpeg"] |
| playerIconDimensions := cardDim |
| playerIconX := (windowSize.X-cardDim.X)/2 |
| playerIconY := windowSize.Y-tableCardDim.Y-bottomPadding-padding-cardDim.Y |
| playerIconXY := card.MakeVec(playerIconX, playerIconY) |
| playerIconPos := card.MakePosition(playerIconXY, playerIconXY, playerIconDimensions) |
| playerIcon := texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, playerIcon) |
| // player 0's device icon |
| deviceIconImage := texs["phoneIcon.png"] |
| deviceIconDimensions := card.MakeVec(playerIconDimensions.X/4, playerIconDimensions.Y/4) |
| addPlayerDeviceIcon(deviceIconImage, deviceIconDimensions, playerIconXY, playerIconDimensions) |
| // player 1's icon |
| playerIconImage = texs["player1.jpeg"] |
| playerIconX = bottomPadding |
| playerIconY = (windowSize.Y+2*bottomPadding+cardDim.Y-(float32(len(t.GetPlayers()[1].GetHand()))*(tableCardDim.Y-overlap)+tableCardDim.Y))/2-cardDim.Y-padding |
| playerIconXY = card.MakeVec(playerIconX, playerIconY) |
| playerIconPos = card.MakePosition(playerIconXY, playerIconXY, playerIconDimensions) |
| playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, playerIcon) |
| // player 1's device icon |
| deviceIconImage = texs["tabletIcon.png"] |
| addPlayerDeviceIcon(deviceIconImage, deviceIconDimensions, playerIconXY, playerIconDimensions) |
| // player 2's icon |
| playerIconImage = texs["player2.jpeg"] |
| playerIconX = (windowSize.X - cardDim.X) / 2 |
| playerIconY = topPadding + tableCardDim.Y + padding |
| playerIconXY = card.MakeVec(playerIconX, playerIconY) |
| playerIconPos = card.MakePosition(playerIconXY, playerIconXY, playerIconDimensions) |
| playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, playerIcon) |
| // player 2's device icon |
| deviceIconImage = texs["watchIcon.png"] |
| addPlayerDeviceIcon(deviceIconImage, deviceIconDimensions, playerIconXY, playerIconDimensions) |
| // player 3's icon |
| playerIconImage = texs["player3.jpeg"] |
| playerIconX = windowSize.X - bottomPadding - cardDim.X |
| playerIconY = (windowSize.Y+2*bottomPadding+cardDim.Y-(float32(len(t.GetPlayers()[3].GetHand()))*(tableCardDim.Y-overlap)+tableCardDim.Y))/2 - cardDim.Y - padding |
| playerIconXY = card.MakeVec(playerIconX, playerIconY) |
| playerIconPos = card.MakePosition(playerIconXY, playerIconXY, playerIconDimensions) |
| playerIcon = texture.MakeImgWithoutAlt(playerIconImage, playerIconPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, playerIcon) |
| // player 3's device icon |
| deviceIconImage = texs["laptopIcon.png"] |
| addPlayerDeviceIcon(deviceIconImage, deviceIconDimensions, playerIconXY, playerIconDimensions) |
| // adding cards |
| for _, p := range t.GetPlayers() { |
| hand := p.GetHand() |
| for i, c := range hand { |
| texture.PopulateCardImage(c, texs, eng, scene) |
| cardIndex := card.MakeVec(float32(len(hand)), float32(i)) |
| paddingVec := card.MakeVec(topPadding, bottomPadding) |
| reposition.SetCardPositionTable(c, p.GetPlayerIndex(), cardIndex, paddingVec, windowSize, tableCardDim, cardScaler, overlap, eng, scene) |
| eng.SetSubTex(c.GetNode(), c.GetBack()) |
| cards = append(cards, c) |
| } |
| } |
| } |
| |
| func addPlayerDeviceIcon(deviceIconImage sprite.SubTex, deviceIconDimensions card.Vec, playerIconXY card.Vec, playerIconDimensions card.Vec) { |
| deviceIconX := playerIconXY.X+playerIconDimensions.X-deviceIconDimensions.X/2 |
| deviceIconY := playerIconXY.Y+playerIconDimensions.Y-deviceIconDimensions.Y/2 |
| deviceIconXY := card.MakeVec(deviceIconX, deviceIconY) |
| deviceIconPos := card.MakePosition(deviceIconXY, deviceIconXY, deviceIconDimensions) |
| deviceIcon := texture.MakeImgWithoutAlt(deviceIconImage, deviceIconPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, deviceIcon) |
| } |
| |
| func loadPassView(t *table.Table) { |
| view = Pass |
| cards = make([]*card.Card, 0) |
| backgroundImgs = make([]*staticimg.StaticImg, 0) |
| emptySuitImgs = make([]*staticimg.StaticImg, 0) |
| dropTargets = make([]*staticimg.StaticImg, 0) |
| buttons = make([]*staticimg.StaticImg, 0) |
| numSuits := 4 |
| numDropTargets := 3 |
| scene = &sprite.Node{} |
| eng.Register(scene) |
| eng.SetTransform(scene, f32.Affine{ |
| {1, 0, 0}, |
| {0, 1, 0}, |
| }) |
| cards = t.GetPlayers()[1].GetHand() |
| sort.Sort(card.CardSorter(cards)) |
| clubCount := 0 |
| diamondCount := 0 |
| spadeCount := 0 |
| heartCount := 0 |
| for i := 0; i < len(cards); i++ { |
| switch cards[i].GetSuit() { |
| case card.Club: |
| clubCount++ |
| case card.Diamond: |
| diamondCount++ |
| case card.Spade: |
| spadeCount++ |
| case card.Heart: |
| heartCount++ |
| } |
| } |
| suitCounts := []int{clubCount, diamondCount, spadeCount, heartCount} |
| texs := texture.LoadTextures(eng) |
| // adding blue banner for croupier header |
| headerImage := texs["blue.png"] |
| headerXY := card.MakeVec(0, 0) |
| headerWidth := windowSize.X |
| var headerHeight float32 |
| if 2*cardDim.Y < headerWidth/4 { |
| headerHeight = 2 * cardDim.Y |
| } else { |
| headerHeight = headerWidth / 4 |
| } |
| headerDimensions := card.MakeVec(headerWidth, headerHeight) |
| headerPos := card.MakePosition(headerXY, headerXY, headerDimensions) |
| header := texture.MakeImgWithoutAlt(headerImage, headerPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, header) |
| // adding croupier name on top of banner |
| headerTextImage := texs["croupierName.png"] |
| var headerTextWidth float32 |
| var headerTextHeight float32 |
| if headerHeight-topPadding > headerWidth/6 { |
| headerTextWidth = headerWidth / 2 |
| headerTextHeight = headerTextWidth / 3 |
| } else { |
| headerTextHeight = 2 * headerHeight / 3 |
| headerTextWidth = headerTextHeight * 3 |
| } |
| headerTextX := headerXY.X + (headerWidth-headerTextWidth)/2 |
| headerTextY := headerXY.Y + (headerHeight-headerTextHeight+topPadding)/2 |
| headerTextXY := card.MakeVec(headerTextX, headerTextY) |
| headerTextDimensions := card.MakeVec(headerTextWidth, headerTextHeight) |
| headerTextPos := card.MakePosition(headerTextXY, headerTextXY, headerTextDimensions) |
| headerText := texture.MakeImgWithoutAlt(headerTextImage, headerTextPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, headerText) |
| // adding blue background banner for drop targets |
| topOfHand := windowSize.Y - 5*(cardDim.Y+padding) - (2 * padding / 5) - bottomPadding |
| passBannerImage := texs["blue.png"] |
| passBannerX := float32(0) |
| passBannerY := topOfHand - (2 * padding) |
| passBannerWidth := windowSize.X |
| passBannerHeight := cardDim.Y + (4 * padding / 5) |
| passBannerXY := card.MakeVec(passBannerX, passBannerY) |
| passBannerDimensions := card.MakeVec(passBannerWidth, passBannerHeight) |
| passBannerPos := card.MakePosition(passBannerXY, passBannerXY, passBannerDimensions) |
| passBanner := texture.MakeImgWithoutAlt(passBannerImage, passBannerPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, passBanner) |
| // adding drop targets |
| dropTargetImage := texs["white.png"] |
| dropTargetDimensions := cardDim |
| dropTargetY := passBannerY + (2 * padding / 5) |
| for i := 0; i < numDropTargets; i++ { |
| dropTargetX := windowSize.X/2 - (dropTargetDimensions.X+float32(numDropTargets)*(padding+dropTargetDimensions.X))/2 + float32(i)*(padding+dropTargetDimensions.X) |
| dropTargetXY := card.MakeVec(dropTargetX, dropTargetY) |
| dropTargetPos := card.MakePosition(dropTargetXY, dropTargetXY, dropTargetDimensions) |
| newTarget := texture.MakeImgWithoutAlt(dropTargetImage, dropTargetPos, eng, scene) |
| dropTargets = append(dropTargets, newTarget) |
| } |
| // adding pass button |
| pressedImg := texs["passPressed.png"] |
| unpressedImg := texs["passUnpressed.png"] |
| buttonWidth := cardDim.X |
| buttonHeight := cardDim.Y / 2 |
| buttonDimensions := card.MakeVec(buttonWidth, buttonHeight) |
| buttonX := windowSize.X/2 + (float32(numDropTargets)*(padding+buttonWidth)-buttonWidth)/2 |
| buttonY := passBannerY + (2 * padding / 5) |
| buttonXY := card.MakeVec(buttonX, buttonY) |
| buttonPos := card.MakePosition(buttonXY, buttonXY, buttonDimensions) |
| button := texture.MakeImgWithAlt(unpressedImg, pressedImg, buttonPos, true, eng, scene) |
| buttons = append(buttons, button) |
| // adding arrow below pass button |
| var arrow *staticimg.StaticImg |
| if dir == direction.Right { |
| arrowImage := texs["rightArrow.png"] |
| arrowWidth := cardDim.X |
| arrowHeight := cardDim.Y / 2 |
| arrowX := windowSize.X/2 + (float32(numDropTargets)*(padding+buttonWidth)-arrowWidth)/2 |
| arrowY := buttonY + cardDim.Y/2 |
| arrowXY := card.MakeVec(arrowX, arrowY) |
| arrowDimensions := card.MakeVec(arrowWidth, arrowHeight) |
| arrowPos := card.MakePosition(arrowXY, arrowXY, arrowDimensions) |
| arrow = texture.MakeImgWithoutAlt(arrowImage, arrowPos, eng, scene) |
| } else if dir == direction.Left { |
| arrowImage := texs["leftArrow.png"] |
| arrowWidth := cardDim.X |
| arrowHeight := cardDim.Y / 2 |
| arrowX := windowSize.X/2 + (float32(numDropTargets)*(padding+buttonWidth)-arrowWidth)/2 |
| arrowY := buttonY + cardDim.Y/2 |
| arrowXY := card.MakeVec(arrowX, arrowY) |
| arrowDimensions := card.MakeVec(arrowWidth, arrowHeight) |
| arrowPos := card.MakePosition(arrowXY, arrowXY, arrowDimensions) |
| arrow = texture.MakeImgWithoutAlt(arrowImage, arrowPos, eng, scene) |
| } else if dir == direction.Across { |
| arrowImage := texs["acrossArrow.png"] |
| arrowWidth := cardDim.X / 4 |
| arrowHeight := cardDim.Y / 2 |
| arrowX := windowSize.X/2 + (float32(numDropTargets)*(padding+buttonWidth)-arrowWidth)/2 |
| arrowY := buttonY + cardDim.Y/2 |
| arrowXY := card.MakeVec(arrowX, arrowY) |
| arrowDimensions := card.MakeVec(arrowWidth, arrowHeight) |
| arrowPos := card.MakePosition(arrowXY, arrowXY, arrowDimensions) |
| arrow = texture.MakeImgWithoutAlt(arrowImage, arrowPos, eng, scene) |
| } |
| backgroundImgs = append(backgroundImgs, arrow) |
| // adding gray background banners for each suit |
| suitBannerImage := texs["gray.jpeg"] |
| suitBannerX := float32(0) |
| suitBannerWidth := windowSize.X |
| suitBannerHeight := cardDim.Y + (4 * padding / 5) |
| suitBannerDimensions := card.MakeVec(suitBannerWidth, suitBannerHeight) |
| for i := 0; i < numSuits; i++ { |
| suitBannerY := windowSize.Y - float32(i+1)*(cardDim.Y+padding) - (2 * padding / 5) - bottomPadding |
| suitBannerXY := card.MakeVec(suitBannerX, suitBannerY) |
| suitBannerPos := card.MakePosition(suitBannerXY, suitBannerXY, suitBannerDimensions) |
| suitBanner := texture.MakeImgWithoutAlt(suitBannerImage, suitBannerPos, eng, scene) |
| backgroundImgs = append(backgroundImgs, suitBanner) |
| } |
| // adding suit image to any empty suit in hand |
| for i, c := range suitCounts { |
| var texKey string |
| switch i { |
| case 0: |
| texKey = "Club.png" |
| case 1: |
| texKey = "Diamond.png" |
| case 2: |
| texKey = "Spade.png" |
| case 3: |
| texKey = "Heart.png" |
| } |
| suitIconImage := texs[texKey] |
| suitIconAlt := texs["gray.png"] |
| suitIconX := windowSize.X/2 - cardDim.X/3 |
| suitIconY := windowSize.Y - float32(4-i)*(cardDim.Y+padding) + cardDim.Y/6 - bottomPadding |
| suitIconWidth := 2 * cardDim.X / 3 |
| suitIconHeight := 2 * cardDim.Y / 3 |
| display := c == 0 |
| suitIconXY := card.MakeVec(suitIconX, suitIconY) |
| suitIconDimensions := card.MakeVec(suitIconWidth, suitIconHeight) |
| suitIconPos := card.MakePosition(suitIconXY, suitIconXY, suitIconDimensions) |
| suitIcon := texture.MakeImgWithAlt(suitIconImage, suitIconAlt, suitIconPos, display, eng, scene) |
| emptySuitImgs = append(emptySuitImgs, suitIcon) |
| } |
| paddingVec := card.MakeVec(padding, bottomPadding) |
| // adding clubs |
| for i := 0; i < clubCount; i++ { |
| numInSuit := i |
| texture.PopulateCardImage(cards[i], texs, eng, scene) |
| reposition.SetCardPositionHand(cards[i], numInSuit, suitCounts, cardDim, paddingVec, windowSize, eng, scene) |
| } |
| // adding diamonds |
| for i := clubCount; i < clubCount+diamondCount; i++ { |
| numInSuit := i - clubCount |
| texture.PopulateCardImage(cards[i], texs, eng, scene) |
| reposition.SetCardPositionHand(cards[i], numInSuit, suitCounts, cardDim, paddingVec, windowSize, eng, scene) |
| } |
| // adding spades |
| for i := clubCount + diamondCount; i < clubCount+diamondCount+spadeCount; i++ { |
| numInSuit := i - clubCount - diamondCount |
| texture.PopulateCardImage(cards[i], texs, eng, scene) |
| reposition.SetCardPositionHand(cards[i], numInSuit, suitCounts, cardDim, paddingVec, windowSize, eng, scene) |
| } |
| // adding hearts |
| for i := clubCount + diamondCount + spadeCount; i < clubCount+diamondCount+spadeCount+heartCount; i++ { |
| numInSuit := i - clubCount - diamondCount - spadeCount |
| texture.PopulateCardImage(cards[i], texs, eng, scene) |
| reposition.SetCardPositionHand(cards[i], numInSuit, suitCounts, cardDim, paddingVec, windowSize, eng, scene) |
| } |
| } |
