Adding modding folder with a hacked build.

modding/hacked/ss1/content/archive/level/ObjectClassTable.go

@@ -0,0 +1,156 @@
+package level
+
+import (
+	"github.com/inkyblackness/hacked/ss1/content/object"
+	"github.com/inkyblackness/hacked/ss1/serial"
+)
+
+const (
+	// ObjectClassEntryHeaderSize is the size, in bytes, of the header prefix for each class entry.
+	ObjectClassEntryHeaderSize = 6
+)
+
+// ObjectClassEntry describes an entry in a object-class specific list.
+type ObjectClassEntry struct {
+	ObjectID ObjectID
+	Next     int16
+	Prev     int16
+	Data     []byte
+}
+
+// NewObjectClassEntry returns an instance with the given amount of bytes initialized for data.
+func NewObjectClassEntry(dataSize int) *ObjectClassEntry {
+	return &ObjectClassEntry{
+		Data: make([]byte, dataSize),
+	}
+}
+
+// Code serializes the entry with given coder, including the data array.
+func (entry *ObjectClassEntry) Code(coder serial.Coder) {
+	coder.Code(&entry.ObjectID)
+	coder.Code(&entry.Next)
+	coder.Code(&entry.Prev)
+	coder.Code(entry.Data)
+}
+
+// Reset sets all members of the entry to zero, including all bytes of the data array.
+func (entry *ObjectClassEntry) Reset() {
+	entry.ObjectID = 0
+	entry.Next = 0
+	entry.Prev = 0
+	for i := 0; i < len(entry.Data); i++ {
+		entry.Data[i] = 0
+	}
+}
+
+// ObjectClassTable is a list of entries.
+//
+// The first entry is reserved for internal use. For the reserved entry,
+// the Next field identifies the head of the single-linked free chain,
+// and the ObjectID field identifies the head of the double-linked used chain.
+type ObjectClassTable []ObjectClassEntry
+
+// DefaultObjectClassTable returns an initialized table for given object class.
+func DefaultObjectClassTable(class object.Class) ObjectClassTable {
+	info := ObjectClassInfoFor(class)
+	table := make(ObjectClassTable, info.EntryCount)
+	table.AllocateData(info.DataSize)
+	table.Reset()
+	return table
+}
+
+// AllocateData prepares each entry to be able to store the given amount of bytes.
+// This function drops any previously assigned data.
+func (table ObjectClassTable) AllocateData(size int) {
+	for i := 0; i < len(table); i++ {
+		table[i].Data = make([]byte, size)
+	}
+}
+
+// Reset wipes the entire table and initializes all links.
+// The bytes of the data members of each entry are reset to zero.
+func (table ObjectClassTable) Reset() {
+	tableLen := len(table)
+	for i := 0; i < tableLen; i++ {
+		entry := &table[i]
+		entry.Reset()
+		entry.Next = int16(i + 1)
+	}
+	if tableLen > 0 {
+		table[tableLen-1].Next = 0
+	}
+}
+
+// Code serializes the table with the provided coder.
+func (table ObjectClassTable) Code(coder serial.Coder) {
+	for i := 0; i < len(table); i++ {
+		table[i].Code(coder)
+	}
+}
+
+// Capacity returns the number of how many objects the table can hold.
+func (table ObjectClassTable) Capacity() int {
+	size := len(table)
+	if size < 2 {
+		return 0
+	}
+	return size - 1
+}
+
+// AllocatedCount returns the number of how many objects are currently allocated in the table.
+func (table ObjectClassTable) AllocatedCount() int {
+	capacity := table.Capacity()
+	if capacity == 0 {
+		return 0
+	}
+	index := int(table[0].ObjectID)
+	count := 0
+	for (index != 0) && (count < capacity) {
+		count++
+		index = int(table[index].Next)
+	}
+	return count
+}
+
+// Allocate attempts to reserve an entry in the table and returns the corresponding index.
+// returns 0 if exhausted.
+func (table ObjectClassTable) Allocate() int {
+	if len(table) < 2 {
+		return 0
+	}
+	start := &table[0]
+	if start.Next == 0 {
+		return 0
+	}
+	index := start.Next
+	entry := &table[index]
+	start.Next = entry.Next
+
+	entry.Reset()
+	entry.Next = int16(start.ObjectID)
+	table[start.ObjectID].Prev = index
+	entry.Prev = 0
+	start.ObjectID = ObjectID(index)
+
+	return int(index)
+}
+
+// Release frees the identified entry.
+func (table ObjectClassTable) Release(index int) {
+	if (index < 1) || (index >= len(table)) {
+		return
+	}
+	start := &table[0]
+	entry := &table[index]
+
+	if entry.Prev == 0 {
+		start.ObjectID = ObjectID(entry.Next)
+	} else {
+		table[entry.Prev].Next = entry.Next
+	}
+	table[entry.Next].Prev = entry.Prev
+
+	entry.Reset()
+	entry.Next = start.Next
+	start.Next = int16(index)
+}