copy slices to prevent weird slice overlap

board.go

@@ -4,7 +4,7 @@ import . "git.saintnet.tech/tomecraft/tome_lib"
 
 func NewBoard() *Board {
 	return &Board{
-		Sentinal: [4]*Card{NewEmpty(0), NewEmpty(1), NewEmpty(2), NewEmpty(3)},
-		Scourge:  [4]*Card{NewEmpty(0), NewEmpty(1), NewEmpty(2), NewEmpty(3)},
+		Sentinal: [4]*Card{NewEmpty(SentinalID, 0), NewEmpty(SentinalID, 1), NewEmpty(SentinalID, 2), NewEmpty(SentinalID, 3)},
+		Scourge:  [4]*Card{NewEmpty(ScourgeID, 0), NewEmpty(ScourgeID, 1), NewEmpty(ScourgeID, 2), NewEmpty(ScourgeID, 3)},
 	}
 }

card.go

@@ -1,11 +1,17 @@
 package tome_game
 
 import (
+	"log"
+
 	. "git.saintnet.tech/tomecraft/tome_lib"
 	"github.com/google/uuid"
 )
 
 func NewCard(v, o, p int, id uuid.UUID) *Card {
+	if o != ScourgeID && o != SentinalID {
+		log.Println("Need valid owner for card")
+		return nil
+	}
 	if id == uuid.Nil {
 		id = uuid.New()
 	}
@@ -19,6 +25,7 @@ func NewCard(v, o, p int, id uuid.UUID) *Card {
 		Owner:     o,
 		Position:  p,
 		Spell:     OracleSpell(CardType(v), nil),
+		Token:     OracleToken(CardType(v), nil),
 		Effects:   []*Effect{},
 	}
 }

deck.go

