Stack.asc

// currently (AGS 3.4.0.3), managed structs cannot hold any pointer types
// (including String), so frustratingly we must attempt to pool them here
struct StringCache_t
{
  String Pool[];
  int Count;
  int Capacity;
};

StringCache_t StringCache;

// Grows the String cache by a factor of 2 until it matches or exceeds minCapacity.
void noloopcheck Grow(this StringCache_t*, int minCapacity)
{
  if (this.Capacity >= minCapacity) return;
  if ((this.Capacity == 1000000) || (minCapacity > 1000000))
  {
    AbortGame("Stack module error!: Attempted to grow cache capacity beyond 1000000 items.");
  }
  int copy = this.Capacity;
  do
  {
    if (this.Capacity == 0) this.Capacity = 1;
    else if (this.Capacity >= 500000) this.Capacity = 1000000;
    else this.Capacity *= 2;
  } while (this.Capacity < minCapacity);
  String pool[] = new String[this.Capacity];
  int i;
  for (i = 0; i < copy; i++)
  {
    pool[i] = this.Pool[i];
  }
  this.Pool = pool;
}

function game_start()
{
  // reserve StringCache slot 0, because int is default 0
  // and with no ctor we can't control the value of _scacheID
  // for StackData instances, so StringCache.Pool[0] == null
  StringCache.Count = 1;
  StringCache.Grow(1);
}

// Checks if the String exists in the pool. If not, it is added.
// Returns the cached index of this String.
int Cache(this String*)
{
  int i;
  for (i = 0; i < StringCache.Count; i++)
  {
    if (StringCache.Pool[i] == this) return i;
  }
  StringCache.Count++;
  StringCache.Grow(StringCache.Count);
  StringCache.Pool[i] = this;
  return i;
}

// StackData property definitions

int get_AsInt(this StackData*)
{
  if (this.Type != eStackDataInt)
  {
    return 0;
  }
  return this._idata;
}

float get_AsFloat(this StackData*)
{
  if (this.Type != eStackDataFloat)
  {
    return 0.0;
  }
  return this._fdata;
}

String get_AsString(this StackData*)
{
  if ((this.Type != eStackDataString) || (this._scacheID < 0) ||
      (this._scacheID >= StringCache.Count))
  {
    return null;
  }
  return StringCache.Pool[this._scacheID];
}

Character* get_AsCharacter(this StackData*)
{
  if ((this.Type != eStackDataCharacter) || (this._idata == -1))
  {
    return null;
  }
  return character[this._idata];
}

InventoryItem* get_AsInventoryItem(this StackData*)
{
  if ((this.Type != eStackDataInventoryItem) || (this._idata == -1))
  {
    return null;
  }
  return inventory[this._idata];
}

GUI* get_AsGUI(this StackData*)
{
  if ((this.Type != eStackDataGUI) || (this._idata == -1))
  {
    return null;
  }
  return gui[this._idata];
}

GUIControl* get_AsGUIControl(this StackData*)
{
  if ((this.Type != eStackDataGUIControl) || (this._idata == -1))
  {
    return null;
  }
  int owner = this._idata / AGS_MAX_CONTROLS_PER_GUI;
  int ctrl = this._idata % AGS_MAX_CONTROLS_PER_GUI;
  if ((owner < 0) || (owner >= Game.GUICount) ||
      (ctrl >= gui[owner].ControlCount))
  {
    return null;
  }
  return gui[owner].Controls[ctrl];
}

// end StackData property definitions

// StackData helpers (for internal access to private members)

int GetIData(this StackData*)
{
  return this._idata;
}

void SetIData(this StackData*, int value)
{
  this._idata = value;
}

float GetFData(this StackData*)
{
  return this._fdata;
}

void SetFData(this StackData*, float value)
{
  this._fdata = value;
}

int GetSCacheID(this StackData*)
{
  return this._scacheID;
}

void SetSCacheID(this StackData*, int value)
{
  this._scacheID = value;
}

