Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

werewolf

package module

Go to main page

Versions in this module

v1

v1.0.0

Dec 24, 2025

Changes in this version

+ var ErrGameEnded = &GameError

+ var ErrGameNotStarted = &GameError

+ var ErrInvalidPhase = &GameError

+ var ErrPlayerDead = &GameError

+ var ErrPlayerNotFound = &GameError

+ var ErrSkillNotAllowed = &GameError

+ var ErrTargetDead = &GameError

+ var ErrTargetNotFound = &GameError

+ func GetErrorCode(err error) pb.ErrorCode

+ func IsErrorCode(err error, code pb.ErrorCode) bool

+ type DayResolver struct

+ func NewDayResolver() *DayResolver

+ func (r *DayResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type Effect struct

+ Canceled bool

+ Data map[string]interface{}

+ Reason string

+ SourceID string

+ TargetID string

+ Type pb.EventType

+ func NewEffect(eventType pb.EventType, sourceID, targetID string) *Effect

+ func (e *Effect) Cancel(reason string)

+ func (e *Effect) ToEvent() *pb.Event

+ func (e *Effect) WithData(key string, value interface{}) *Effect

type Engine

+ func (e *Engine) EndPhase() ([]*Effect, error)

+ func (e *Engine) EndSubStep() ([]*Effect, error)

+ func (e *Engine) GetAllowedSkills(playerID string) []pb.SkillType

+ func (e *Engine) GetCurrentPhase() pb.PhaseType

+ func (e *Engine) GetCurrentRound() int

+ func (e *Engine) GetCurrentSubStep() int

+ func (e *Engine) GetNightKillTarget() string

+ func (e *Engine) GetWolfTeammates(playerID string) []string

+ func (e *Engine) IsGameOver() bool

+ func (e *Engine) OnEvent(handler EventHandler)

+ func (e *Engine) StartSubStepMode() error

+ func (e *Engine) SubmitSkillUse(use *SkillUse) error

+ type GameConfig struct

+ DefaultTimeout time.Duration

+ GuardCanProtectSelf bool

+ GuardCanRepeat bool

+ Phases map[pb.PhaseType]*PhaseConfig

+ SameGuardKillIsEmpty bool

+ WitchCanSaveSelf bool

+ func DefaultGameConfig() *GameConfig

+ func SubStepGameConfig() *GameConfig

+ type GameError struct

+ Code pb.ErrorCode

+ Message string

+ func NewGameError(code pb.ErrorCode, message string) *GameError

+ func WrapError(code pb.ErrorCode, format string, args ...interface{}) *GameError

+ func (e *GameError) Error() string

+ type GuardResolver struct

+ func NewGuardResolver() *GuardResolver

+ func (r *GuardResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type NightResolver struct

+ func NewNightResolver() *NightResolver

+ func (r *NightResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type Phase struct

+ func NewPhase(config *GameConfig) *Phase

+ func (p *Phase) GetAllowedSkills(phase pb.PhaseType, role pb.RoleType) []pb.SkillType

+ func (p *Phase) GetAllowedSkillsForSubStep(phase pb.PhaseType, subStep int, role pb.RoleType) []pb.SkillType

+ func (p *Phase) GetCurrentStepRole(phase pb.PhaseType, subStep int) pb.RoleType

+ func (p *Phase) GetPhaseConfig(phase pb.PhaseType) *PhaseConfig

+ func (p *Phase) GetRequiredRoles(phase pb.PhaseType) []pb.RoleType

+ func (p *Phase) GetResolver(phase pb.PhaseType) Resolver

+ func (p *Phase) NextPhase(current pb.PhaseType) pb.PhaseType

+ func (p *Phase) NextSubPhase(current pb.PhaseType) pb.PhaseType

+ func (p *Phase) ValidateSkillUse(use *SkillUse, state *State) error

+ func (p *Phase) ValidateSkillUseForSubStep(use *SkillUse, state *State) error

+ type PhaseConfig struct

+ Steps []PhaseStep

+ Timeout time.Duration

+ Type pb.PhaseType

+ func NightGuardPhase() *PhaseConfig

+ func NightSeerPhase() *PhaseConfig

+ func NightWitchPhase() *PhaseConfig

+ func NightWolfPhase() *PhaseConfig

+ func StandardDayPhase() *PhaseConfig

+ func StandardNightPhase() *PhaseConfig

+ func StandardVotePhase() *PhaseConfig

+ type PhaseStep struct

+ Multiple bool

+ Order int

+ Required bool

+ Role pb.RoleType

+ Skill pb.SkillType

type PlayerState

+ Alive bool

+ Camp pb.Camp

+ Protected bool

+ type Resolver interface

+ Resolve func(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type SeerResolver struct

+ func NewSeerResolver() *SeerResolver

+ func (r *SeerResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type SkillUse struct

+ Phase pb.PhaseType

+ PlayerID string

+ Round int

+ Skill pb.SkillType

+ TargetID string

+ type State struct

+ NightKillTarget string

+ Phase pb.PhaseType

+ Players map[string]*PlayerState

+ Round int

+ SubStep int

+ func NewState() *State

+ func (s *State) AddPlayer(id string, role pb.RoleType, camp pb.Camp)

+ func (s *State) ApplyEffect(effect *Effect)

+ func (s *State) CheckVictory() (bool, pb.Camp)

+ func (s *State) GetAlivePlayers() []*PlayerState

+ func (s *State) GetAlivePlayersByCamp(camp pb.Camp) []*PlayerState

+ func (s *State) GetAlivePlayersByRole(role pb.RoleType) []*PlayerState

+ func (s *State) GetPlayer(id string) (*PlayerState, bool)

+ func (s *State) GetWolfTeammates(playerID string) []string

+ func (s *State) NextPhase(phase pb.PhaseType)

+ func (s *State) ResetRoundState()

+ type VoteResolver struct

+ func NewVoteResolver() *VoteResolver

+ func (r *VoteResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type WitchResolver struct

+ func NewWitchResolver() *WitchResolver

+ func (r *WitchResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

+ type WolfResolver struct

+ func NewWolfResolver() *WolfResolver

+ func (r *WolfResolver) Resolve(uses []*SkillUse, state *State, config *GameConfig) []*Effect

v0

v0.0.1

Dec 10, 2025

Changes in this version

+ type ActionType string

+ const ActionAntidote

+ const ActionCheck

+ const ActionKill

+ const ActionLastWords

+ const ActionPoison

+ const ActionProtect

+ const ActionShoot

+ const ActionSpeak

+ const ActionVote

+ type Camp int

+ const CampEvil

+ const CampGood

+ const CampNone

+ func (c Camp) String() string

+ type Config struct

+ EnableLastWords bool

+ Roles []RoleType

+ type Engine struct

+ func NewEngine(config Config) *Engine

+ func (e *Engine) AddPlayer(playerID string) error

+ func (e *Engine) AdvancePhase(nextPhase PhaseType) error

+ func (e *Engine) CheckWinCondition() Camp

+ func (e *Engine) EndGame(winner Camp)

+ func (e *Engine) GetPlayerState(playerID string) (PlayerState, error)

+ func (e *Engine) GetState() GameState

+ func (e *Engine) KillPlayer(playerID string, reason string) error

+ func (e *Engine) PerformAction(playerID string, actionType ActionType, targetID string, ...) error

+ func (e *Engine) Start() error

+ func (e *Engine) Subscribe(eventType EventType, handler EventHandler) SubscriptionID

+ func (e *Engine) Unsubscribe(id SubscriptionID)

+ type Event struct

+ Data interface{}

+ Timestamp time.Time

+ Type EventType

+ type EventHandler func(event Event)

+ type EventType = event.EventType

+ const EventActionExecuted

+ const EventGameEnded

+ const EventGameStarted

+ const EventHunterShot

+ const EventLastWords

+ const EventPhaseEnded

+ const EventPhaseStarted

+ const EventPlayerDied

+ const EventPlayerProtected

+ const EventPlayerRevived

+ const EventRoundChanged

+ const EventSkillUsed

+ const EventVoteResult

+ type GameState struct

+ AlivePlayers []string

+ IsEnded bool

+ Phase PhaseType

+ Players []PlayerState

+ Round int

+ Winner Camp

+ type PhaseType string

+ const PhaseDay

+ const PhaseEnd

+ const PhaseNight

+ const PhaseNone

+ const PhaseStart

+ const PhaseVote

+ type PlayerState struct

+ ID string

+ IsAlive bool

+ IsProtected bool

+ Role RoleType

+ type Role interface

+ GetAvailableSkills func(phase PhaseType) []Skill

+ GetCamp func() Camp

+ GetName func() RoleType

+ GetPriority func(phase PhaseType) int

+ type RoleType string

+ const RoleTypeGuard

+ const RoleTypeHunter

+ const RoleTypeSeer

+ const RoleTypeVillager

+ const RoleTypeWerewolf

+ const RoleTypeWitch

+ func (r RoleType) String() string

+ type Skill interface

+ CanUseMultipleTimes func() bool

+ GetName func() SkillType

+ GetPhase func() PhaseType

+ GetPriority func() int

+ RequiresTarget func() bool

+ type SkillType string

+ const SkillTypeAntidote

+ const SkillTypeCheck

+ const SkillTypeKill

+ const SkillTypePoison

+ const SkillTypeProtect

+ const SkillTypeShoot

+ const SkillTypeSpeak

+ const SkillTypeVote

+ func (s SkillType) String() string

+ type SubscriptionID string