@@ -1,11 +1,17 @@
 package tome_game
 
 import (
+	"log"
+
 	. "git.saintnet.tech/tomecraft/tome_lib"
 	"github.com/google/uuid"
 )
 
 func NewDeck(owner int) *Deck {
+	if owner != SentinalID && owner != ScourgeID {
+		log.Printf("need valid owner for new deck: %v", owner)
+		return nil
+	}
 	cards := []*Card{}
 	for i := 0; i < 3; i++ {
 		for j := 1; j < 9; j++ {
@@ -17,3 +23,35 @@ func NewDeck(owner int) *Deck {
 		Cards: cards,
 	}
 }
+
+func LoadDeck(owner int, cards []int) *Deck {
+	if owner != SentinalID && owner != ScourgeID {
+		log.Printf("need valid owner for loaded deck:%v", owner)
+		return nil
+	}
+	if len(cards) == 0 {
+		return NewDeck(owner)
+	}
+	d := []*Card{}
+	for _, v := range cards {
+		d = append(d, NewCard(v, owner, -1, uuid.Nil))
+	}
+	return &Deck{
+		Cards: d,
+	}
+}
+
+func ValidateDeck(cards []int) bool {
+	if len(cards) < 15 {
+		return false
+	}
+	for _, v := range cards {
+		if !CardType(v).IsACardType() {
+			return false
+		}
+		if OracleToken(CardType(v), nil) {
+			return false
+		}
+	}
+	return true
+}

game.go

@@ -19,16 +19,18 @@ type Game struct {
 	ScourgeGrave   *Deck
 	CurrentTurn    int
 	CardBuffer     *Deck
+	ScryBuffer     int
+	BottomBuffer   int
 	CanDraw        bool
 	HasDrawn       bool
+	QueuedEffect   *Effect
+	TargetReq      TargetStatus
 	Status         GameStatus
 }
 
-func NewGame() *Game {
-	deckA := NewDeck(SentinalID)
-	deckB := NewDeck(ScourgeID)
-	deckA.Shuffle()
-	deckB.Shuffle()
+func NewGame(sentDeck []int, scoDeck []int) *Game {
+	deckA := LoadDeck(SentinalID, sentDeck)
+	deckB := LoadDeck(ScourgeID, scoDeck)
 	return &Game{
 		GameBoard:      NewBoard(),
 		SentinalPlayer: NewPlayer("Sentinal", SentinalID),
@@ -39,14 +41,18 @@ func NewGame() *Game {
 		ScourgeGrave:   DeckFromCards([]*Card{}),
 		CurrentTurn:    0, //start with no turn
 		CardBuffer:     DeckFromCards([]*Card{}),
+		ScryBuffer:     0,
+		BottomBuffer:   0,
 		CanDraw:        false,
 		HasDrawn:       false,
+		QueuedEffect:   nil,
+		TargetReq:      TargetNone,
 		Status:         StatusLobby,
 	}
 }
 
 func (g *Game) String() string {
-	return fmt.Sprintf("Sen(%v): %v\n\n%v\n\nSco(%v): %v\nStatus:%v Draw:%v Turn:%v\n%v\n", g.SentinalPlayer.Life, g.SentinalPlayer.Hand, g.GameBoard, g.ScourgePlayer.Life, g.ScourgePlayer.Hand, g.Status, g.CanDraw, g.CurrentTurn, g.CardBuffer)
+	return fmt.Sprintf("Sen(%v): %v\n\n%v\n\nSco(%v): %v\nStatus:%v Draw:%v Turn:%v\nBuffers\nCardBuffer:%v\nSB:%v BB:%v\nEffectTarget:%v\nQueuedEffect:%v\n", g.SentinalPlayer.Life, g.SentinalPlayer.Hand, g.GameBoard, g.ScourgePlayer.Life, g.ScourgePlayer.Hand, g.Status, g.CanDraw, g.CurrentTurn, g.CardBuffer, g.ScryBuffer, g.BottomBuffer, g.TargetReq, g.QueuedEffect)
 }
 
 func (g *Game) Parse(cmd *Command) *CommandResult {
@@ -87,7 +93,9 @@ func (g *Game) Parse(cmd *Command) *CommandResult {
 		debug_res = nil
 		res_type = InvalidCmd
 	}
-	g.StateChanges()
+	if g.Status == StatusPlaying {
+		g.StateChanges()
+	}
 	return &CommandResult{
 		PlayerID:     cmd.PlayerID,
 		ResultType:   res_type,
@@ -110,6 +118,10 @@ func (g *Game) StateChanges() {
 			g.Status = StatusSentinalWin
 		}
 	}
+	//apply CurrentTurn player effects
+	for i := 0; i < len(g.GetPlayer(g.CurrentTurn).Effects); i++ {
+		OraclePlayerEffect(g.GetPlayer(g.CurrentTurn), g)
+	}
 	//reapply card effects
 	g.GameBoard.ResetCards()
 	for i := 0; i < len(g.GameBoard.Sentinal); i++ {
@@ -143,6 +155,9 @@ func (g *Game) PlayerStateAct(id int, cmd string) *GameView {
 		return NewView(id, g)
 	case "b":
 		//begin game
+		if g.Status == StatusPlaying {
+			break
+		}
 		if id == SentinalID {
 			g.SentinalPlayer.Ready = true
 		} else if id == ScourgeID {
@@ -150,6 +165,8 @@ func (g *Game) PlayerStateAct(id int, cmd string) *GameView {
 		}
 		if g.SentinalPlayer.Ready && g.ScourgePlayer.Ready && g.Status == StatusLobby {
 			g.Status = StatusReady
+			g.SentinalDeck.Shuffle()
+			g.ScourgeDeck.Shuffle()
 			if id == SentinalID {
 				g.SentinalPlayer.Hand = g.SentinalDeck.Cards[len(g.SentinalDeck.Cards)-5 : len(g.SentinalDeck.Cards)]
 				g.SentinalDeck.Cards = g.SentinalDeck.Cards[0 : len(g.SentinalDeck.Cards)-5]
@@ -190,6 +207,10 @@ func (g *Game) PlayerStateAct(id int, cmd string) *GameView {
 		if id != g.CurrentTurn {
 			return nil
 		}
+		if g.CanDraw == true || g.QueuedEffect != nil {
+			log.Println("player tried to end turn while still actions available")
+			return nil
+		}
 		g.CardBuffer = DeckFromCards([]*Card{})
 		for _, v := range g.GetBoard(id) {
 			OracleEndstep(v, g)
@@ -204,6 +225,9 @@ func (g *Game) PlayerStateAct(id int, cmd string) *GameView {
 }
 
 func (g *Game) PlayerAct(id int, cmd string) *Deck {
+	if g.Status != StatusPlaying {
+		return nil
+	}
 	if id != g.CurrentTurn {
 		return nil
 	}
@@ -220,16 +244,20 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 	switch cmd_s[0] {
 	case "s":
 		//scry: return scry options off top of deck
-		if !g.CanDraw {
+		if !g.CanDraw || g.QueuedEffect != nil {
 			return nil
 		}
-		if g.CardBuffer.Size() <= 0 {
-			g.CardBuffer = DeckFromCards(currD.Scry(curr.Life))
+		if g.ScryBuffer == 0 {
+			g.ScryBuffer = curr.Life
 		}
+		if g.CardBuffer.Size() <= 0 {
+			g.CardBuffer = currD.Scry(g.ScryBuffer)
+		}
+		g.ScryBuffer = 0
 		return g.CardBuffer
 	case "d":
 		//draw: return player hand
-		if !g.CanDraw {
+		if !g.CanDraw || g.QueuedEffect != nil || g.BottomBuffer != 0 {
 			return nil
 		}
 		if len(cmd_s) != 2 || !g.CanDraw {
@@ -240,28 +268,54 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 		}
 		x_i, err := strconv.Atoi(cmd_s[1])
 		if err != nil {
-			panic(err)
+			log.Printf("error converting draw target %v", err)
+			return nil
 		}
-		if x_i > 2 || x_i < 0 {
+		if x_i > g.CardBuffer.Size() || x_i < 0 {
 			return nil
 		}
 		x := g.CardBuffer.Cards[x_i]
 		if x.Owner != g.CurrentTurn {
 			log.Println("drew a card from our deck that isn't our own")
 		}
-		g.CardBuffer.Cards = append(g.CardBuffer.Cards[:x_i], g.CardBuffer.Cards[x_i+1:]...)
-		currD.Bottom(g.CardBuffer.Cards)
+		g.CardBuffer = DeckFromCards(append(g.CardBuffer.Cards[:x_i], g.CardBuffer.Cards[x_i+1:]...))
+		currD.Bottom(g.CardBuffer)
 		curr.Hand = append(curr.Hand, x)
 		g.CanDraw = false
 		g.HasDrawn = true
+		g.CardBuffer.Reset()
 		return DeckFromCards(curr.Hand)
-
+	case "b":
+		if g.BottomBuffer == 0 || g.ScryBuffer != 0 {
+			return nil
+		}
+		if len(cmd_s) != 2 {
+			return nil
+		}
+		x_i, err := strconv.Atoi(cmd_s[1])
+		if err != nil {
+			log.Printf("error converting bottom target %v", err)
+			return nil
+		}
+		if x_i > g.CardBuffer.Size() || x_i < 0 {
+			return nil
+		}
+		bottomTarget := g.CardBuffer.Cards[x_i]
+		g.CardBuffer.Cards = append(g.CardBuffer.Cards[:x_i], g.CardBuffer.Cards[x_i+1:]...)
+		currD.Bottom(DeckFromCards([]*Card{bottomTarget}))
+		g.BottomBuffer = g.BottomBuffer - 1
+		if g.BottomBuffer > 0 {
+			return g.CardBuffer
+		} else {
+			g.BottomBuffer = 0
+			return nil
+		}
 	case "m":
 		//move: return player board or [] if invalid
 		if len(cmd_s) != 3 {
 			return nil
 		}
-		if !g.HasDrawn {
+		if !g.HasDrawn || g.QueuedEffect != nil || g.BottomBuffer != 0 {
 			return nil
 		}
 		x_i, err := strconv.Atoi(cmd_s[1])
@@ -285,7 +339,7 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 		if len(cmd_s) != 3 {
 			return nil
 		}
-		if !g.HasDrawn {
+		if !g.HasDrawn || g.QueuedEffect != nil || g.BottomBuffer != 0 {
 			return nil
 		}
 		x_i, err := strconv.Atoi(cmd_s[1])
@@ -299,7 +353,7 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 			return nil
 		}
 		if g.GameBoard.CanAttack(g.CurrentTurn, x_i, y_i) {
-			OracleAttack(g.GameBoard.GetCard(g.CurrentTurn, x_i), g)
+			OracleAttack(g.GameBoard.GetCard(g.CurrentTurn, x_i), x_i, y_i, g)
 			res := g.GameBoard.Attack(g.CurrentTurn, x_i, y_i)
 			var aid, did int
 			aid = g.GetPlayer(id).Id
@@ -333,12 +387,12 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 			return DeckFromCards([]*Card{})
 		}
 	case "p":
-		//play: return player boad or [] if invalid
+		//play: return player board or [] if invalid
 		if len(cmd_s) != 3 {
 			fmt.Println("not enough arguments")
 			return nil
 		}
-		if !g.HasDrawn {
+		if !g.HasDrawn || g.QueuedEffect != nil || g.BottomBuffer != 0 {
 			return nil
 		}
 		x_i, err := strconv.Atoi(cmd_s[1])
@@ -368,6 +422,80 @@ func (g *Game) PlayerAct(id int, cmd string) *Deck {
 			fmt.Println("couldn't play")
 			return DeckFromCards([]*Card{})
 		}
+	case "t":
+		//target: apply queued effect to target,return affected board or nil
+		if len(cmd_s) != 3 {
+			fmt.Println("not enough arguments")
+			return nil
+		}
+		if !g.HasDrawn || g.QueuedEffect == nil || g.BottomBuffer != 0 {
+			return nil
+		}
+		board, err := strconv.Atoi(cmd_s[1])
+		if err != nil {
+			log.Println(err)
+			return nil
+		}
+		pos, err := strconv.Atoi(cmd_s[2])
+		if err != nil {
+			log.Println(err)
+			return nil
+		}
+		if pos == -1 {
+			fmt.Println("no target requested, fizzling effect")
+			g.QueuedEffect = nil
+			g.TargetReq = TargetNone
+			return DeckFromCards(g.GetBoard(board))
+		}
+		if pos < 0 || pos >= 3 {
+			fmt.Println("board position out of bounds")
+			return nil
+		}
+		switch g.TargetReq {
+		case TargetSelf:
+			if board != g.CurrentTurn && g.GetBoard(board)[pos].Id != g.QueuedEffect.Owner {
+				fmt.Println("self target not on self")
+				return nil
+			}
+		case TargetOwn:
+			if board != g.CurrentTurn {
+				fmt.Println("own target not on own board")
+				return nil
+			}
+		case TargetOwnEmpty:
+			if board != g.CurrentTurn {
+				fmt.Println("own target not on board")
+				return nil
+			}
+			if g.GetBoard(board)[pos].Type != EmptyValue {
+				fmt.Println("own empty target not empty")
+				return nil
+			}
+		case TargetOpp:
+			if board == g.CurrentTurn {
+				fmt.Println("opponent target not on oponents board")
+				return nil
+			}
+		case TargetOppEmpty:
+			if board == g.CurrentTurn {
+				fmt.Println("opponent target not on board")
+				return nil
+			}
+			if g.GetBoard(board)[pos].Type != EmptyValue {
+				fmt.Println("opponent empty target not empty")
+				return nil
+			}
+		case TargetNone:
+			fmt.Println("NoneTarget'd ability?")
+			return nil
+		}
+		//we know the target is valid now, so modify the effect to have a valid target
+		g.QueuedEffect.Target = g.GetBoard(board)[pos].Id
+		AddEffect(g.GetBoard(board)[pos], g.QueuedEffect)
+		g.QueuedEffect = nil
+		g.TargetReq = TargetNone
+		return DeckFromCards(g.GetBoard(board))
+
 	default:
 		fmt.Println("Invalid act command")
 		return nil
@@ -418,6 +546,15 @@ func (g *Game) GetOpponentDeck(id int) *Deck {
 func (g *Game) GetBoard(id int) []*Card {
 	return g.GameBoard.GetRow(id)
 }
+func (g *Game) GetOpponentBoard(id int) []*Card {
+	if id == SentinalID {
+		return g.GameBoard.GetRow(ScourgeID)
+	} else if id == ScourgeID {
+		return g.GameBoard.GetRow(SentinalID)
+	} else {
+		return nil
+	}
+}
 
 func (g *Game) GetGrave(id int) *Deck {
 	if id == SentinalID {

game_view.go

@@ -15,6 +15,8 @@ func NewView(id int, g *Game) *GameView {
 		CurrentTurn:   g.CurrentTurn,
 		CanDraw:       g.CanDraw,
 		HasDrawn:      g.HasDrawn,
+		QueuedEffect:  g.QueuedEffect,
+		TargetReq:     g.TargetReq,
 		Status:        g.Status,
 	}
 }

go.mod

@@ -6,3 +6,5 @@ require (
 	git.saintnet.tech/tomecraft/tome_lib v0.1.3 // indirect
 	github.com/google/uuid v1.3.0 // indirect
 )
+
+replace git.saintnet.tech/tomecraft/tome_lib => ../tome_lib

go.sum

@@ -6,5 +6,14 @@ git.saintnet.tech/tomecraft/tome_lib v0.1.2 h1:S2BHgsWBGFv9fy+qBHuKXv0kcjT7VP/7g
 git.saintnet.tech/tomecraft/tome_lib v0.1.2/go.mod h1:Jekqa9ojNDOrcO1aL0IWKuhCQSE5+MNHVcYtTWA6uko=
 git.saintnet.tech/tomecraft/tome_lib v0.1.3 h1:JHW5ozFDfikLcRakAUSX+xxXlwNb4nmlcl8/ja7dKAo=
 git.saintnet.tech/tomecraft/tome_lib v0.1.3/go.mod h1:Jekqa9ojNDOrcO1aL0IWKuhCQSE5+MNHVcYtTWA6uko=
+github.com/alvaroloes/enumer v1.1.2 h1:5khqHB33TZy1GWCO/lZwcroBFh7u+0j40T83VUbfAMY=
+github.com/alvaroloes/enumer v1.1.2/go.mod h1:FxrjvuXoDAx9isTJrv4c+T410zFi0DtXIT0m65DJ+Wo=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1/go.mod h1:eD5JxqMiuNYyFNmyY9rkJ/slN8y59oEu4Ei7F8OoKWQ=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190524210228-3d17549cdc6b/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=

oracle.go

@@ -4,16 +4,29 @@ import (
 	"log"
 
 	. "git.saintnet.tech/tomecraft/tome_lib"
+	"github.com/google/uuid"
 )
 
 func OracleUpkeep(c *Card, g *Game) {
 	switch c.Type {
-	case Eight:
+	case ShieldWall:
 		c.Sick = true
 		if c.Counters >= 3 {
 			g.GameBoard.Remove(c)
 			g.Bury(c)
 		}
+	case Hologram:
+		c.Sick = false
+		if c.Counters >= 3 {
+			g.GameBoard.Remove(c)
+			g.Bury(c)
+		}
+	case Clog:
+		c.Sick = false
+		if c.Counters >= 1 {
+			g.GameBoard.Remove(c)
+			g.Bury(c)
+		}
 	default:
 		c.Sick = false
 	}
@@ -28,7 +41,14 @@ func OracleSpell(c CardType, g *Game) bool {
 		return false
 	}
 }
-
+func OracleToken(c CardType, g *Game) bool {
+	switch c {
+	case GoblinSpawn, Dud, Clog:
+		return true
+	default:
+		return false
+	}
+}
 func OracleCast(c *Card, g *Game) bool {
 	switch c.Type {
 	case Valk:
@@ -42,39 +62,88 @@ func OracleCast(c *Card, g *Game) bool {
 func OracleEnters(c *Card, g *Game) {
 	c.Sick = true
 	switch c.Type {
-	case Ace:
+	case Speedster:
 		c.Sick = false
 		return
-	case Four:
-		AddEffect(c, &Effect{c.Id, c.Id, 2})
-	case Eight:
+	case Scholar:
+		AddPlayerEffect(g.GetPlayer(c.Owner), &Effect{c.Id, uuid.Nil, 2, 1, true})
+	case Student:
+		AddPlayerEffect(g.GetPlayer(c.Owner), &Effect{c.Id, uuid.Nil, 4, 2, true})
+	case Librarian:
+		AddPlayerEffect(g.GetPlayer(c.Owner), &Effect{c.Id, uuid.Nil, 1, 1, true})
+	case ShieldWall, Tree:
 		c.Counters = 0
+	case HealthPotion:
+		g.SentinalPlayer.Life = g.SentinalPlayer.Life + 1
+		g.ScourgePlayer.Life = g.ScourgePlayer.Life + 1
+	case Goblin:
+		for i := 0; i < 2; i++ {
+			for k, v := range g.GetBoard(c.Owner) {
+				if v.Empty() {
+					g.GetBoard(c.Owner)[k] = NewCard(int(GoblinSpawn), c.Owner, k, uuid.Nil)
+					break
+				}
+			}
+		}
+	case Ally:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 1, 1, true}
+		g.TargetReq = TargetOwn
+	case Enemy:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 1, -1, true}
+		g.TargetReq = TargetOpp
+	case Chupacabra:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 4, 0, true}
+		g.TargetReq = TargetOpp
+	case Duelist:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 6, 1, true}
+		g.TargetReq = TargetOwn
+	case Vanguard:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 5, 1, true}
+		g.TargetReq = TargetOwn
+	case Elephant:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 9, 0, false}
+		g.TargetReq = TargetOppEmpty
+	case Bureaucrat:
+		g.QueuedEffect = &Effect{c.Id, uuid.Nil, 10, 0, false}
+		g.TargetReq = TargetAny
+	case Clog:
+		c.Phased = true
+		c.Counters = 0
+	case Mesmerist:
+		g.GetOpponentDeck(c.Owner).Shuffle()
+	case Diviner:
+		AddPlayerEffect(g.GetPlayer(c.Owner), &Effect{c.Id, uuid.Nil, 3, 2, true})
 	}
 }
 
 func OracleTick(c *Card, g *Game) {
-	if c.Type == EmptyValue {
+	if c.Empty() {
 		return
 	}
 	row := g.GetBoard(c.Owner)
 
 	switch c.Type {
-	case Two:
+	case Commander:
 		//+1 to all
 		for _, v := range row {
 			if v.Id != c.Id {
-				AddEffect(v, &Effect{c.Id, v.Id, 1})
+				AddEffect(v, &Effect{c.Id, v.Id, 1, 1, true})
 			}
 		}
-	case Three:
+	case Paladin:
 		//+1 around it
 		if c.Position-1 >= 0 {
-			AddEffect(row[c.Position-1], &Effect{c.Id, row[c.Position-1].Id, 1})
+			AddEffect(row[c.Position-1], &Effect{c.Id, row[c.Position-1].Id, 1, 1, true})
 		}
 		if c.Position+1 <= 3 {
-			AddEffect(row[c.Position+1], &Effect{c.Id, row[c.Position+1].Id, 1})
+			AddEffect(row[c.Position+1], &Effect{c.Id, row[c.Position+1].Id, 1, 1, true})
+		}
+	case Tree:
+		if c.Counters >= 5 {
+			AddEffect(row[c.Position], &Effect{c.Id, row[c.Position].Id, 1, 8, true})
 		}
 	}
+
 }
 
 func OracleLeaves(c *Card, g *Game) {
@@ -83,12 +152,12 @@ func OracleLeaves(c *Card, g *Game) {
 	}
 	row := g.GetBoard(c.Owner)
 	switch c.Type {
-	case Two:
+	case Commander:
 		//remove +1 to all
 		for _, v := range row {
 			RemoveEffect(c.Id, v)
 		}
-	case Three:
+	case Paladin:
 		//+1 around it
 		if c.Position-1 >= 0 {
 			RemoveEffect(c.Id, row[c.Position-1])
@@ -96,27 +165,52 @@ func OracleLeaves(c *Card, g *Game) {
 		if c.Position+1 <= 3 {
 			RemoveEffect(c.Id, row[c.Position+1])
 		}
-
+	case HealthPotion:
+		g.SentinalPlayer.Life = g.SentinalPlayer.Life - 1
+		g.ScourgePlayer.Life = g.ScourgePlayer.Life - 1
 	}
 	return
 }
 
 func OracleEndstep(c *Card, g *Game) {
 	switch c.Type {
-	case Eight:
+	case ShieldWall, Tree, Hologram, Clog:
 		c.Counters = c.Counters + 1
 	}
 	return
 }
 
 func OraclePower(c CardType, g *Game) int {
-	return int(c)
+	//this is horrible
+	switch c {
+	case Dud, Clog, Valk:
+		return 0
+	case Speedster, HealthPotion, Tree, Goblin, GoblinSpawn, Chupacabra:
+		return 1
+	case Commander, Ally, Enemy:
+		return 2
+	case Paladin, Duelist, Bureaucrat:
+		return 3
+	case Scholar, Vanguard, Student, Librarian:
+		return 4
+	case Warrior, Elephant:
+		return 5
+	case Fighter, Mesmerist, Diviner:
+		return 6
+	case Seven:
+		return 7
+	case ShieldWall, Hologram:
+		return 8
+	default:
+		log.Printf("played card %v without power in oracle", c)
+		return int(c)
+	}
 }
 
 func OracleMove(c *Card, src, dest int, g *Game) {
 	c.Sick = true
 	switch c.Type {
-	case Three:
+	case Paladin:
 		row := g.GetBoard(c.Owner)
 		if src-1 >= 0 {
 			RemoveEffect(c.Id, row[src-1])
@@ -127,31 +221,98 @@ func OracleMove(c *Card, src, dest int, g *Game) {
 	}
 }
 
-func OracleAttack(c *Card, g *Game) {
+func OracleAttack(c *Card, src, dest int, g *Game) {
 	c.Sick = true
+	switch c.Type {
+	case Hologram:
+		row := g.GetOpponentBoard(c.Owner)
+		if row[dest].Type == EmptyValue {
+			c.Power = 0
+		}
+	}
 }
 
 func OracleEffect(c *Card, g *Game) {
-	if c.Empty() {
-		return
-	}
 	for _, e := range c.Effects {
 		switch e.ID {
 		case 0:
 			log.Println("dummy effect applied. probably a bug")
 		case 1:
-			c.Power = c.Power + 1
+			c.Power = c.Power + e.Modifier
 		case 2:
 			if c.Owner != SentinalID && c.Owner != ScourgeID {
 				log.Println("card draw effect was played but with no owner?")
 			} else {
-				g.CardBuffer = DeckFromCards(g.GetDeck(c.Owner).Scry(1))
+				g.CardBuffer = g.GetDeck(c.Owner).Scry(1)
 			}
 			g.CanDraw = true
 			g.HasDrawn = false
 			RemoveEffect(e.Owner, c)
+		case 3:
+			c.BasePower = e.Modifier
+		case 4:
+			g.GameBoard.Remove(c)
+			g.Bury(c)
+		case 5: //+x/+0
+			if g.CurrentTurn == c.Owner {
+				c.Power = c.Power + e.Modifier
+			}
+		case 6: //+0/+x
+			if g.CurrentTurn != c.Owner {
+				c.Power = c.Power + e.Modifier
+			}
+		case 7: //+x/-x
+			if g.CurrentTurn == c.Owner {
+				c.Power = c.Power + e.Modifier
+			} else {
+				c.Power = c.Power - e.Modifier
+			}
+		case 8: //-x/+x
+			if g.CurrentTurn == c.Owner {
+				c.Power = c.Power + e.Modifier
+			} else {
+				c.Power = c.Power + e.Modifier
+			}
+		case 9: //create dud
+			RemoveEffect(e.Owner, c)
+			g.GameBoard.Replace(c, NewCard(int(Dud), c.Owner, c.Position, uuid.Nil))
+		case 10: //create clog
+			RemoveEffect(e.Owner, c)
+			log.Println("applying clog")
+			g.GameBoard.Replace(c, NewCard(int(Clog), c.Owner, c.Position, uuid.Nil))
 		default:
 			log.Println("wrong effect type")
 		}
 	}
+	if c.Power < 0 {
+		c.Power = 0
+	}
+}
+
+func OraclePlayerEffect(p *Player, g *Game) {
+	if p == nil {
+		return
+	}
+	for _, e := range p.Effects {
+		switch e.ID {
+		case 1:
+			g.CanDraw = true
+			g.HasDrawn = false
+			RemovePlayerEffect(e.Owner, p)
+		case 2:
+			g.CardBuffer = g.GetDeck(p.Id).Scry(1)
+			g.CanDraw = true
+			g.HasDrawn = false
+			RemovePlayerEffect(e.Owner, p)
+		case 3:
+			g.ScryBuffer = e.Modifier
+			g.BottomBuffer = e.Modifier - 1
+			RemovePlayerEffect(e.Owner, p)
+		case 4:
+			g.ScryBuffer = e.Modifier
+			g.CanDraw = true
+			g.HasDrawn = false
+			RemovePlayerEffect(e.Owner, p)
+		}
+	}
 }

player.go

@@ -6,10 +6,11 @@ import (
 
 func NewPlayer(name string, id int) *Player {
 	return &Player{
-		Name:  name,
-		Id:    id,
-		Hand:  []*Card{},
-		Life:  3,
-		Ready: false,
+		Name:    name,
+		Id:      id,
+		Hand:    []*Card{},
+		Life:    3,
+		Ready:   false,
+		Effects: []*Effect{},
 	}
 }