package mlp import ( "math/rand" "git.fromouter.space/mcg/draft" ) // I8PCube is a cube that uses I8Pages' pack schema. // I8Pages' cube uses different kinds of packs, so a single schema is not possible. // Therefore, I8PCube itself is not a valid set, but contains two valid sets for // both types of packs (main deck / problems) // // Infos on I8Pages' cube: // https://docs.google.com/spreadsheets/d/1Ufz4QLwLCZ1vLemAhE6cuAmu2lq_VAN7RhLO9p1opNQ type I8PCube struct { Main *I8PSet Problems *I8PSet } // I8PSet is one of the sets of packs contained in a I8PCube type I8PSet struct { Cards I8PPool Schema draft.PackSchema } // I8PType is a category of cards to be seeded into packs type I8PType string // I8PSchema is a schema to seed a single I8PCube pack type I8PSchema []I8PSchemaSlot // I8PSchemaSlot is a single slot of a I8PSchema type I8PSchemaSlot struct { Amount int Type I8PType } // All types used for seeding packs const ( I8PTypeBlue I8PType = "blue" I8PTypeOrange I8PType = "orange" I8PTypePink I8PType = "pink" I8PTypePurple I8PType = "purple" I8PTypeWhite I8PType = "white" I8PTypeYellow I8PType = "yellow" I8PTypeNone I8PType = "none" I8PTypeMulti I8PType = "multi" I8PTypeEntry I8PType = "entry" I8PTypeProblem I8PType = "problem" // Special types I8PTypeAll I8PType = "all" // all means "from any other non-problem type" ) // I8PPool is a pool of card divided into categories type I8PPool map[I8PType][]Card // MakeI8PCube takes an organized set of cards and sorts them into a draftable I8PCube func MakeI8PCube(cards I8PPool, schema I8PSchema) *I8PCube { return &I8PCube{ Main: makeMainSet(cards, schema), Problems: makeProblemSet(cards), } } func makeMainSet(cards I8PPool, schema I8PSchema) (set *I8PSet) { // Create set with the given card pool set = &I8PSet{ Cards: I8PPool{ I8PTypeBlue: cards[I8PTypeBlue], I8PTypeOrange: cards[I8PTypeOrange], I8PTypePink: cards[I8PTypePink], I8PTypePurple: cards[I8PTypePurple], I8PTypeWhite: cards[I8PTypeWhite], I8PTypeYellow: cards[I8PTypeYellow], I8PTypeNone: cards[I8PTypeNone], I8PTypeMulti: cards[I8PTypeMulti], I8PTypeEntry: cards[I8PTypeEntry], }, } // Build PackSchema from given I8PSchema var slots []draft.PackSlot for _, slot := range schema { // Check for special cases var provider draft.CardProvider switch slot.Type { case I8PTypeAll: provider = set.ProviderOther() default: provider = set.ProviderByType(slot.Type) } // Add slot slots = append(slots, draft.PackSlot{ Amount: slot.Amount, Provider: provider, }) } set.Schema = draft.PackSchema{ Slots: slots, } return } func makeProblemSet(cards I8PPool) (set *I8PSet) { set = &I8PSet{ Cards: I8PPool{ I8PTypeProblem: cards[I8PTypeProblem], }, } set.Schema = draft.PackSchema{ Slots: []draft.PackSlot{ { Amount: 12, Provider: set.ProviderByType(I8PTypeProblem), }, }, } return } // ProviderByType provides cards from a specified category func (s *I8PSet) ProviderByType(typ I8PType) draft.CardProvider { return func(n int) (out []draft.Card) { s.shuffle(typ) if len(s.Cards[typ]) < n { n = len(s.Cards[typ]) } out, s.Cards[typ] = toDraft(s.Cards[typ][:n]), s.Cards[typ][n:] return } } // ProviderOther picks a random card for any available set (except Problems) func (s *I8PSet) ProviderOther() draft.CardProvider { choices := []I8PType{ I8PTypeBlue, I8PTypeOrange, I8PTypePink, I8PTypePurple, I8PTypeWhite, I8PTypeYellow, I8PTypeNone, I8PTypeMulti, I8PTypeEntry, } return func(n int) (out []draft.Card) { // Filter types that have enough cards for what we need // n is almost always 1, so this should not introduce bias available := []I8PType{} for _, typ := range choices { if len(s.Cards[typ]) >= n { available = append(available, typ) } } // Check if there are no pools we can pick stuff from, and exit early // THIS IS NOT NORMAL, AND YOU SHOULD FIX YOUR CUBE! if len(available) < 1 { return } typ := available[rand.Intn(len(available))] return s.ProviderByType(typ)(n) } } // PackSchema returns the pack schema for building packs from a I8PCube func (s *I8PSet) PackSchema() draft.PackSchema { return s.Schema } func (s *I8PSet) shuffle(typ I8PType) { rand.Shuffle(len(s.Cards[typ]), func(i, j int) { s.Cards[typ][i], s.Cards[typ][j] = s.Cards[typ][j], s.Cards[typ][i] }) } // DefaultI8PSchema returns I8Pages' schema as specified in his docs func DefaultI8PSchema() I8PSchema { return I8PSchema{ {Amount: 1, Type: I8PTypeBlue}, {Amount: 1, Type: I8PTypeOrange}, {Amount: 1, Type: I8PTypePink}, {Amount: 1, Type: I8PTypePurple}, {Amount: 1, Type: I8PTypeWhite}, {Amount: 1, Type: I8PTypeYellow}, {Amount: 1, Type: I8PTypeNone}, {Amount: 2, Type: I8PTypeMulti}, {Amount: 2, Type: I8PTypeEntry}, {Amount: 1, Type: I8PTypeAll}, } } // PackProvider returns a PackProvider for a given number of main and problem packs func (c *I8PCube) PackProvider(mainPacks, problemPacks int) draft.PackProvider { return func() []draft.Pack { packs := make([]draft.Pack, mainPacks+problemPacks) for main := 0; main < mainPacks; main++ { packs[main] = draft.MakePack(c.Main) } for problem := 0; problem < problemPacks; problem++ { packs[mainPacks+problem] = draft.MakePack(c.Problems) } return packs } }