Browse Source

initial

master
Jeffrey Paul 4 years ago
parent
commit
66260ec52d
  1. 100
      main.go
  2. 153
      pokercore/pokercore.go
  3. 7
      pokercore/pokercore_test.go

100
main.go

@ -0,0 +1,100 @@
package main
import (
"errors"
"fmt"
log "github.com/sirupsen/logrus"
"io"
"net/http"
"net/rpc"
"net/rpc/jsonrpc"
"os"
"time"
)
type JSONRPCServer struct {
*rpc.Server
}
func NewJSONRPCServer() *JSONRPCServer {
return &JSONRPCServer{rpc.NewServer()}
}
func (s *JSONRPCServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
log.Println("rpc server got a request")
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
return
}
io.WriteString(conn, "HTTP/1.0 200 Connected to Go JSON-RPC\n\n")
codec := jsonrpc.NewServerCodec(conn)
log.Println("ServeCodec")
s.Server.ServeCodec(codec)
log.Println("finished serving request")
}
type Args struct {
A, B int
}
type Quotient struct {
Quo, Rem int
}
type Arith int
func (t *Arith) Multiply(args *Args, reply *int) error {
*reply = args.A * args.B
return nil
}
func (t *Arith) Divide(args *Args, quo *Quotient) error {
if args.B == 0 {
return errors.New("divide by zero")
}
quo.Quo = args.A / args.B
quo.Rem = args.A % args.B
return nil
}
func main() {
//log.SetFormatter(&log.JSONFormatter{})
// Output to stdout instead of the default stderr
// Can be any io.Writer, see below for File example
log.SetOutput(os.Stdout)
// Only log the warning severity or above.
//log.SetLevel(log.WarnLevel)
log.Infof("starting up")
go runHttpServer()
running := true
for running {
time.Sleep(1 * time.Second)
}
}
func runHttpServer() {
js := NewJSONRPCServer()
arith := new(Arith)
js.Register(arith)
port := 8080
listenaddr := fmt.Sprintf("0.0.0.0:%d", port)
s := &http.Server{
Addr: listenaddr,
Handler: js,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
MaxHeaderBytes: 1 << 20,
}
log.Infof("starting up http server %s", listenaddr)
log.Fatal(s.ListenAndServe())
}

153
pokercore/pokercore.go

@ -0,0 +1,153 @@
package pokercore
import "encoding/binary"
import "fmt"
import crand "crypto/rand"
import . "github.com/logrusorgru/aurora"
import log "github.com/sirupsen/logrus"
import rand "math/rand"
import "strings"
/*
const CLUB = "\u2663"
const SPADE = "\u2660"
const DIAMOND = "\u2666"
const HEART = "\u2665"
*/
const CLUB = "C"
const SPADE = "S"
const DIAMOND = "D"
const HEART = "H"
type TestGenerationIteration struct {
Deck *Deck
Seed int64
}
type Card struct {
Rank string
Suit string
}
type Cards []*Card
type Deck struct {
Cards Cards
Dealt int
ShuffleSeedVal int64
}
func cryptoUint64() (v uint64) {
err := binary.Read(crand.Reader, binary.BigEndian, &v)
if err != nil {
log.Fatal(err)
}
log.Debugf("crand cryptosource is returning Uint64: %d", v)
return v
}
func NewRandom() *rand.Rand {
trueRandom := true
var rnd *rand.Rand
seed := int64(42)
if trueRandom {
rnd = rand.New(rand.NewSource(int64(cryptoUint64())))
} else {
rnd = rand.New(rand.NewSource(seed))
}
return rnd
}
func (self *Card) String() string {
var rank string
var suit string
color := Red
switch self.Suit {
case DIAMOND:
color = Blue
case HEART:
color = Red
case CLUB:
color = Green
case SPADE:
color = Black
}
rank = fmt.Sprintf("%s", BgGray(Bold(color(self.Rank))))
suit = fmt.Sprintf("%s", BgGray(Bold(color(self.Suit))))
return fmt.Sprintf("%s%s", rank, suit)
}
func NewDeck() *Deck {
self := new(Deck)
ranks := []string{"A", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "J", "Q", "K"}
suits := []string{HEART, DIAMOND, CLUB, SPADE}
self.Cards = make([]*Card, 52)
// Loop over each type and suit appending to the deck
tot := 0
for i := 0; i < len(ranks); i++ {
for n := 0; n < len(suits); n++ {
self.Cards[tot] = &Card{
Rank: ranks[i],
Suit: suits[n],
}
tot++
}
}
self.Dealt = 0
return self
}
func (self *Deck) Shuffle() {
r := NewRandom()
r.Shuffle(len(self.Cards), func(i, j int) { self.Cards[i], self.Cards[j] = self.Cards[j], self.Cards[i] })
}
func (self *Deck) Deal(n int) (output Cards) {
if (self.Dealt + n) > len(self.Cards) {
return output
}
for i := 0; i < n; i++ {
card := self.Cards[self.Dealt+1]
output = append(output, card)
self.Dealt++
}
return output
}
func (s Cards) String() (output string) {
var cardstrings []string
for i := 0; i < len(s); i++ {
cardstrings = append(cardstrings, s[i].String())
}
output = strings.Join(cardstrings, ",")
return output
}
func main2() {
log.SetLevel(log.DebugLevel)
myDeck := NewDeck()
myDeck.Shuffle()
myHand := myDeck.Deal(2)
//spew.Dump(myHand)
fmt.Printf("my hand: %s\n", myHand)
cmty := myDeck.Deal(5)
fmt.Printf("community: %s\n", cmty)
}

7
pokercore/pokercore_test.go

@ -0,0 +1,7 @@
package pokercore
import "testing"
func TestPokerHand(t *testing.T) {
//test stuff here
}
Loading…
Cancel
Save