func ResetAnims(u *uistate.UIState) {
for _, ch := range u.AnimChans {
ch <- true
}
u.SwitchingViews = false
u.AnimChans = make([]chan bool, 0)
}
func beginClickSplit(t touch.Event, u *uistate.UIState) {
u.CurCard = findClickedCard(t, u)
if u.CurCard != nil {
reposition.BringNodeToFront(u.CurCard.GetNode(), u)
}
buttonList := findClickedButton(t, u)
for _, b := range buttonList {
if b == u.Buttons["toggleSplit"] && !u.SwitchingViews {
ch := make(chan bool)
u.SwitchingViews = true
reposition.AnimateOutSplit(ch, u)
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
u.SwitchingViews = false
if u.CurView == uistate.Split {
view.LoadPlayView(false, u)
}
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
} else if b == u.Buttons["takeTrick"] {
pressButton(b, u)
} else {
handleDebugButtonClick(b, u)
}
}
}
func onStop(u *uistate.UIState) {
u.Eng.Release()
fps.Release()
u.Images.Release()
sound.ClosePlayers(u)
u.Done = true
u.Shutdown()
}
// Creates a new gamelog syncgroup
func CreateLogSyncgroup(u *uistate.UIState) (string, string) {
fmt.Println("Creating Log Syncgroup")
u.IsOwner = true
// Generate random gameID information to advertise this game
gameID := rand.Intn(1000000)
u.GameID = gameID
gameMap := make(map[string]interface{})
gameMap["type"] = "Hearts"
gameMap["playerNumber"] = 0
gameMap["gameID"] = gameID
gameMap["ownerID"] = util.UserID
value, err := json.Marshal(gameMap)
if err != nil {
fmt.Println("WE HAVE A HUGE PROBLEM:", err)
}
// Create gamelog syncgroup
logSGName := fmt.Sprintf("%s/croupier/%s/%%%%sync/gaming-%d", util.MountPoint, util.SBName, gameID)
allAccess := access.AccessList{In: []security.BlessingPattern{"..."}}
permissions := access.Permissions{
"Admin": allAccess,
"Write": allAccess,
"Read": allAccess,
"Resolve": allAccess,
"Debug": allAccess,
}
logPref := wire.TableRow{util.LogName, fmt.Sprintf("%d", u.GameID)}
logPrefs := []wire.TableRow{logPref}
tables := []string{util.MountPoint + "/croupier"}
logSpec := wire.SyncgroupSpec{
Description: "croupier syncgroup",
Perms: permissions,
Prefixes: logPrefs,
MountTables: tables,
IsPrivate: false,
}
myInfoCreator := wire.SyncgroupMemberInfo{8, true}
app := u.Service.App(util.AppName)
db := app.Database(util.DbName, nil)
logSG := db.Syncgroup(logSGName)
err = logSG.Create(u.Ctx, logSpec, myInfoCreator)
if err != nil {
fmt.Println("SYNCGROUP CREATE ERROR: ", err)
fmt.Println("JOINING INSTEAD...")
_, err2 := logSG.Join(u.Ctx, myInfoCreator)
if err2 != nil {
fmt.Println("SYNCGROUP JOIN ERROR: ", err2)
return string(value), ""
} else {
return string(value), logSGName
}
} else {
fmt.Println("Syncgroup created")
if logSGName != u.LogSG {
ResetGame(logSGName, true, u)
}
return string(value), logSGName
}
}
func endClickSplit(t touch.Event, u *uistate.UIState) {
if u.CurCard != nil {
if u.CurTable.GetTrick()[u.CurPlayerIndex] == nil {
if dropCardHere(u.CurCard, u.DropTargets[0], t, u) {
if u.CurTable.WhoseTurn() == u.CurPlayerIndex {
ch := make(chan bool)
if err := sync.PlayCard(ch, u.CurPlayerIndex, u); err != "" {
view.ChangePlayMessage(err, u)
if sync.RemoveCardFromTarget(u.CurCard, u) {
u.CardToPlay = nil
u.BackgroundImgs[0].GetNode().Arranger = nil
var emptyTex sprite.SubTex
u.Eng.SetSubTex(u.BackgroundImgs[0].GetNode(), emptyTex)
u.BackgroundImgs[0].SetHidden(true)
}
// add card back to hand
reposition.ResetCardPosition(u.CurCard, u.Eng)
}
} else {
u.CardToPlay = u.CurCard
reposition.AlternateImgs(u.BackgroundImgs[0], u)
}
} else {
// add card back to hand
if sync.RemoveCardFromTarget(u.CurCard, u) {
u.CardToPlay = nil
u.BackgroundImgs[0].GetNode().Arranger = nil
var emptyTex sprite.SubTex
u.Eng.SetSubTex(u.BackgroundImgs[0].GetNode(), emptyTex)
u.BackgroundImgs[0].SetHidden(true)
}
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
} else {
// add card back to hand
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
}
pressed := getPressed(u)
unpress := true
for _, b := range pressed {
if b == u.Buttons["takeTrick"] {
sync.LogTakeTrick(u)
} else if b == u.Buttons["toggleSplit"] {
unpress = false
}
}
if unpress {
unpressButtons(u)
}
}
func ResetGame(logName string, creator bool, u *uistate.UIState) {
u.M.Lock()
defer u.M.Unlock()
go sendTrueIfExists(u.GameChan)
u.PlayerData = make(map[int]int)
u.CurPlayerIndex = -1
u.LogSG = logName
writeLogAddr(logName, creator)
u.CurTable.NewGame()
tmp := strings.Split(logName, "-")
gameID, _ := strconv.Atoi(tmp[len(tmp)-1])
u.GameID = gameID
u.GameChan = make(chan bool)
go UpdateGame(u.GameChan, u)
}
func RemoveAnimChan(ch chan bool, u *uistate.UIState) {
for i, c := range u.AnimChans {
if ch == c {
u.AnimChans = append(u.AnimChans[:i], u.AnimChans[i+1:]...)
return
}
}
}
func onStart(glctx gl.Context, u *uistate.UIState) {
flag.Set("v23.credentials", "/sdcard/credentials")
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.LogToStderr(true))
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.Level(0))
ctx, shutdown := v23.Init()
u.Shutdown = shutdown
u.Ctx = ctx
u.Service = syncbase.NewService(util.MountPoint + "/croupier/" + util.SBName)
namespace := v23.GetNamespace(u.Ctx)
allAccess := access.AccessList{In: []security.BlessingPattern{"..."}}
permissions := access.Permissions{
"Admin": allAccess,
"Write": allAccess,
"Read": allAccess,
"Resolve": allAccess,
"Debug": allAccess,
}
namespace.SetPermissions(u.Ctx, util.MountPoint, permissions, "")
namespace.SetPermissions(u.Ctx, util.MountPoint+"/croupier", permissions, "")
u.Service.SetPermissions(u.Ctx, permissions, "")
u.Images = glutil.NewImages(glctx)
fps = debug.NewFPS(u.Images)
u.Eng = glsprite.Engine(u.Images)
u.Texs = texture.LoadTextures(u.Eng)
u.CurTable = table.InitializeGame(u.NumPlayers, u.Texs)
sound.InitPlayers(u)
sync.CreateTables(u)
// Create watch stream to update game state based on Syncbase updates
go sync.UpdateSettings(u)
}
func UpdateImgPositions(sz size.Event, u *uistate.UIState) {
// must copy u.WindowSize instead of creating a pointer to it
oldWindowSize := coords.MakeVec(u.WindowSize.X, u.WindowSize.Y)
updateWindowSize(sz, u)
if windowExists(oldWindowSize) && windowExists(u.WindowSize) {
u.Padding = scaleVar(u.Padding, oldWindowSize, u.WindowSize)
AdjustImgs(oldWindowSize, u)
}
}
func endClickArrange(t touch.Event, u *uistate.UIState) {
pressed := unpressButtons(u)
for _, b := range pressed {
if b == u.Buttons["exit"] {
if u.SGChan != nil {
u.SGChan <- true
u.SGChan = nil
}
u.IsOwner = false
u.DiscGroups = make(map[string]*uistate.DiscStruct)
u.ScanChan = make(chan bool)
go sync.ScanForSG(u.Ctx, u.ScanChan, u)
view.LoadDiscoveryView(u)
} else if b == u.Buttons["start"] {
if u.CurTable.AllReadyForNewRound() {
successStart := sync.LogGameStart(u)
for !successStart {
successStart = sync.LogGameStart(u)
}
newHands := u.CurTable.Deal()
successDeal := sync.LogDeal(u, u.CurPlayerIndex, newHands)
for !successDeal {
successDeal = sync.LogDeal(u, u.CurPlayerIndex, newHands)
}
}
} else {
for key, button := range u.Buttons {
if b == button && (u.CurPlayerIndex < 0 || u.Debug) {
if key == "joinTable" {
u.CurPlayerIndex = 4
sync.LogPlayerNum(u)
} else {
playerNum := strings.Split(key, "-")[1]
u.CurPlayerIndex, _ = strconv.Atoi(playerNum)
sync.LogPlayerNum(u)
}
}
}
}
}
}
func handleDebugButtonClick(b *staticimg.StaticImg, u *uistate.UIState) {
if b == u.Buttons["player0"] {
u.CurPlayerIndex = 0
view.LoadPassOrTakeOrPlay(u)
} else if b == u.Buttons["player1"] {
u.CurPlayerIndex = 1
view.LoadPassOrTakeOrPlay(u)
} else if b == u.Buttons["player2"] {
u.CurPlayerIndex = 2
view.LoadPassOrTakeOrPlay(u)
} else if b == u.Buttons["player3"] {
u.CurPlayerIndex = 3
view.LoadPassOrTakeOrPlay(u)
} else if b == u.Buttons["table"] {
view.LoadTableView(u)
} else if b == u.Buttons["hand"] {
view.LoadPassOrTakeOrPlay(u)
} else if b == u.Buttons["restart"] {
sync.ResetGame(u.LogSG, u.IsOwner, u)
}
}
func endClickDiscovery(t touch.Event, u *uistate.UIState) {
pressed := unpressButtons(u)
for _, button := range pressed {
if button == u.Buttons["newGame"] {
gameStartData, logName := sync.CreateLogSyncgroup(u)
settingsName := sync.CreateSettingsSyncgroup(u)
if logName != "" && settingsName != "" {
sync.LogSettingsName(settingsName, u)
u.ScanChan <- true
u.ScanChan = nil
u.SGChan = make(chan bool)
go sync.Advertise(logName, settingsName, gameStartData, u.SGChan, u.Ctx)
view.LoadArrangeView(u)
}
} else {
for _, b := range u.Buttons {
if button == b {
s := strings.Split(b.GetInfo(), "|")
logAddr := s[0]
creator, _ := strconv.ParseBool(s[1])
fmt.Println("TRYING TO JOIN:", logAddr)
success := sync.JoinLogSyncgroup(logAddr, creator, u)
if success {
sgName := sync.CreateSettingsSyncgroup(u)
if sgName != "" {
sync.LogSettingsName(sgName, u)
}
u.ScanChan <- true
u.ScanChan = nil
view.LoadArrangeView(u)
} else {
fmt.Println("Failed to join")
}
}
}
}
}
}
func beginClickPass(t touch.Event, u *uistate.UIState) {
u.CurCard = findClickedCard(t, u)
if u.CurCard != nil {
reposition.BringNodeToFront(u.CurCard.GetNode(), u)
}
buttonList := findClickedButton(t, u)
for _, b := range buttonList {
if b == u.Buttons["pass"] {
pressButton(b, u)
} else {
handleDebugButtonClick(b, u)
}
}
}
func onPaint(glctx gl.Context, sz size.Event, u *uistate.UIState) {
if u.CurView == uistate.None {
u.ScanChan = make(chan bool)
go sync.ScanForSG(u.Ctx, u.ScanChan, u)
view.LoadDiscoveryView(u)
}
glctx.ClearColor(1, 1, 1, 1)
glctx.Clear(gl.COLOR_BUFFER_BIT)
now := clock.Time(time.Since(u.StartTime) * 60 / time.Second)
u.Eng.Render(u.Scene, now, sz)
if u.Debug {
fps.Draw(sz)
}
}
func onPlayerNum(key, value string, u *uistate.UIState) {
userID, _ := strconv.Atoi(strings.Split(key, "/")[2])
playerNum, _ := strconv.Atoi(value)
if playerNum >= 0 && playerNum < 4 {
u.PlayerData[playerNum] = userID
u.CurTable.GetPlayers()[playerNum].SetDoneScoring(true)
}
if playerNum == u.CurPlayerIndex && userID != util.UserID {
u.CurPlayerIndex = -1
}
if u.CurView == uistate.Arrange {
view.LoadArrangeView(u)
if u.CurTable.AllReadyForNewRound() && u.IsOwner {
b := u.Buttons["start"]
u.Eng.SetSubTex(b.GetNode(), b.GetImage())
b.SetHidden(false)
b.SetDisplayingImage(true)
if u.SGChan != nil {
u.SGChan <- true
u.SGChan = nil
}
}
}
}
func beginClickPlay(t touch.Event, u *uistate.UIState) {
u.CurCard = findClickedCard(t, u)
if u.CurCard != nil {
reposition.BringNodeToFront(u.CurCard.GetNode(), u)
}
buttonList := findClickedButton(t, u)
for _, b := range buttonList {
if b == u.Buttons["toggleSplit"] && !u.SwitchingViews {
view.LoadSplitView(false, u)
} else if b == u.Buttons["takeTrick"] {
pressButton(b, u)
} else {
handleDebugButtonClick(b, u)
}
}
}
func handleGameUpdate(file *os.File, key string, value []byte, u *uistate.UIState) {
curTime := time.Now().UnixNano() / 1000000
valueStr := string(value)
fmt.Fprintf(file, fmt.Sprintf("key: %s\n", key))
fmt.Fprintf(file, fmt.Sprintf("value: %s\n", valueStr))
fmt.Fprintf(file, fmt.Sprintf("time: %v\n", curTime))
tmp := strings.Split(key, "/")
if len(tmp) == 3 {
keyTime, _ := strconv.ParseInt(strings.Split(tmp[2], "-")[0], 10, 64)
if keyTime > u.LatestTimestamp {
u.LatestTimestamp = keyTime
}
fmt.Fprintf(file, fmt.Sprintf("diff: %d milliseconds\n\n", curTime-keyTime))
} else {
fmt.Fprintf(file, "\n")
}
fmt.Println(key, valueStr)
keyType := strings.Split(key, "/")[1]
switch keyType {
case "log":
updateType := strings.Split(valueStr, "|")[0]
switch updateType {
case Deal:
onDeal(valueStr, u)
case Pass:
onPass(valueStr, u)
case Take:
onTake(valueStr, u)
case Play:
onPlay(valueStr, u)
case TakeTrick:
onTakeTrick(valueStr, u)
case Ready:
onReady(valueStr, u)
}
case "players":
switch strings.Split(key, "/")[3] {
case "player_number":
onPlayerNum(key, valueStr, u)
case "settings_sg":
onSettings(key, valueStr, u)
}
}
}
// Joins gamelog syncgroup
func JoinLogSyncgroup(logName string, creator bool, u *uistate.UIState) bool {
fmt.Println("Joining gamelog syncgroup")
u.IsOwner = creator
app := u.Service.App(util.AppName)
db := app.Database(util.DbName, nil)
logSg := db.Syncgroup(logName)
myInfoJoiner := wire.SyncgroupMemberInfo{8, creator}
_, err := logSg.Join(u.Ctx, myInfoJoiner)
if err != nil {
fmt.Println("SYNCGROUP JOIN ERROR: ", err)
return false
} else {
fmt.Println("Syncgroup joined")
if u.LogSG != logName {
ResetGame(logName, creator, u)
}
return true
}
}
func endClickTake(t touch.Event, u *uistate.UIState) {
pressed := unpressButtons(u)
for _, b := range pressed {
if b == u.Buttons["take"] {
cards := make([]*card.Card, 0)
for _, d := range u.DropTargets {
c := d.GetCardHere()
if c != nil {
cards = append(cards, c)
}
}
for _, c := range cards {
sync.RemoveCardFromTarget(c, u)
// add card back to hand
reposition.ResetCardPosition(c, u.Eng)
reposition.RealignSuit(c.GetSuit(), c.GetInitial().Y, u)
}
ch := make(chan bool)
success := takeCards(ch, u.CurPlayerIndex, u)
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
if !success {
fmt.Println("Invalid take")
} else {
if u.CurView == uistate.Take {
view.LoadPlayView(false, u)
}
}
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
}
}
}
func onReady(value string, u *uistate.UIState) {
// logic
playerInt, _ := parsePlayerAndCards(value, u)
u.CurTable.GetPlayers()[playerInt].SetDoneScoring(true)
// UI
if u.CurTable.AllReadyForNewRound() && u.IsOwner {
if u.CurView == uistate.Arrange {
b := u.Buttons["start"]
u.Eng.SetSubTex(b.GetNode(), b.GetImage())
b.SetHidden(false)
b.SetDisplayingImage(true)
if u.SGChan != nil {
u.SGChan <- true
u.SGChan = nil
}
} else if u.CurView == uistate.Score {
newHands := u.CurTable.Deal()
successDeal := LogDeal(u, u.CurPlayerIndex, newHands)
for !successDeal {
successDeal = LogDeal(u, u.CurPlayerIndex, newHands)
}
}
}
}
func onTake(value string, u *uistate.UIState) {
// logic
playerInt, _ := parsePlayerAndCards(value, u)
p := u.CurTable.GetPlayers()[playerInt]
passed := p.GetPassedTo()
for _, c := range passed {
p.AddToHand(c)
}
u.CurTable.GetPlayers()[playerInt].SetDoneTaking(true)
if u.SequentialPhases {
if u.CurTable.AllDoneTaking() {
for _, player := range u.CurTable.GetPlayers() {
if player.HasTwoOfClubs() {
u.CurTable.SetFirstPlayer(player.GetPlayerIndex())
}
}
// UI
if u.CurView == uistate.Play {
view.LoadPlayView(true, u)
}
}
} else if p.HasTwoOfClubs() {
u.CurTable.SetFirstPlayer(p.GetPlayerIndex())
// UI
if u.CurView == uistate.Play && u.CurPlayerIndex != playerInt {
view.LoadPlayView(true, u)
}
}
// UI
if u.CurView == uistate.Table {
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateTableCardTake(passed, u.CurTable.GetPlayers()[playerInt], quit, u)
view.LoadTableView(u)
}
}
func onPass(value string, u *uistate.UIState) {
// logic
playerInt, curCards := parsePlayerAndCards(value, u)
var receivingPlayer int
switch u.CurTable.GetDir() {
case direction.Right:
receivingPlayer = (playerInt + 3) % u.NumPlayers
case direction.Left:
receivingPlayer = (playerInt + 1) % u.NumPlayers
case direction.Across:
receivingPlayer = (playerInt + 2) % u.NumPlayers
}
for _, c := range curCards {
u.CurTable.GetPlayers()[playerInt].RemoveFromHand(c)
}
u.CurTable.GetPlayers()[playerInt].SetPassedFrom(curCards)
u.CurTable.GetPlayers()[receivingPlayer].SetPassedTo(curCards)
u.CurTable.GetPlayers()[playerInt].SetDonePassing(true)
// UI
if u.CurView == uistate.Table {
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateTableCardPass(curCards, receivingPlayer, quit, u)
view.LoadTableView(u)
} else if u.CurView == uistate.Take {
if u.SequentialPhases {
if u.CurTable.AllDonePassing() {
view.LoadTakeView(u)
}
} else if u.CurPlayerIndex == receivingPlayer {
view.LoadTakeView(u)
}
} else if u.CurView == uistate.Play && u.CurTable.AllDonePassing() {
view.LoadPlayView(true, u)
}
}
func OnTouch(t touch.Event, u *uistate.UIState) {
if t.Type == touch.TypeBegin {
u.ViewOnTouch = u.CurView
beganTouchX = t.X
beganTouchY = t.Y
} else if u.CurView != u.ViewOnTouch {
return
}
// tap 5 times to trigger debug mode
if t.Type == touch.TypeEnd {
if t.X == beganTouchX && t.Y == beganTouchY && time.Since(timeStartedTapping).Seconds() <= 5.0 {
numTaps++
if numTaps == 5 {
fmt.Println("TOGGLING DEBUG")
u.Debug = !u.Debug
view.ReloadView(u)
numTaps = 0
}
} else {
numTaps = 0
timeStartedTapping = time.Now()
}
}
switch u.CurView {
case uistate.Discovery:
switch t.Type {
case touch.TypeBegin:
beginClickDiscovery(t, u)
case touch.TypeMove:
moveClickDiscovery(t, u)
case touch.TypeEnd:
endClickDiscovery(t, u)
}
case uistate.Arrange:
switch t.Type {
case touch.TypeBegin:
beginClickArrange(t, u)
case touch.TypeMove:
moveClickArrange(t, u)
case touch.TypeEnd:
endClickArrange(t, u)
}
case uistate.Table:
switch t.Type {
case touch.TypeBegin:
beginClickTable(t, u)
case touch.TypeMove:
moveClickTable(t, u)
case touch.TypeEnd:
endClickTable(t, u)
}
case uistate.Pass:
switch t.Type {
case touch.TypeBegin:
beginClickPass(t, u)
case touch.TypeMove:
moveClickPass(t, u)
case touch.TypeEnd:
endClickPass(t, u)
}
case uistate.Take:
switch t.Type {
case touch.TypeBegin:
beginClickTake(t, u)
case touch.TypeMove:
moveClickTake(t, u)
case touch.TypeEnd:
endClickTake(t, u)
}
case uistate.Play:
switch t.Type {
case touch.TypeBegin:
beginClickPlay(t, u)
case touch.TypeMove:
moveClickPlay(t, u)
case touch.TypeEnd:
endClickPlay(t, u)
}
case uistate.Split:
switch t.Type {
case touch.TypeBegin:
beginClickSplit(t, u)
case touch.TypeMove:
moveClickSplit(t, u)
case touch.TypeEnd:
endClickSplit(t, u)
}
case uistate.Score:
switch t.Type {
case touch.TypeBegin:
beginClickScore(t, u)
case touch.TypeMove:
moveClickScore(t, u)
case touch.TypeEnd:
endClickScore(t, u)
}
}
u.LastMouseXY.X = t.X
u.LastMouseXY.Y = t.Y
}
func onTakeTrick(value string, u *uistate.UIState) {
trickCards := u.CurTable.GetTrick()
recipient := u.CurTable.GetTrickRecipient()
roundOver := u.CurTable.SendTrick(recipient)
if roundOver {
u.RoundScores, u.Winners = u.CurTable.EndRound()
}
// UI
if u.CurView == uistate.Table {
sound.PlaySound(1, u)
var emptyTex sprite.SubTex
u.Eng.SetSubTex(u.Buttons["takeTrick"].GetNode(), emptyTex)
u.Buttons["takeTrick"].SetHidden(true)
var trickDir direction.Direction
switch recipient {
case 0:
trickDir = direction.Down
case 1:
trickDir = direction.Left
case 2:
trickDir = direction.Across
case 3:
trickDir = direction.Right
}
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateTableCardTakeTrick(trickCards, trickDir, quit, u)
reposition.SetTableDropColors(u)
view.SetNumTricksTable(u)
} else if u.CurView == uistate.Split {
var emptyTex sprite.SubTex
u.Eng.SetSubTex(u.Buttons["takeTrick"].GetNode(), emptyTex)
u.Buttons["takeTrick"].SetHidden(true)
if roundOver {
view.LoadScoreView(u)
} else {
var trickDir direction.Direction
switch recipient {
case u.CurPlayerIndex:
sound.PlaySound(0, u)
trickDir = direction.Down
case (u.CurPlayerIndex + 1) % u.NumPlayers:
trickDir = direction.Left
case (u.CurPlayerIndex + 2) % u.NumPlayers:
trickDir = direction.Across
case (u.CurPlayerIndex + 3) % u.NumPlayers:
trickDir = direction.Right
}
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateTableCardTakeTrick(trickCards, trickDir, quit, u)
view.LoadSplitView(true, u)
}
} else if u.CurView == uistate.Play {
if roundOver {
view.LoadScoreView(u)
} else {
if recipient == u.CurPlayerIndex {
sound.PlaySound(0, u)
}
view.LoadPlayView(true, u)
}
}
// logic
if len(u.Winners) > 0 {
u.CurTable.NewGame()
}
}
func onPlay(value string, u *uistate.UIState) {
// logic
playerInt, curCards := parsePlayerAndCards(value, u)
playedCard := curCards[0]
u.CurTable.GetPlayers()[playerInt].RemoveFromHand(playedCard)
u.CurTable.SetPlayedCard(playedCard, playerInt)
u.CurTable.GetPlayers()[playerInt].SetDonePlaying(true)
trickOver := u.CurTable.TrickOver()
var recipient int
if trickOver {
recipient = u.CurTable.GetTrickRecipient()
}
// UI
if u.CurView == uistate.Table {
sound.PlaySound(0, u)
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateTableCardPlay(playedCard, playerInt, quit, u)
reposition.SetTableDropColors(u)
if trickOver {
// display take trick button
b := u.Buttons["takeTrick"]
u.Eng.SetSubTex(b.GetNode(), b.GetImage())
b.SetHidden(false)
}
} else if u.CurView == uistate.Split {
if playerInt != u.CurPlayerIndex {
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
reposition.AnimateSplitCardPlay(playedCard, playerInt, quit, u)
}
reposition.SetSplitDropColors(u)
view.LoadSplitView(true, u)
if trickOver {
if recipient == u.CurPlayerIndex {
// display take trick button
b := u.Buttons["takeTrick"]
u.Eng.SetSubTex(b.GetNode(), b.GetImage())
b.SetHidden(false)
}
} else if u.CardToPlay != nil && u.CurTable.WhoseTurn() == u.CurPlayerIndex {
ch := make(chan bool)
if err := PlayCard(ch, u.CurPlayerIndex, u); err != "" {
view.ChangePlayMessage(err, u)
RemoveCardFromTarget(u.CardToPlay, u)
// add card back to hand
reposition.ResetCardPosition(u.CardToPlay, u.Eng)
}
u.CardToPlay = nil
u.BackgroundImgs[0].GetNode().Arranger = nil
var emptyTex sprite.SubTex
u.Eng.SetSubTex(u.BackgroundImgs[0].GetNode(), emptyTex)
u.BackgroundImgs[0].SetHidden(true)
}
} else if u.CurView == uistate.Play && u.CurPlayerIndex != playerInt {
view.LoadPlayView(true, u)
if u.CardToPlay != nil && u.CurTable.WhoseTurn() == u.CurPlayerIndex {
ch := make(chan bool)
if err := PlayCard(ch, u.CurPlayerIndex, u); err != "" {
view.ChangePlayMessage(err, u)
RemoveCardFromTarget(u.CardToPlay, u)
// add card back to hand
reposition.ResetCardPosition(u.CardToPlay, u.Eng)
reposition.RealignSuit(u.CardToPlay.GetSuit(), u.CardToPlay.GetInitial().Y, u)
}
u.CardToPlay = nil
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
if u.CurView == uistate.Play {
view.LoadPlayView(true, u)
}
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
}
}
}
func endClickPlay(t touch.Event, u *uistate.UIState) {
if u.CurCard != nil {
if u.CurTable.GetTrick()[u.CurPlayerIndex] == nil {
if dropCardOnTarget(u.CurCard, t, u) {
if u.CurTable.WhoseTurn() == u.CurPlayerIndex {
ch := make(chan bool)
if err := sync.PlayCard(ch, u.CurPlayerIndex, u); err != "" {
view.ChangePlayMessage(err, u)
sync.RemoveCardFromTarget(u.CurCard, u)
u.CardToPlay = nil
// add card back to hand
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
if u.CurView == uistate.Play {
view.LoadPlayView(true, u)
}
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
} else {
u.CardToPlay = u.CurCard
}
} else {
// add card back to hand
if sync.RemoveCardFromTarget(u.CurCard, u) {
u.CardToPlay = nil
}
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
} else {
// add card back to hand
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
}
pressed := unpressButtons(u)
for _, b := range pressed {
if b == u.Buttons["takeTrick"] {
var emptyTex sprite.SubTex
u.Eng.SetSubTex(b.GetNode(), emptyTex)
b.SetHidden(true)
u.Buttons["takeTrick"] = nil
for _, takenCard := range u.TableCards {
sync.RemoveCardFromTarget(takenCard, u)
reposition.BringNodeToFront(takenCard.GetNode(), u)
}
ch := make(chan bool)
reposition.AnimateHandCardTakeTrick(ch, u.TableCards, u)
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
sync.LogTakeTrick(u)
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
}
}
}
func endClickPass(t touch.Event, u *uistate.UIState) {
if u.CurCard != nil {
if !dropCardOnTarget(u.CurCard, t, u) {
// check to see if card was removed from a drop target
sync.RemoveCardFromTarget(u.CurCard, u)
// add card back to hand
reposition.ResetCardPosition(u.CurCard, u.Eng)
reposition.RealignSuit(u.CurCard.GetSuit(), u.CurCard.GetInitial().Y, u)
}
// check to see whether pull tab should be displayed
readyToPass := true
for _, d := range u.DropTargets {
if d.GetCardHere() == nil {
readyToPass = false
}
}
passButton := u.Buttons["pass"]
if readyToPass {
if passButton.GetDisplayingImage() {
u.Eng.SetSubTex(passButton.GetNode(), passButton.GetImage())
passButton.SetHidden(false)
passButton.SetDisplayingImage(true)
}
for _, img := range u.Other {
if img.GetDisplayingImage() {
u.Eng.SetSubTex(img.GetNode(), img.GetAlt())
img.SetHidden(false)
img.SetDisplayingImage(false)
}
}
} else {
var emptyTex sprite.SubTex
u.Eng.SetSubTex(passButton.GetNode(), emptyTex)
passButton.SetHidden(true)
passButton.SetDisplayingImage(true)
for _, img := range u.Other {
if !img.GetDisplayingImage() {
u.Eng.SetSubTex(img.GetNode(), img.GetImage())
img.SetHidden(false)
img.SetDisplayingImage(true)
}
}
}
}
pressed := unpressButtons(u)
for _, p := range pressed {
if p == u.Buttons["pass"] {
ch := make(chan bool)
success := passCards(ch, u.CurPlayerIndex, u)
quit := make(chan bool)
u.AnimChans = append(u.AnimChans, quit)
go func() {
onDone := func() {
if !success {
fmt.Println("Invalid pass")
} else if u.CurView == uistate.Pass {
view.LoadTakeView(u)
}
}
reposition.SwitchOnChan(ch, quit, onDone, u)
}()
}
}
u.CurCard = nil
}
func updateWindowSize(sz size.Event, u *uistate.UIState) {
u.WindowSize.SetVec(float32(sz.WidthPt), float32(sz.HeightPt))
u.PixelsPerPt = float32(sz.WidthPx) / u.WindowSize.X
}