void SetType(this StackData*, StackDataType value)
{
  this.Type = value;
}

// end StackData helpers

static bool StackData::IsNullOrInvalid(StackData value)
{
  return ((value == null) || (value.Type == eStackDataInvalid));
}

StackData IDataToData(static StackData, int idata, StackDataType type)
{
  StackData result = new StackData;
  result.SetIData(idata);
  result.SetType(type);
  return result;
}

static StackData StackData::IntToData(int value)
{
  return StackData.IDataToData(value, eStackDataInt);
}

static StackData StackData::FloatToData(float value)
{
  StackData result = new StackData;
  result.SetFData(value);
  result.SetType(eStackDataFloat);
  return result;
}

static StackData StackData::StringToData(String value)
{
  StackData result = new StackData;
  if (value != null)
  {
    result.SetSCacheID(value.Cache());
  }
  result.SetType(eStackDataString);
  return result;
}

static StackData StackData::StringCachedToData(int cachedID)
{
  StackData result = new StackData;
  if ((cachedID > 0) && (cachedID < StringCache.Count))
  {
    result.SetSCacheID(cachedID);
  }
  result.SetType(eStackDataString);
  return result;
}

static StackData StackData::CharacterToData(Character *value)
{
  int id = -1;
  if (value != null) id = value.ID;
  return StackData.IDataToData(id, eStackDataCharacter);
}

static StackData StackData::InventoryItemToData(InventoryItem *value)
{
  int id = -1;
  if (value != null) id = value.ID;
  return StackData.IDataToData(id, eStackDataInventoryItem);
}

static StackData StackData::GUIToData(GUI *value)
{
  int id = -1;
  if (value != null) id = value.ID;
  return StackData.IDataToData(id, eStackDataGUI);
}

static StackData StackData::GUIControlToData(GUIControl *value)
{
  int id = -1;
  if (value != null) id = ((value.OwningGUI.ID * AGS_MAX_CONTROLS_PER_GUI) + value.ID);
  return StackData.IDataToData(id, eStackDataGUIControl);
}

// Returns the cached index of a String
static int Stack::GetStringCachedID(String value)
{
  if (value == null) return -1;
  return value.Cache();
}

// Stack property definitions

int get_StringCacheCapacity(this Stack*)
{
  return StringCache.Capacity;
}

void set_StringCacheCapacity(this Stack*, int value)
{
  StringCache.Grow(value);
}

// Grows this Stack's item array until it matches or exceeds minCapacity.
void noloopcheck Grow(this Stack*, int minCapacity)
{
  if (minCapacity <= this._capacity) return;
  if ((this._capacity == 1000000) || (minCapacity > 1000000))
  {
    AbortGame("Stack module error!: Attempted to grow capacity beyond 1000000 items.");
  }
  int copy = this._capacity;
  do
  {
    if (this._capacity == 0) this._capacity = 1;
    else if (this._capacity >= 500000) this._capacity = 1000000;
    else this._capacity *= 2;
  } while (this._capacity < minCapacity);
  StackData items[] = new StackData[this._capacity];
  int i;
  for (i = 0; i < copy; i++)
  {
    items[i] = this._items[i];
  }
  this._items = items;
}

int get_Capacity(this Stack*)
{
  return this._capacity;
}

void set_Capacity(this Stack*, int value)
{
  this.Grow(value);
}

// Safely overwrites an existing item in the Stack.
bool OverwriteItem(this Stack*, int index, StackData value)
{
  if ((index < 0) || (index >= this.ItemCount) || (value == null) ||
      (value.Type == eStackDataInvalid))
  {
    return false;
  }
  this._items[index] = value;
  return true;
}

StackData geti_Items(this Stack*, int index)
{
  if ((index < 0) || (index >= this.ItemCount)) return new StackData;
  return this._items[index];
}

void seti_Items(this Stack*, int index, StackData value)
{
  this.OverwriteItem(index, value);
}

// end Stack property definitions

