First Stages Implemented (Pool, Seedings)

astro/services/Pool.go

@@ -6,8 +6,18 @@ type Pool struct {
 	PoolID      uint8 // 255 pools max
 	PoolState   State
 	PoolMaxSize uint16
-	PoolPlayers []Player
-	PoolReferee Referee
+	PoolSize    uint16
+	PoolPlayers map[uint16]*Player
+	PoolReferee *Referee
+}
+
+type PoolStage struct {
+	PoolStageID              uint8
+	PoolStageSize            uint16
+	PoolPlayers              map[uint16]*Player
+	PoolStagePools           map[uint8]*Pool
+	PoolStageState           State
+	PoolEnteringPlayerNumber uint16
 }
 
 func (p Pool) String() string {
@@ -22,60 +32,261 @@ func (p Pool) String() string {
 	return s
 }
 
-func CreateStage(poolID uint8, poolMaxSize uint16) Pool {
-	var p Pool
+func CreatePoolStage(poolStageID uint8, enteringPlayerNumber uint16, leavingPlayerNumber uint16) PoolStage {
+	var s PoolStage
 
-	p.PoolID = poolID
-	p.PoolState = IDLE
-	p.PoolMaxSize = poolMaxSize
-	p.PoolPlayers = make([]Player, poolMaxSize)
-	p.PoolReferee = Referee{}
+	s.PoolStageID = poolStageID
+	s.PoolEnteringPlayerNumber = enteringPlayerNumber
+	s.PoolPlayers = make(map[uint16]*Player)
+	s.PoolStagePools = make(map[uint8]*Pool)
+	s.PoolStageState = IDLE
+	s.PoolStageSize = 0
 
-	return p
+	return s
 }
 
-func (p Pool) PlayerPosition(player Player) uint16 {
-	for i, poolPlayer := range p.PoolPlayers {
-		if poolPlayer.PlayerID == player.PlayerID {
-			return uint16(i)
+// From interface
+func (p *PoolStage) PlayerPosition(player *Player) uint16 {
+	for _, pool := range p.PoolStagePools {
+		if pool.PlayerPosition(player) != math.MaxInt16 {
+			return pool.PlayerPosition(player)
 		}
 	}
 
 	return math.MaxInt16
 }
 
-func (p *Pool) AddPlayer(player Player) bool {
-	if p.PoolState != IDLE {
+// From interface
+func (p *PoolStage) AddPlayer(player *Player) bool {
+	if p.PoolStageState != REGISTERING {
 		return false
 	}
 
-	if len(p.PoolPlayers) >= int(p.PoolMaxSize) {
+	if p.PlayerPosition(player) != math.MaxInt16 {
+		return false
+	}
+
+	for _, pool := range p.PoolStagePools {
+		if pool.AddPlayer(player) {
+			p.PoolPlayers[player.PlayerID] = player
+			p.PoolStageSize++
+
+			pool.PoolSize++
+			return true
+		}
+	}
+
+	// Add pool
+	pool := &Pool{
+		PoolID:      uint8(len(p.PoolStagePools)),
+		PoolState:   REGISTERING,
+		PoolMaxSize: 7,
+		PoolSize:    0,
+		PoolPlayers: make(map[uint16]*Player),
+		PoolReferee: nil,
+	}
+
+	pool.AddPlayer(player)
+
+	p.AddPool(pool)
+	p.PoolPlayers[player.PlayerID] = player
+
+	return true
+}
+
+// From interface
+func (p *PoolStage) RemovePlayer(player *Player) bool {
+	if p.PoolStageState != REGISTERING {
 		return false
 	}
 
 	if p.PlayerPosition(player) == math.MaxInt16 {
-		p.PoolPlayers = append(p.PoolPlayers, player)
-		return true
+		return false
+	}
+
+	for _, pool := range p.PoolStagePools {
+		if pool.RemovePlayer(player) {
+			delete(p.PoolPlayers, player.PlayerID)
+			p.PoolStageSize--
+
+			pool.PoolSize--
+
+			if pool.PoolSize == 0 {
+				p.RemovePool(pool)
+			}
+
+			return true
+		}
 	}
 
 	return false
 }
 
-func (p *Pool) RemovePlayer(player Player) bool {
-	if p.PoolState != IDLE {
+// From interface
+func (p *PoolStage) GetID() uint8 {
+	return p.PoolStageID
+}
+
+// From interface
+func (p *PoolStage) GetState() State {
+	return p.PoolStageState
+}
+
+// From interface
+func (p *PoolStage) GetPlayers() []*Player {
+	players := []*Player{}
+
+	for _, player := range p.PoolPlayers {
+		players = append(players, player)
+	}
+
+	return players
+}
+
+// From interface
+func (p *PoolStage) Register() bool {
+	if p.PoolStageState != IDLE {
 		return false
 	}
 
-	pos := p.PlayerPosition(player)
+	p.PoolStageState = REGISTERING
+
+	return true
+}
+
+// From interface
+func (p *PoolStage) Start() bool {
+	if p.PoolStageState != REGISTERING {
+		return false
+	}
 
-	if pos != math.MaxInt16 {
-		p.PoolPlayers = append(p.PoolPlayers[:pos], p.PoolPlayers[pos+1:]...)
-		return true
+	if p.PoolStageSize < p.PoolEnteringPlayerNumber {
+		return false
 	}
 
+	p.PoolStageState = STARTED
+
+	return true
+}
+
+// From interface
+func (p *PoolStage) End() bool {
+	if p.PoolStageState != STARTED {
+		return false
+	}
+
+	p.PoolStageState = FINISHED
+
+	return true
+}
+
+// From interface
+func (p *PoolStage) Lock() bool {
+	if p.PoolStageState != FINISHED {
+		return false
+	}
+
+	p.PoolStageState = LOCKED
+
+	return true
+}
+
+// From interface
+func (p *PoolStage) Build() bool {
+	// TODO: Implement
 	return false
 }
 
-func (p *Pool) SetReferee(referee Referee) {
+func (p *PoolStage) AddPool(pool *Pool) bool {
+	if p.PoolStageState != REGISTERING {
+		return false
+	}
+
+	if pool == nil {
+		return false
+	}
+
+	p.PoolStagePools[pool.PoolID] = pool
+
+	return true
+}
+
+func (p *PoolStage) RemovePool(pool *Pool) bool {
+	if p.PoolStageState != REGISTERING {
+		return false
+	}
+
+	if pool == nil {
+		return false
+	}
+
+	if pool.PoolSize > 0 {
+		return false
+	}
+
+	delete(p.PoolStagePools, pool.PoolID)
+
+	return true
+}
+
+func (p *PoolStage) GetPool(poolID uint8) *Pool {
+	pool, ok := p.PoolStagePools[poolID]
+	if ok {
+		return pool
+	}
+
+	return nil
+}
+
+// ------------------------------ Pool ------------------------------
+func (p Pool) PlayerPosition(player *Player) uint16 {
+	_, ok := p.PoolPlayers[player.PlayerID]
+	if ok {
+		return p.PoolPlayers[player.PlayerID].PlayerID
+	}
+
+	return math.MaxInt16
+}
+
+func (p *Pool) AddPlayer(player *Player) bool {
+	if p.PoolState != REGISTERING {
+		return false
+	}
+
+	if p.PoolSize >= p.PoolMaxSize {
+		return false
+	}
+
+	if p.PlayerPosition(player) != math.MaxInt16 {
+		return false
+	}
+
+	p.PoolPlayers[p.PoolSize] = player
+	p.PoolSize++
+
+	return true
+}
+
+func (p *Pool) RemovePlayer(player *Player) bool {
+	if p.PoolState != REGISTERING {
+		return false
+	}
+
+	if p.PlayerPosition(player) == math.MaxInt16 {
+		return false
+	}
+
+	delete(p.PoolPlayers, player.PlayerID)
+
+	return true
+}
+
+func (p *Pool) SetReferee(referee *Referee) bool {
+	if p.PoolState != REGISTERING {
+		return false
+	}
+
 	p.PoolReferee = referee
+
+	return true
 }

astro/services/Seeding.go

+package services
+
+// Seeding : Seeding details
+type Seeding struct {
+	SeedingPosition uint16
+	SeedingPlayer   *Player
+}
+
+type SeedingStage struct {
+	SeedingStageID              uint8
+	SeedingSize                 uint16
+	SeedingSeedings             map[uint16]*Seeding
+	SeedingState                State
+	SeedingEnteringPlayerNumber uint16
+}
+
+func (s *SeedingStage) String() string {
+	var str string
+
+	str = string(s.SeedingStageID) + " - " + s.SeedingState.String()
+
+	for _, seeding := range s.SeedingSeedings {
+		str = str + "\n" + seeding.SeedingPlayer.String()
+	}
+
+	return str
+}
+
+func CreateSeedingStage(seedingStageID uint8, enteringPlayerNumber uint16, leavingPlayerNumber uint16) SeedingStage {
+	var s SeedingStage
+
+	s.SeedingStageID = seedingStageID
+	s.SeedingEnteringPlayerNumber = enteringPlayerNumber
+	s.SeedingSeedings = make(map[uint16]*Seeding)
+	s.SeedingState = IDLE
+	s.SeedingSize = 0
+
+	return s
+}
+
+// From interface
+func (s *SeedingStage) PlayerPosition(player Player) uint16 {
+	return s.SeedingSeedings[player.PlayerID].SeedingPosition
+}
+
+// From interface
+func (s *SeedingStage) AddPlayer(player Player) bool {
+	if s.SeedingState != REGISTERING {
+		return false
+	}
+
+	if s.SeedingSeedings[player.PlayerID] != nil {
+		return false
+	}
+
+	s.SeedingSeedings[player.PlayerID] = &Seeding{
+		SeedingPosition: s.SeedingSize,
+		SeedingPlayer:   &player,
+	}
+
+	s.SeedingSize++
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) RemovePlayer(player Player) bool {
+	if s.SeedingState != REGISTERING {
+		return false
+	}
+
+	if s.SeedingSeedings[player.PlayerID] == nil {
+		return false
+	}
+
+	delete(s.SeedingSeedings, player.PlayerID)
+
+	s.SeedingSize--
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) GetID() uint8 {
+	return s.SeedingStageID
+}
+
+// From interface
+func (s *SeedingStage) GetState() State {
+	return s.SeedingState
+}
+
+// From interface
+func (s *SeedingStage) GetPlayers() []Player {
+	players := []Player{}
+
+	for _, seeding := range s.SeedingSeedings {
+		players = append(players, *seeding.SeedingPlayer)
+	}
+
+	return players
+}
+
+// From interface
+func (s *SeedingStage) Register() bool {
+	if s.SeedingState != IDLE {
+		return false
+	}
+
+	s.SeedingState = REGISTERING
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) Start() bool {
+	if s.SeedingState != REGISTERING {
+		return false
+	}
+
+	if s.SeedingSize != s.SeedingEnteringPlayerNumber {
+		return false
+	}
+
+	s.SeedingState = STARTED
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) End() bool {
+	if s.SeedingState != STARTED {
+		return false
+	}
+
+	s.SeedingState = FINISHED
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) Lock() bool {
+	if s.SeedingState != FINISHED {
+		return false
+	}
+
+	s.SeedingState = LOCKED
+
+	return true
+}
+
+// From interface
+func (s *SeedingStage) Build() bool {
+	if s.SeedingState != REGISTERING {
+		return false
+	}
+
+	if s.SeedingSize != s.SeedingEnteringPlayerNumber {
+		return false
+	}
+
+	return true
+}

astro/services/Stage.go

@@ -2,9 +2,15 @@ package services
 
 // Stage : Stage details
 type Stage interface {
-	CreateStage(stageID uint8, stageMaxSize uint16) Stage
 	PlayerPosition(player Player) uint16
 	AddPlayer(player Player) bool
 	RemovePlayer(player Player) bool
 	GetID() uint8
+	GetState() State
+	GetPlayers() []Player
+	Register() bool
+	Start() bool
+	End() bool
+	Lock() bool
+	Build() bool
 }

astro/services/Util.go

@@ -107,7 +107,8 @@ const (
 	REGISTERING State = iota // 0
 	STARTED                  // 1
 	FINISHED                 // 2
-	IDLE                     // 3
+	LOCKED                   // 3
+	IDLE                     // 4
 )
 
 func (s State) String() string {
@@ -118,6 +119,8 @@ func (s State) String() string {
 		return "Started"
 	case FINISHED:
 		return "Finished"
+	case LOCKED:
+		return "Locked"
 	case IDLE:
 		return "Idle"
 	default: