diff --git a/object/enums.go b/enum/enums.go similarity index 53% rename from object/enums.go rename to enum/enums.go index f946a91..5cb27fe 100644 --- a/object/enums.go +++ b/enum/enums.go @@ -1,13 +1,18 @@ -package object +package enum import ( "encoding/json" "fmt" + "math/bits" "strconv" "strings" ) -type enum[T ~uint32] interface { +type number interface { + ~uint64 | ~uint32 | ~uint16 | ~uint8 +} + +type Enum[T number] interface { json.Marshaler Has(c2 T) bool HasAny(c2 T) bool @@ -15,9 +20,14 @@ type enum[T ~uint32] interface { String() string } -func splitBits[T ~uint32](v T) (out []T) { - for i := 0; i < 32; i++ { - v2 := T(1 << i) +func bitSize[T number]() int { + var zero T + return bits.OnesCount64(uint64(^zero)) +} + +func SplitBits[T number](v T) (out []T) { + for i := 0; i < bitSize[T](); i++ { + v2 := T(1) << i if v&v2 != 0 { out = append(out, v2) } @@ -25,10 +35,10 @@ func splitBits[T ~uint32](v T) (out []T) { return } -func stringBits(v uint32, names []string) string { +func StringBits[T number](v T, names []string) string { var out []string - for i := 0; i < 32; i++ { - v2 := uint32(1 << i) + for i := 0; i < bitSize[T](); i++ { + v2 := T(1) << i if v&v2 != 0 { if i < len(names) { out = append(out, names[i]) @@ -40,10 +50,10 @@ func stringBits(v uint32, names []string) string { return strings.Join(out, " | ") } -func stringBitsRaw(v uint32) string { +func StringBitsRaw[T number](v T) string { var out []string - for i := 0; i < 32; i++ { - v2 := uint32(1 << i) + for i := 0; i < bitSize[T](); i++ { + v2 := T(1) << i if v&v2 != 0 { out = append(out, "0x"+strconv.FormatUint(uint64(v2), 16)) } @@ -51,7 +61,7 @@ func stringBitsRaw(v uint32) string { return strings.Join(out, " | ") } -func parseEnum(ename string, s string, names []string) (uint32, error) { +func Parse[T number](ename string, s string, names []string) (T, error) { s = strings.ToUpper(s) if s == "" || s == "NULL" { return 0, nil @@ -64,14 +74,14 @@ func parseEnum(ename string, s string, names []string) (uint32, error) { return 0, fmt.Errorf("invalid %s name: %q", ename, s) } -func parseEnumSet(ename string, s string, names []string) (uint32, error) { +func ParseSet[T number](ename string, s string, names []string) (T, error) { var ( - out uint32 + out T last error ) for _, w := range strings.Split(s, "+") { w = strings.TrimSpace(w) - v, err := parseEnum(ename, w, names) + v, err := Parse[T](ename, w, names) if err != nil { last = err } @@ -80,7 +90,7 @@ func parseEnumSet(ename string, s string, names []string) (uint32, error) { return out, last } -func parseEnumMulti(ename string, s string, lists [][]string) (uint32, error) { +func ParseMulti[T number](ename string, s string, lists [][]string) (T, error) { s = strings.ToUpper(s) if s == "" || s == "NULL" { return 0, nil @@ -95,14 +105,14 @@ func parseEnumMulti(ename string, s string, lists [][]string) (uint32, error) { return 0, fmt.Errorf("invalid %s name: %q", ename, s) } -func parseEnumSetMulti(ename string, s string, lists [][]string) (uint32, error) { +func ParseSetMulti[T number](ename string, s string, lists [][]string) (T, error) { var ( - out uint32 + out T last error ) for _, w := range strings.Split(s, "+") { w = strings.TrimSpace(w) - v, err := parseEnumMulti(ename, w, lists) + v, err := ParseMulti[T](ename, w, lists) if err != nil { last = err } @@ -110,3 +120,11 @@ func parseEnumSetMulti(ename string, s string, lists [][]string) (uint32, error) } return out, last } + +func MarshalJSONArray[E interface{ Split() []T }, T interface{ String() string }](v E) ([]byte, error) { + var arr []string + for _, s := range v.Split() { + arr = append(arr, s.String()) + } + return json.Marshal(arr) +} diff --git a/object/class.go b/object/class.go index 180b9d7..33162ae 100644 --- a/object/class.go +++ b/object/class.go @@ -1,7 +1,7 @@ package object import ( - "encoding/json" + "github.com/noxworld-dev/opennox-lib/enum" ) var ClassNames = []string{ @@ -47,16 +47,14 @@ var goClassNames = []string{ "ClassPickup", } -var _ enum[Class] = Class(0) +var _ enum.Enum[Class] = Class(0) func ParseClass(s string) (Class, error) { - v, err := parseEnum("class", s, ClassNames) - return Class(v), err + return enum.Parse[Class]("class", s, ClassNames) } func ParseClassSet(s string) (Class, error) { - v, err := parseEnumSet("class", s, ClassNames) - return Class(v), err + return enum.ParseSet[Class]("class", s, ClassNames) } type Class uint32 @@ -110,21 +108,17 @@ func (c Class) HasAny(c2 Class) bool { } func (c Class) Split() []Class { - return splitBits(c) + return enum.SplitBits(c) } func (c Class) String() string { - return stringBits(uint32(c), ClassNames) + return enum.StringBits(uint32(c), ClassNames) } func (c Class) GoString() string { - return stringBits(uint32(c), goClassNames) + return enum.StringBits(uint32(c), goClassNames) } func (c Class) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/flags.go b/object/flags.go index 38b1ae9..19c804e 100644 --- a/object/flags.go +++ b/object/flags.go @@ -3,6 +3,8 @@ package object import ( "encoding/json" "strings" + + "github.com/noxworld-dev/opennox-lib/enum" ) var FlagsNames = []string{ @@ -16,16 +18,14 @@ var FlagsNames = []string{ "NO_AUTO_DROP", "FLICKER", "SELECTED", "MARKED", } -var _ enum[Flags] = Flags(0) +var _ enum.Enum[Flags] = Flags(0) func ParseFlag(s string) (Flags, error) { - v, err := parseEnum("flag", s, FlagsNames) - return Flags(v), err + return enum.Parse[Flags]("flag", s, FlagsNames) } func ParseFlagSet(s string) (Flags, error) { - v, err := parseEnumSet("flag", s, FlagsNames) - return Flags(v), err + return enum.ParseSet[Flags]("flag", s, FlagsNames) } type Flags uint32 diff --git a/object/material.go b/object/material.go index d68ca73..3bb84c0 100644 --- a/object/material.go +++ b/object/material.go @@ -1,7 +1,7 @@ package object import ( - "encoding/json" + "github.com/noxworld-dev/opennox-lib/enum" ) var MaterialNames = []string{ @@ -9,16 +9,14 @@ var MaterialNames = []string{ "GLASS", "PAPER", "SNOW", "MUD", "MAGIC", "DIAMOND", "NONE", } -var _ enum[Material] = Material(0) +var _ enum.Enum[Material] = Material(0) func ParseMaterial(s string) (Material, error) { - v, err := parseEnum("material", s, MaterialNames) - return Material(v), err + return enum.Parse[Material]("material", s, MaterialNames) } func ParseMaterialSet(s string) (Material, error) { - v, err := parseEnumSet("material", s, MaterialNames) - return Material(v), err + return enum.ParseSet[Material]("material", s, MaterialNames) } type Material uint32 @@ -50,17 +48,13 @@ func (c Material) HasAny(c2 Material) bool { } func (c Material) Split() []Material { - return splitBits(c) + return enum.SplitBits(c) } func (c Material) String() string { - return stringBits(uint32(c), MaterialNames) + return enum.StringBits(c, MaterialNames) } func (c Material) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass.go b/object/subclass.go index 8d271da..977ef34 100644 --- a/object/subclass.go +++ b/object/subclass.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var SubClassNames = [][]string{ ArmorClassNames, @@ -15,16 +17,14 @@ var SubClassNames = [][]string{ } func ParseSubClass(s string) (SubClass, error) { - v, err := parseEnumMulti("subclass", s, SubClassNames) - return SubClass(v), err + return enum.ParseMulti[SubClass]("subclass", s, SubClassNames) } func ParseSubClassSet(s string) (SubClass, error) { - v, err := parseEnumSetMulti("subclass", s, SubClassNames) - return SubClass(v), err + return enum.ParseSetMulti[SubClass]("subclass", s, SubClassNames) } -var _ enum[SubClass] = SubClass(0) +var _ enum.Enum[SubClass] = SubClass(0) type SubClass uint32 @@ -37,17 +37,13 @@ func (c SubClass) HasAny(c2 SubClass) bool { } func (c SubClass) Split() []SubClass { - return splitBits(c) + return enum.SplitBits(c) } func (c SubClass) String() string { - return stringBitsRaw(uint32(c)) + return enum.StringBitsRaw(c) } func (c SubClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_armor.go b/object/subclass_armor.go index d39c4d7..f21fa89 100644 --- a/object/subclass_armor.go +++ b/object/subclass_armor.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var ArmorClassNames = []string{ "HELMET", "SHIELD", "BREASTPLATE", "ARM_ARMOR", "PANTS", "BOOTS", "SHIRT", "LEG_ARMOR", "BACK", @@ -11,16 +13,14 @@ func (c SubClass) AsArmor() ArmorClass { } func ParseArmorClass(s string) (ArmorClass, error) { - v, err := parseEnum("armor class", s, ArmorClassNames) - return ArmorClass(v), err + return enum.Parse[ArmorClass]("armor class", s, ArmorClassNames) } func ParseArmorClassSet(s string) (ArmorClass, error) { - v, err := parseEnumSet("armor class", s, ArmorClassNames) - return ArmorClass(v), err + return enum.ParseSet[ArmorClass]("armor class", s, ArmorClassNames) } -var _ enum[ArmorClass] = ArmorClass(0) +var _ enum.Enum[ArmorClass] = ArmorClass(0) type ArmorClass uint32 @@ -45,17 +45,13 @@ func (c ArmorClass) HasAny(c2 ArmorClass) bool { } func (c ArmorClass) Split() []ArmorClass { - return splitBits(c) + return enum.SplitBits(c) } func (c ArmorClass) String() string { - return stringBits(uint32(c), ArmorClassNames) + return enum.StringBits(c, ArmorClassNames) } func (c ArmorClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_book.go b/object/subclass_book.go index b362159..ff525a1 100644 --- a/object/subclass_book.go +++ b/object/subclass_book.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var BookClassNames = []string{ "SPELL_BOOK", @@ -13,16 +15,14 @@ func (c SubClass) AsBook() BookClass { } func ParseBookClass(s string) (BookClass, error) { - v, err := parseEnum("book class", s, BookClassNames) - return BookClass(v), err + return enum.Parse[BookClass]("book class", s, BookClassNames) } func ParseBookClassSet(s string) (BookClass, error) { - v, err := parseEnumSet("book class", s, BookClassNames) - return BookClass(v), err + return enum.ParseSet[BookClass]("book class", s, BookClassNames) } -var _ enum[BookClass] = BookClass(0) +var _ enum.Enum[BookClass] = BookClass(0) type BookClass uint32 @@ -41,17 +41,13 @@ func (c BookClass) HasAny(c2 BookClass) bool { } func (c BookClass) Split() []BookClass { - return splitBits(c) + return enum.SplitBits(c) } func (c BookClass) String() string { - return stringBits(uint32(c), BookClassNames) + return enum.StringBits(c, BookClassNames) } func (c BookClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_exit.go b/object/subclass_exit.go index 5b2e582..8d80229 100644 --- a/object/subclass_exit.go +++ b/object/subclass_exit.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var ExitClassNames = []string{ "QUEST_EXIT", @@ -12,16 +14,14 @@ func (c SubClass) AsExit() ExitClass { } func ParseExitClass(s string) (ExitClass, error) { - v, err := parseEnum("exit class", s, ExitClassNames) - return ExitClass(v), err + return enum.Parse[ExitClass]("exit class", s, ExitClassNames) } func ParseExitClassSet(s string) (ExitClass, error) { - v, err := parseEnumSet("exit class", s, ExitClassNames) - return ExitClass(v), err + return enum.ParseSet[ExitClass]("exit class", s, ExitClassNames) } -var _ enum[ExitClass] = ExitClass(0) +var _ enum.Enum[ExitClass] = ExitClass(0) type ExitClass uint32 @@ -39,17 +39,13 @@ func (c ExitClass) HasAny(c2 ExitClass) bool { } func (c ExitClass) Split() []ExitClass { - return splitBits(c) + return enum.SplitBits(c) } func (c ExitClass) String() string { - return stringBits(uint32(c), ExitClassNames) + return enum.StringBits(c, ExitClassNames) } func (c ExitClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_food.go b/object/subclass_food.go index f5c03b3..3c157bc 100644 --- a/object/subclass_food.go +++ b/object/subclass_food.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var FoodClassNames = []string{ "SIMPLE", "APPLE", "JUG", @@ -16,16 +18,14 @@ func (c SubClass) AsFood() FoodClass { } func ParseFoodClass(s string) (FoodClass, error) { - v, err := parseEnum("food class", s, FoodClassNames) - return FoodClass(v), err + return enum.Parse[FoodClass]("food class", s, FoodClassNames) } func ParseFoodClassSet(s string) (FoodClass, error) { - v, err := parseEnumSet("food class", s, FoodClassNames) - return FoodClass(v), err + return enum.ParseSet[FoodClass]("food class", s, FoodClassNames) } -var _ enum[FoodClass] = FoodClass(0) +var _ enum.Enum[FoodClass] = FoodClass(0) type FoodClass uint32 @@ -58,17 +58,13 @@ func (c FoodClass) HasAny(c2 FoodClass) bool { } func (c FoodClass) Split() []FoodClass { - return splitBits(c) + return enum.SplitBits(c) } func (c FoodClass) String() string { - return stringBits(uint32(c), FoodClassNames) + return enum.StringBits(c, FoodClassNames) } func (c FoodClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_generator.go b/object/subclass_generator.go index 00b579c..0cdb3d2 100644 --- a/object/subclass_generator.go +++ b/object/subclass_generator.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var GeneratorClassNames = []string{ "GENERATOR_NW", @@ -14,16 +16,14 @@ func (c SubClass) AsGenerator() GeneratorClass { } func ParseGeneratorClass(s string) (GeneratorClass, error) { - v, err := parseEnum("generator class", s, GeneratorClassNames) - return GeneratorClass(v), err + return enum.Parse[GeneratorClass]("generator class", s, GeneratorClassNames) } func ParseGeneratorClassSet(s string) (GeneratorClass, error) { - v, err := parseEnumSet("generator class", s, GeneratorClassNames) - return GeneratorClass(v), err + return enum.ParseSet[GeneratorClass]("generator class", s, GeneratorClassNames) } -var _ enum[GeneratorClass] = GeneratorClass(0) +var _ enum.Enum[GeneratorClass] = GeneratorClass(0) type GeneratorClass uint32 @@ -43,17 +43,13 @@ func (c GeneratorClass) HasAny(c2 GeneratorClass) bool { } func (c GeneratorClass) Split() []GeneratorClass { - return splitBits(c) + return enum.SplitBits(c) } func (c GeneratorClass) String() string { - return stringBits(uint32(c), GeneratorClassNames) + return enum.StringBits(c, GeneratorClassNames) } func (c GeneratorClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_missile.go b/object/subclass_missile.go index 14b1298..aa91553 100644 --- a/object/subclass_missile.go +++ b/object/subclass_missile.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var MissileClassNames = []string{ "MISSILE_COUNTERSPELL", @@ -12,16 +14,14 @@ func (c SubClass) AsMissile() MissileClass { } func ParseMissileClass(s string) (MissileClass, error) { - v, err := parseEnum("missile class", s, MissileClassNames) - return MissileClass(v), err + return enum.Parse[MissileClass]("missile class", s, MissileClassNames) } func ParseMissileClassSet(s string) (MissileClass, error) { - v, err := parseEnumSet("missile class", s, MissileClassNames) - return MissileClass(v), err + return enum.ParseSet[MissileClass]("missile class", s, MissileClassNames) } -var _ enum[MissileClass] = MissileClass(0) +var _ enum.Enum[MissileClass] = MissileClass(0) type MissileClass uint32 @@ -39,17 +39,13 @@ func (c MissileClass) HasAny(c2 MissileClass) bool { } func (c MissileClass) Split() []MissileClass { - return splitBits(c) + return enum.SplitBits(c) } func (c MissileClass) String() string { - return stringBits(uint32(c), MissileClassNames) + return enum.StringBits(c, MissileClassNames) } func (c MissileClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_monster.go b/object/subclass_monster.go index 5984fc5..eb0dc33 100644 --- a/object/subclass_monster.go +++ b/object/subclass_monster.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var MonsterClassNames = []string{ "SMALL_MONSTER", "MEDIUM_MONSTER", "LARGE_MONSTER", "SHOPKEEPER", "NPC", "FEMALE_NPC", @@ -14,16 +16,14 @@ func (c SubClass) AsMonster() MonsterClass { } func ParseMonsterClass(s string) (MonsterClass, error) { - v, err := parseEnum("monster class", s, MonsterClassNames) - return MonsterClass(v), err + return enum.Parse[MonsterClass]("monster class", s, MonsterClassNames) } func ParseMonsterClassSet(s string) (MonsterClass, error) { - v, err := parseEnumSet("monster class", s, MonsterClassNames) - return MonsterClass(v), err + return enum.ParseSet[MonsterClass]("monster class", s, MonsterClassNames) } -var _ enum[MonsterClass] = MonsterClass(0) +var _ enum.Enum[MonsterClass] = MonsterClass(0) type MonsterClass uint32 @@ -59,19 +59,15 @@ func (c MonsterClass) HasAny(c2 MonsterClass) bool { } func (c MonsterClass) Split() []MonsterClass { - return splitBits(c) + return enum.SplitBits(c) } func (c MonsterClass) String() string { - return stringBits(uint32(c), MonsterClassNames) + return enum.StringBits(c, MonsterClassNames) } func (c MonsterClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } var MonsterStatusNames = []string{ @@ -89,16 +85,14 @@ var MonsterStatusNames = []string{ } func ParseMonsterStatus(s string) (MonsterStatus, error) { - v, err := parseEnum("monster status", s, MonsterStatusNames) - return MonsterStatus(v), err + return enum.Parse[MonsterStatus]("monster status", s, MonsterStatusNames) } func ParseMonsterStatusSet(s string) (MonsterStatus, error) { - v, err := parseEnumSet("monster status", s, MonsterStatusNames) - return MonsterStatus(v), err + return enum.ParseSet[MonsterStatus]("monster status", s, MonsterStatusNames) } -var _ enum[MonsterStatus] = MonsterStatus(0) +var _ enum.Enum[MonsterStatus] = MonsterStatus(0) type MonsterStatus uint32 @@ -111,19 +105,15 @@ func (c MonsterStatus) HasAny(c2 MonsterStatus) bool { } func (c MonsterStatus) Split() []MonsterStatus { - return splitBits(c) + return enum.SplitBits(c) } func (c MonsterStatus) String() string { - return stringBits(uint32(c), MonsterStatusNames) + return enum.StringBits(c, MonsterStatusNames) } func (c MonsterStatus) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } const ( diff --git a/object/subclass_other.go b/object/subclass_other.go index 81702de..8a83deb 100644 --- a/object/subclass_other.go +++ b/object/subclass_other.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var OtherClassNames = []string{ "HEAVY", "LAVA", "GATE", "VISIBLE_OBELISK", "INVISIBLE_OBELISK", "TECH", "LOTD", @@ -12,16 +14,14 @@ func (c SubClass) AsOther() OtherClass { } func ParseOtherClass(s string) (OtherClass, error) { - v, err := parseEnum("other class", s, OtherClassNames) - return OtherClass(v), err + return enum.Parse[OtherClass]("other class", s, OtherClassNames) } func ParseOtherClassSet(s string) (OtherClass, error) { - v, err := parseEnumSet("other class", s, OtherClassNames) - return OtherClass(v), err + return enum.ParseSet[OtherClass]("other class", s, OtherClassNames) } -var _ enum[OtherClass] = OtherClass(0) +var _ enum.Enum[OtherClass] = OtherClass(0) type OtherClass uint32 @@ -50,17 +50,13 @@ func (c OtherClass) HasAny(c2 OtherClass) bool { } func (c OtherClass) Split() []OtherClass { - return splitBits(c) + return enum.SplitBits(c) } func (c OtherClass) String() string { - return stringBits(uint32(c), OtherClassNames) + return enum.StringBits(c, OtherClassNames) } func (c OtherClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/object/subclass_weapon.go b/object/subclass_weapon.go index eca95c3..40748ea 100644 --- a/object/subclass_weapon.go +++ b/object/subclass_weapon.go @@ -1,6 +1,8 @@ package object -import "encoding/json" +import ( + "github.com/noxworld-dev/opennox-lib/enum" +) var WeaponClassNames = []string{ "FLAG", @@ -37,16 +39,14 @@ func (c SubClass) AsWeapon() WeaponClass { } func ParseWeaponClass(s string) (WeaponClass, error) { - v, err := parseEnum("weapon class", s, WeaponClassNames) - return WeaponClass(v), err + return enum.Parse[WeaponClass]("weapon class", s, WeaponClassNames) } func ParseWeaponClassSet(s string) (WeaponClass, error) { - v, err := parseEnumSet("weapon class", s, WeaponClassNames) - return WeaponClass(v), err + return enum.ParseSet[WeaponClass]("weapon class", s, WeaponClassNames) } -var _ enum[WeaponClass] = WeaponClass(0) +var _ enum.Enum[WeaponClass] = WeaponClass(0) type WeaponClass uint32 @@ -89,17 +89,13 @@ func (c WeaponClass) HasAny(c2 WeaponClass) bool { } func (c WeaponClass) Split() []WeaponClass { - return splitBits(c) + return enum.SplitBits(c) } func (c WeaponClass) String() string { - return stringBits(uint32(c), WeaponClassNames) + return enum.StringBits(c, WeaponClassNames) } func (c WeaponClass) MarshalJSON() ([]byte, error) { - var arr []string - for _, s := range c.Split() { - arr = append(arr, s.String()) - } - return json.Marshal(arr) + return enum.MarshalJSONArray(c) } diff --git a/script/eval/imports/github_com-noxworld-dev-opennox-lib-wall.go b/script/eval/imports/github_com-noxworld-dev-opennox-lib-wall.go new file mode 100644 index 0000000..72dcc71 --- /dev/null +++ b/script/eval/imports/github_com-noxworld-dev-opennox-lib-wall.go @@ -0,0 +1,31 @@ +// Code generated by 'yaegi extract github.com/noxworld-dev/opennox-lib/wall'. DO NOT EDIT. + +package imports + +import ( + "go/constant" + "go/token" + "reflect" + + "github.com/noxworld-dev/opennox-lib/wall" +) + +func init() { + Symbols["github.com/noxworld-dev/opennox-lib/wall/wall"] = map[string]reflect.Value{ + // function, constant and variable definitions + "Flag1": reflect.ValueOf(wall.Flag1), + "Flag8": reflect.ValueOf(wall.Flag8), + "FlagBreakable": reflect.ValueOf(wall.FlagBreakable), + "FlagBroken": reflect.ValueOf(wall.FlagBroken), + "FlagDoor": reflect.ValueOf(wall.FlagDoor), + "FlagFront": reflect.ValueOf(wall.FlagFront), + "FlagSecret": reflect.ValueOf(wall.FlagSecret), + "FlagWindow": reflect.ValueOf(wall.FlagWindow), + "GridStep": reflect.ValueOf(constant.MakeFromLiteral("23", token.INT, 0)), + "GridToPos": reflect.ValueOf(wall.GridToPos), + "PosToGrid": reflect.ValueOf(wall.PosToGrid), + + // type definitions + "Flags": reflect.ValueOf((*wall.Flags)(nil)), + } +} diff --git a/script/eval/imports/symbols.go b/script/eval/imports/symbols.go index 6ad964a..ea62b58 100644 --- a/script/eval/imports/symbols.go +++ b/script/eval/imports/symbols.go @@ -6,6 +6,7 @@ import ( //go:generate yaegi extract github.com/noxworld-dev/opennox-lib/types //go:generate yaegi extract github.com/noxworld-dev/opennox-lib/object +//go:generate yaegi extract github.com/noxworld-dev/opennox-lib/wall //go:generate yaegi extract github.com/noxworld-dev/opennox-lib/player //go:generate yaegi extract github.com/noxworld-dev/opennox-lib/script //go:generate goimports -w . diff --git a/wall/wall.go b/wall/wall.go index ab812d3..2e41830 100644 --- a/wall/wall.go +++ b/wall/wall.go @@ -4,6 +4,7 @@ import ( "image" "github.com/noxworld-dev/opennox-lib/common" + "github.com/noxworld-dev/opennox-lib/enum" "github.com/noxworld-dev/opennox-lib/types" ) @@ -22,3 +23,49 @@ func GridToPos(pos image.Point) types.Pointf { Y: float32(pos.Y) * GridStep, } } + +var _ enum.Enum[Flags] = Flags(0) + +type Flags byte + +func (f Flags) Has(f2 Flags) bool { + return f&f2 != 0 +} + +func (f Flags) HasAny(f2 Flags) bool { + return f&f2 != 0 +} + +func (f Flags) Split() []Flags { + return enum.SplitBits(f) +} + +func (f Flags) String() string { + return enum.StringBits(f, flagNames) +} + +func (f Flags) MarshalJSON() ([]byte, error) { + return enum.MarshalJSONArray(f) +} + +const ( + Flag1 = Flags(0x1) + FlagFront = Flags(0x2) + FlagSecret = Flags(0x4) + FlagBreakable = Flags(0x8) + FlagDoor = Flags(0x10) + FlagBroken = Flags(0x20) + FlagWindow = Flags(0x40) + Flag8 = Flags(0x80) +) + +var flagNames = []string{ + "Flag1", + "FlagFront", + "FlagSecret", + "FlagBreakable", + "FlagDoor", + "FlagBroken", + "FlagWindow", + "Flag8", +}