Adding modding folder with a hacked build.

modding/hacked/ss1/content/interpreters/Simplifier.go

@@ -0,0 +1,193 @@
+package interpreters
+
+import (
+	"math"
+)
+
+// RawValueFormatter provides the format function for given value.
+// If nothing special is to be displayed, an empty string should be returned.
+// The handler is responsible for adding the number value representation.
+type RawValueFormatter func(value int) string
+
+// RawValueHandler is for a simple value range.
+type RawValueHandler func(minValue, maxValue int64, formatter RawValueFormatter)
+
+// EnumValueHandler is for enumerated (mapped) values.
+type EnumValueHandler func(values map[uint32]string)
+
+// BitfieldHandler is for bitfields.
+type BitfieldHandler func(values map[uint32]string)
+
+// ObjectIDHandler is for object identifier in a level.
+type ObjectIDHandler func()
+
+// SpecialHandler is for rare occasions.
+type SpecialHandler func()
+
+// RotationHandler is for circular values.
+type RotationHandler func(minValue, maxValue int64)
+
+func basicToString(value int) string {
+	return ""
+}
+
+// RangedValue creates a field range for specific minimum and maximum values.
+func RangedValue(minValue, maxValue int64) FieldRange {
+	return FormattedRangedValue(minValue, maxValue, basicToString)
+}
+
+// FormattedRangedValue is similar to RangedValue, and adds a formatting function.
+func FormattedRangedValue(minValue, maxValue int64, formatter RawValueFormatter) FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.rangedValue(minValue, maxValue, formatter)
+	}
+}
+
+// EnumValue creates a field range describing enumerated values.
+func EnumValue(values map[uint32]string) FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.enumValue(values)
+	}
+}
+
+// Bitfield creates a field range describing bitfield values.
+func Bitfield(values map[uint32]string) FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.bitfield(values)
+	}
+}
+
+// ObjectID creates a field range describing object identifier.
+func ObjectID() FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.objectIndex()
+	}
+}
+
+// RotationValue creates a field range for a rotational property.
+func RotationValue(minValue, maxValue int64) FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.rotation(minValue, maxValue)
+	}
+}
+
+// SpecialValue creates a field range for special fields.
+// Currently known special values:
+// * BinaryCodedDecimal - for keypads storing their number as BCD
+// * LevelTexture - index value into level texture list
+// * MaterialOrLevelTexture - index value into level texture list, or material (bit 7 toggles)
+// * VariableKey - for actions
+// * VariableCondition - for action conditions
+// * ObjectTriple - for 0x00CCSSTT selection
+// * ObjectHeight - for level height value 0..255
+// * MoveTileHeight - for change tile height action
+// * TileHeight - tile heights
+// * TileType - tile types
+// * Unknown - It is unclear whether this field would have any effect, none identified so far
+// * Ignored - Although values have been found in this field, they don't appear to have any effect
+// * Mistake - It is assumed that these values should have been placed somewhere else. Typical example: Container content
+// * Internal - Fields that are handled mainly by the engine and shouldn't be modified.
+func SpecialValue(specialType string) FieldRange {
+	return func(simpl *Simplifier) bool {
+		return simpl.specialValue(specialType)
+	}
+}
+
+// Simplifier forwards descriptions in a way the requester can use.
+type Simplifier struct {
+	rawValueHandler  RawValueHandler
+	enumValueHandler EnumValueHandler
+	bitfieldHandler  BitfieldHandler
+	objectIDHandler  ObjectIDHandler
+	rotationHandler  RotationHandler
+	specialHandler   map[string]SpecialHandler
+}
+
+// NewSimplifier returns a new instance of a simplifier, with the minimal
+// handler set.
+func NewSimplifier(rawValueHandler RawValueHandler) *Simplifier {
+	return &Simplifier{
+		rawValueHandler: rawValueHandler,
+		specialHandler:  make(map[string]SpecialHandler)}
+}
+
+func (simpl *Simplifier) rawValue(e *entry) {
+	max := int64(math.Pow(2, float64(e.count*8)))
+	if max == 256 {
+		simpl.rawValueHandler(0, 255, basicToString)
+	} else {
+		half := max / 2
+		simpl.rawValueHandler(-1, half-1, basicToString)
+	}
+}
+
+func (simpl *Simplifier) rangedValue(minValue, maxValue int64, formatter RawValueFormatter) bool {
+	simpl.rawValueHandler(minValue, maxValue, formatter)
+	return true
+}
+
+// SetEnumValueHandler registers the handler for enumerations.
+func (simpl *Simplifier) SetEnumValueHandler(handler EnumValueHandler) {
+	simpl.enumValueHandler = handler
+}
+
+func (simpl *Simplifier) enumValue(values map[uint32]string) (result bool) {
+	if simpl.enumValueHandler != nil {
+		simpl.enumValueHandler(values)
+		result = true
+	}
+	return
+}
+
+// SetBitfieldHandler registers the handler for bitfields.
+func (simpl *Simplifier) SetBitfieldHandler(handler BitfieldHandler) {
+	simpl.bitfieldHandler = handler
+}
+
+func (simpl *Simplifier) bitfield(values map[uint32]string) (result bool) {
+	if simpl.bitfieldHandler != nil {
+		simpl.bitfieldHandler(values)
+		result = true
+	}
+	return
+}
+
+// SetObjectIDHandler registers the handler for object indices.
+func (simpl *Simplifier) SetObjectIDHandler(handler ObjectIDHandler) {
+	simpl.objectIDHandler = handler
+}
+
+func (simpl *Simplifier) objectIndex() (result bool) {
+	if simpl.objectIDHandler != nil {
+		simpl.objectIDHandler()
+		result = true
+	}
+	return
+}
+
+// SetSpecialHandler registers the handler for special values.
+func (simpl *Simplifier) SetSpecialHandler(specialType string, handler SpecialHandler) {
+	simpl.specialHandler[specialType] = handler
+}
+
+func (simpl *Simplifier) specialValue(specialType string) (result bool) {
+	handler, existing := simpl.specialHandler[specialType]
+	if existing && (handler != nil) {
+		handler()
+		result = true
+	}
+	return
+}
+
+// SetRotationHandler registers the handler for rotation values.
+func (simpl *Simplifier) SetRotationHandler(handler RotationHandler) {
+	simpl.rotationHandler = handler
+}
+
+func (simpl *Simplifier) rotation(minValue, maxValue int64) (result bool) {
+	if simpl.rotationHandler != nil {
+		simpl.rotationHandler(minValue, maxValue)
+		result = true
+	}
+	return
+}