void Stack::Clear()
{
  int i;
  for (i = 0; i < this.ItemCount; i++)
  {
    this._items = null;
  }
}

// Push a generic item onto the Stack.
bool noloopcheck Stack::Push(StackData item, int index, bool insert)
{
  if ((item == null) || (item.Type == eStackDataInvalid))
  {
    // item was not valid, abort
    return false;
  }
  if ((index < 0) || (index > this.ItemCount) || (index == SCR_NO_VALUE))
  {
    // invalid index, force append
    index = this.ItemCount;
  }
  else if (index != this.ItemCount)
  {
    // valid index for existing item
    if (!insert)
    {
      // not inserting, overwrite item
      return this.OverwriteItem(index, item);
    }
  }
  // insert or append item
  this.ItemCount++;
  this.Grow(this.ItemCount);
  // shift items, as needed
  int i;
  for (i = this.ItemCount - 1; i > index; i--)
  {
    this._items[i] = this._items[i - 1];
  }
  // and insert our new item
  this._items[index] = item;
}

bool Stack::PushInt(int value, int index, bool insert)
{
  return this.Push(StackData.IntToData(value), index, insert);
}

bool Stack::PushFloat(float value, int index, bool insert)
{
  return this.Push(StackData.FloatToData(value), index, insert);
}

bool Stack::PushString(String value, int index, bool insert)
{
  return this.Push(StackData.StringToData(value), index, insert);
}

bool Stack::PushStringCached(int cachedID, int index, bool insert)
{
  return this.Push(StackData.StringCachedToData(cachedID), index, insert);
}

bool Stack::PushCharacter(Character *value, int index, bool insert)
{
  return this.Push(StackData.CharacterToData(value), index, insert);
}

bool Stack::PushInventoryItem(InventoryItem *value, int index, bool insert)
{
  return this.Push(StackData.InventoryItemToData(value), index, insert);
}

bool Stack::PushGUI(GUI *value, int index, bool insert)
{
  return this.Push(StackData.GUIToData(value), index, insert);
}

bool Stack::PushGUIControl(GUIControl *value, int index, bool insert)
{
  return this.Push(StackData.GUIControlToData(value), index, insert);
}

// Pops a StackData object.
StackData noloopcheck Pop(this Stack*, int index, bool remove)
{
  // determine index based on Stack's pop style
  if (index == SCR_NO_VALUE)
  {
    if (this.PopStyle == eStackPopFirstInFirstOut)
    {
      index = 0;
    }
    else if (this.PopStyle == eStackPopFirstInLastOut)
    {
      index = this.ItemCount - 1;
    }
    else
    {
      index = Random(this.ItemCount - 1);
    }
  }
  if ((index < 0) || (index >= this.ItemCount))
  {
    // invalid index
    return null;
  }
  StackData item = this._items[index];
  if (!remove)
  {
    // if not removing the item, just return it
    return item;
  }
  this.ItemCount--;
  // shift the remaining items, to remove this one
  int i;
  for (i = index; i < this.ItemCount; i++)
  {
    this._items[i] = this._items[i + 1];
  }
  // clear the newly emptied slot
  this._items[i] = null;
  return item;
}

// Helper to ensure that the popped StackData is non-null.
// This prevents duplicating the defaults for invalid data casts.
StackData SafePop(this Stack*, int index, bool remove)
{
  StackData result = this.Pop(index, remove);
  if (result == null) return new StackData;
  return result;
}

int Stack::PopInt(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsInt();
}

float Stack::PopFloat(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsFloat();
}

String Stack::PopString(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsString();
}

Character* Stack::PopCharacter(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsCharacter();
}

InventoryItem* Stack::PopInventoryItem(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsInventoryItem();
}

GUI* Stack::PopGUI(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsGUI();
}

GUIControl* Stack::PopGUIControl(int index, bool remove)
{
  StackData item = this.SafePop(index, remove);
  return item.get_AsGUIControl();
}