Matchbox maze - Astar solution.

const string MATCHBOX = "matchbox";
const string WALL = "shelfwall_";
const float MAX_NUMBER_OF_WALLS = 200;

void OnStart()
{
    //AttachProp(MATCHBOX,"TT",NODE_FILE,0,0,0);
    //AttachProp(MATCHBOX,"TT",NODE_FILE,NODE_SIZE,0,0);
    AStarBegin(25,0,-11);
}

///////////////////////////////
//+ A* PATH FINDING
///////////////////////////////
const float NODE_SIZE = 2.0f;
const float NODE_SEP = 0.01f;
const string NODE_FILE = "sdiv" + NODE_SIZE + ".ent";
const float ASTAR_TIMESTEP = 0.2f;

void AStarBegin(float goalX, float goalY, float goalZ)
 {
    //Create the lists
    stringListCreate("OpenList");
    stringListCreate("ClosedList");

    //Create start node
    string startNode = CreateNode(0,0,0,0,"");
    stringListAddItem("OpenList",startNode);

    //Setup the goal node settings
    SetLocalVarFloat("GoalX",goalX);
    SetLocalVarFloat("GoalY",goalY);
    SetLocalVarFloat("GoalZ",goalZ);

    //Start
    AddTimer("TIMER",2.0f,"AStarStep");
 }

void AStarStep(string &in asTimer)
 {
    //Get a new node from the open list. If none, then destination unreachable.
    string newNode = OpenList_LeastCostNode();
    if(newNode == "")
     {
        AddDebugMessage("Error: Destination Unreachable",false);
        return;
     }
    //Add this node to the closed list and remove from open list
    stringListAddItem("ClosedList",newNode);
    if(stringListRemoveItems("OpenList",newNode) != 1)
     {
        AddDebugMessage("Error: Multiple items removed from open list",false);
        return;
     }

    //Goal Test
    if(AStarGoalTest(newNode))
     {
        AddDebugMessage("Goal found",false);
        FollowerBegin(newNode);
        return;
     }

    //Node Properties
    float nX = GetNodeProperty(newNode,"X");
    float nY = GetNodeProperty(newNode,"Y");
    float nZ = GetNodeProperty(newNode,"Z");
    float nC = GetNodeProperty(newNode,"pCost")+1;

    //Determine all the potential new nodes from this point
    string[] reachable = {  CreateNode(nX + NODE_SIZE + NODE_SEP,nY,nZ,nC,newNode),
                            CreateNode(nX - NODE_SIZE - NODE_SEP,nY,nZ,nC,newNode),
                            CreateNode(nX,nY,nZ + NODE_SIZE + NODE_SEP,nC,newNode),
                            CreateNode(nX,nY,nZ - NODE_SIZE - NODE_SEP,nC,newNode) };

    //For each of the new nodes, add to open list if not already visited and not a wall:
    for(uint i = 0; i<reachable.length(); i++)
     {
        string nextNode = reachable[i];
        if(IsNodeColliding(nextNode) || IsNodeInPath(nextNode,"ClosedList") || IsNodeInPath(nextNode,"OpenList"))
             DeleteNode(nextNode); //This node is not valid or optimal
        else //Can assume nodes in open list are optimal as all path cost increments are 1.
            OpenList_AddNewNode(nextNode); //Add/update the open list with this node
     }

    AddTimer("TIMER",ASTAR_TIMESTEP,"AStarStep");
 }

float AStarHeuristic(float fromX, float fromY, float fromZ)
 {
    //StraightLine distance in squares
    float DX = fromX - GetLocalVarFloat("GoalX");
    float DY = fromY - GetLocalVarFloat("GoalY");
    float DZ = fromZ - GetLocalVarFloat("GoalZ");
    return sqrt(DX*DX + DY*DY + DZ*DZ) / (2 * NODE_SIZE);
 }

bool AStarGoalTest(string node)
 {
    float dX = GetNodeProperty(node,"X")-GetLocalVarFloat("GoalX");
    float dY = GetNodeProperty(node,"Y")-GetLocalVarFloat("GoalY");
    float dZ = GetNodeProperty(node,"Z")-GetLocalVarFloat("GoalZ");
    //Does this node contain the goal point?
    return (    dX <  NODE_SIZE && dY <  NODE_SIZE && dZ <  NODE_SIZE
            &&  dX > -NODE_SIZE && dY > -NODE_SIZE && dZ > -NODE_SIZE   );
 }

string OpenList_LeastCostNode()
 {
    string[] nodes = stringListItems("OpenList");
    float leastCost = 999999.0f;
    string bestNode = "";
    for(uint i =0; i<nodes.length(); i++)
     {
        float cost = GetNodeProperty(nodes[i],"pCost") + GetNodeProperty(nodes[i],"hCost");
        if(cost < leastCost)
        {
            bestNode = nodes[i];
            leastCost = cost;
        }
     }
    return bestNode;
 }

void OpenList_AddNewNode(string node)
 {
    /*
    //Use only if path costs are not the same for all nodes
    //If node is already in open list, update old node to pick the best cost if new node is better
    string[] nodes = stringListItems("OpenList");
    for(uint i = 0; i<nodes.length(); i++)
     {
        string oldNode = nodes[i];
        if(GetEntitiesCollide("node_"+oldNode,"node_"+node))
         {
            float pc1 = GetNodeProperty(node,"pCost");
            if(pc1<GetNodeProperty(oldNode,"pCost"))
             {
                SetLocalVarFloat("node_"+oldNode+"pCost",pc1);
                SetLocalVarString("node_"+oldNode+"parent",GetLocalVarString("node_"+node+"parent"));
                AddDebugMessage(GetNodeFullName(oldNode) + " Updated",false);
             }
            DeleteNode(node);
         }
     }
    */
    //Otherwise add the node
    stringListAddItem("OpenList",node);
    AddDebugMessage(GetNodeFullName(node) + " Added",false);
 }
///////////////////////////////
//- A* PATH FINDING
///////////////////////////////

///////////////////////////////
//+ NODE
///////////////////////////////
string CreateNode(float nodeX, float nodeY, float nodeZ, float pCost, string parent)
 {
    int id = GetLocalVarInt("NodeID"); AddLocalVarInt("NodeID",1);
    string name = "node_" + id;
    SetLocalVarFloat(name + "X",nodeX);
    SetLocalVarFloat(name + "Y",nodeY);
    SetLocalVarFloat(name + "Z",nodeZ);
    SetLocalVarFloat(name + "pCost",pCost);
    SetLocalVarFloat(name + "hCost",AStarHeuristic(nodeX,nodeY,nodeZ));
    SetLocalVarString(name + "parent",parent);
    AttachProp(MATCHBOX,name,NODE_FILE,nodeX,nodeY,nodeZ);
    return ""+id;
 }

void DeleteNode(string node) { RemoveAttachedPropFromProp(MATCHBOX,"node_" + node); }

bool IsNodeInPath(string newNode, string path)
 {
    string[] nodes = stringListItems(path);
    string node = "node_" + newNode;

    for(uint i = 0; i<nodes.length(); i++)
        if(GetEntitiesCollide(node,"node_"+nodes[i])) return true;

    return false;
 }

bool IsNodeColliding(string node)
 {
    for(int i =1; i<MAX_NUMBER_OF_WALLS; i++)
        if(GetEntitiesCollide(WALL+i,"node_"+node)) return true;

    return false;
 }

float GetNodeProperty(string node, string property) { return GetLocalVarFloat("node_" + node + property); }

string GetNodeFullName(string node)
 {
    return "Node("+ GetNodeProperty(node,"X")+","+
                    GetNodeProperty(node,"Y")+","+
                    GetNodeProperty(node,"Z")+","+node+")";
 }

void ClearNodeAttachments()
 {
    for(int i =0; i<GetLocalVarInt("NodeID"); i++)
     {
        if(GetEntityExists("node_"+i))
            RemoveAttachedPropFromProp(MATCHBOX,"node_"+i);
     }
 }
///////////////////////////////
//- NODE
///////////////////////////////

///////////////////////////////
//+ PATH FOLLOWING
///////////////////////////////
const float FOLLOWER_TIMESTEP = 1.0f;
const float FOLLOWER_IMPULSE_MUL = 2.25f;

void FollowerBegin(string goalNode)
 {
    //Don't need the old open/closed list anymore, or the attachments.
    stringListClear("OpenList");
    stringListClear("ClosedList");
    ClearNodeAttachments();

    //Use the open list as temp storage for the route from goal->start
    string parent = GetLocalVarString("node_"+goalNode+"parent");
    while(parent!="")
     {
        stringListAddItem("OpenList",parent);
        parent = GetLocalVarString("node_"+parent+"parent");
     }

    //Start the follower timer
    SetLocalVarFloat("OldX",0);
    SetLocalVarFloat("OldY",0);
    SetLocalVarFloat("OldZ",0);
    AddTimer("Follower",FOLLOWER_TIMESTEP,"tmrFollower");
 }

void tmrFollower(string &in asTimer)
 {
    //Get the current node & remove from path
    string[] toVisit = stringListItems("OpenList");
    if(toVisit.length() == 0)
    {
        AddDebugMessage("At Goal",false);
        return;
    }
    string node = toVisit[toVisit.length()-1];
    stringListRemoveItems("OpenList",node);

    //Work out which direction to move in
    float nX = GetNodeProperty(node,"X");
    float nY = GetNodeProperty(node,"Y");
    float nZ = GetNodeProperty(node,"Z");
    float dX = (nX - GetLocalVarFloat("OldX")) * FOLLOWER_IMPULSE_MUL;
    float dY = (nY - GetLocalVarFloat("OldY")) * FOLLOWER_IMPULSE_MUL;
    float dZ = (nZ - GetLocalVarFloat("OldZ")) * FOLLOWER_IMPULSE_MUL;
    SetLocalVarFloat("OldX",nX);
    SetLocalVarFloat("OldY",nY);
    SetLocalVarFloat("OldZ",nZ);

    //Move
    AddPropImpulse(MATCHBOX,dX,dY,dZ,"world");

    //Repeat the path follower
    AddTimer(asTimer,FOLLOWER_TIMESTEP,"tmrFollower");
 }

///////////////////////////////
//- PATH FOLLOWING
///////////////////////////////


///////////////////////////////
//+ MISC METHODS
///////////////////////////////
//Fixed variant of AddAttachedPropToProp
void AttachProp(string &in asPName,string &in asAName, string &in aFile, float afX, float afY, float afZ)
 {
    AddAttachedPropToProp(asPName,asAName,aFile,afX,afY,0,afZ,90.0f,afZ);
 }

//SQRT
bool approx(float &in x, float &in y, float &in epsilon)
 { float delta = x-y; return ((delta>0?delta:-delta) <= (epsilon>0?epsilon:-epsilon)); }
const uint32 _SQRTITERATIONS=16; //Maximum number of iterations for sqrt computation
const float  _SQRTDELTA=0.00001f; //Margin of error allowable if complete before iteration ceiling
float sqrt(float &in x) {
  if(x<=0) return 0; //Early out - not valid input.
  uint32 i = 0; float o = x * 0.5f;
  while( i<_SQRTITERATIONS && !approx(o*o,x,_SQRTDELTA) && o != 0)
    { o = 0.5f * (o + x/o); i++; }
  return o;             }

///////////////////////////////
//- FIXED METHODS
///////////////////////////////

///////////////////////////////
//Begin String Parsing
///////////////////////////////
//+ Private Parsing functions
int  _ParseDigit(uint8 digit) {
    int d = digit-48; //48 is ASCII code for 0
    return ((d >= 0)&&(d<=9)) ? d : -1; }
bool _ParseExp(uint8 digit) {
    return (digit == 69) || (digit == 101); //ASCII for e or E
}
bool _ParseSign(uint8 digit) {
    return (digit == 45);  // -sign
}
bool _ParsePoint(uint8 digit) {
    return (digit == 46);
}
bool _ParseExpSpace(uint8 digit) {
    return (digit == 43)||(digit == 32);
}
float _ParseMakeFloat(int n1, int n2, int n3, bool hasD, bool hasE, bool signE, bool signN, int leading) {
  float output = n1;
     if(hasD) {
    int ln=(""+n2).length() + leading; float temp=n2;
    for(int i=0; i<ln; i++) temp /= 10;
    output += signN?-temp:temp;
   } if(hasE) {
    for(int i =0; i<n3; i++)
     output = signE?(output/10):(output*10);
   } return output;
}
int _ParseMakeInt(int n1, int n3, bool hasE, bool signE) {
  int output = n1;
  if(hasE) {
   for(int i =0; i<n3; i++)
     output = signE?(output/10):(output*10);
           } return output;
}
//-

//Parses a given string to an array of floats
float[] parseStringToFloatArray(string &in asString) {
  float[] output={}; int state = 0;
  bool finalise = false; //Need to store number in array?
  bool reading = false; //In the process of reading a number?
  bool numsign = false; //Whether or not number is signed
  bool expsign = false; // " " " " " " " exponent is signed
  bool hasexp = false; //Has an exponent?
  bool hasdec = false; //Has points?
  int numbers = 0; //Temp store for numbers
  int points =0;   //Temp store for decimals
  int expons =0;   //Temp store for exponent
  int leading =0; //Temp for leading 0s on decimals
  for(uint i=0; i<asString.length(); i++) { uint8 chr = asString[i];
    int d = _ParseDigit(chr);
    switch(state) {
     case 0:  {  //Looking for: - or digit
        if(d>=0 && d<=9) {
          numbers=numsign?-d:d;
          reading = true; //State we are reading a number
          state = 1;  //Number has begun, jump to number reading stage
         } else if(_ParseSign(chr)) {
          numsign=true; //Read a minus sign. Mark number as possibly signed?
         } else {
          numsign=false; //Didn't read a sign - reset sign state.
         } break;
       }
     case 1:  {  //Read digits until a "." or exponent is found
        if(d>=0 && d<=9) {
          numbers=(numbers * 10) + d; //Add each digit
         } else if(_ParsePoint(chr)) {
          state = 2; //Read a decimal point - jump to decimal reading state
         } else if(_ParseExp(chr)) {
          state = 3; //Read an exponent marker - jump to exponent reading state
         } else { //Nothing matches. Finish.
          reading = false; finalise = true;
         } break;
       }
     case 2:  {  //Read digits until an exponent is found
        if(d>=0 && d<=9) {
          if(d == 0 && points == 0) leading++;
          points = (points * 10) + d;
          hasdec=true;
         } else if(_ParseExp(chr)) {
          state = 3;
         } else { //Nothing matches. Finish.
          reading = false; finalise = true;
         } break;
       }
     case 3:  {  //Looking for: - + or whitespace signs or a digit
        if(d>=0 && d<=9) {
          expons=d; hasexp=true; state =4;
         } else if(_ParseSign(chr)) {
          expsign=true;
         } else if(_ParseExpSpace(chr)) {
          expsign=false;
         } else {
          expsign=false; reading = false; finalise = true;
         } break;
       }
     case 4:  {  //Reading digits for exponent
        if(d>=0 && d<=9) {
          expons = (expons * 10) + d; hasexp=true;
         } else {
          reading = false; finalise = true;
         } break;
       }
                  }
    if(finalise) {
      int index = output.length(); output.resize(index+1); //Resize array, store target index
      output[index] = _ParseMakeFloat(numbers, points, expons, hasdec, hasexp, expsign, numsign, leading); //Store number
      numbers = 0; points = 0; expons = 0; state = 0; leading=0; //Reset vars
      finalise = false; reading = false; hasexp=false; expsign=false; numsign = false; hasdec=false;
                 }
   }
   if(reading) {
     int index = output.length(); output.resize(index+1);
     output[index] = _ParseMakeFloat(numbers, points, expons, hasdec, hasexp, expsign, numsign, leading);
               }
  return output;
}

//Parses a given string to an array of ints
int[] parseStringToIntArray(string &in asString) {
  int[] output={}; int state = 0;
  bool finalise = false; //Need to store number in array?
  bool reading = false; //In the process of reading a number?
  bool numsign = false; //Whether or not number is signed
  bool expsign = false; // " " " " " " " exponent is signed
  bool hasexp = false; //Has an exponent?
  int numbers = 0; //Temp store for numbers
  int expons =0;   //Temp store for exponent
  for(uint i=0; i<asString.length(); i++) { uint8 chr = asString[i];
    int d = _ParseDigit(chr);
    switch(state) {
     case 0:  {  //Looking for: - or digit
        if(d>=0 && d<=9) {
          numbers=numsign?-d:d;
          reading = true; //State we are reading a number
          state = 1;  //Number has begun, jump to number reading stage
         } else if(_ParseSign(chr)) {
          numsign=true; //Read a minus sign. Mark number as possibly signed?
         } else  {
          numsign=false; //Didn't read a sign - reset sign state.
         } break;
       }
     case 1:  {  //Read digits until exponent is found
        if(d>=0 && d<=9) {
          numbers=(numbers * 10) + d; //Add each digit
         } else if(_ParseExp(chr)) {
          state = 3; //Read an exponent marker - jump to exponent reading state
         } else { //Nothing matches. Finish.
          reading = false;
          finalise = true;
         } break;
       }
     case 3:  {  //Looking for: - + or whitespace signs or a digit
        if(d>=0 && d<=9) {
          expons=d; hasexp=true; state =4;
         } else if(_ParseSign(chr)) {
          expsign=true;
         } else if(_ParseExpSpace(chr)) {
         expsign=false;
         } else {
          expsign=false; reading = false; finalise = true;
         } break;
       }
     case 4:  {  //Reading digits for exponent
        if(d>=0 && d<=9)
         {
          expons = (expons * 10) + d; hasexp=true;
         } else {
          reading = false; finalise = true;
         }
       }
                  }
    if(finalise) {
      int index = output.length(); output.resize(index+1);
      output[index] = _ParseMakeInt(numbers, expons, hasexp, expsign);
      numbers = 0; expons = 0; state = 0; finalise = false; reading = false;
      hasexp=false; expsign=false; numsign = false;
                 }
   }
   if(reading) {
     int index = output.length(); output.resize(index+1);
     output[index] = _ParseMakeInt(numbers, expons, hasexp, expsign);
               }
  return output;
}

//Parses all the digits out of a given string, ignorning sign
uint parseStringUInt(string &in asString) {
    uint output = 0;
    for(uint i=0; i<asString.length(); i++) {
      int digit = _ParseDigit(asString[i]);
      output = (digit > -1)?(10*output+digit):(output); }
    return output;
}
///////////////////////////////
//End
///////////////////////////////

///////////////////////////////
//Begin String List
///////////////////////////////

//+ Constants
//Change the delimiter to suit, it is currently the null character.
const string _STRLPFX = "_!strli!_"; //Prefixed to all stringList var names
const string _STRLDLM = "\0";    //SINGLE CHARACTER Delimiter for items
//-

//+ List Management
bool stringListCreate(string &in asName) {
  string name = _STRLPFX + asName;
  //If Exists alread, don't overwrite
  if(GetLocalVarInt(name + "_exist")==1) return false;
  //Else continue as normal
  SetLocalVarInt(name + "_exist",1); //State list exists
  SetLocalVarInt(name + "_count",0);  //Put a count on the list
  SetLocalVarString(name,"");         //Define list w/ empty string
  return true;
}

bool stringListDestroy(string &in asName) {
  string name = _STRLPFX + asName;
  //If it doesn't exist - we can't destroy it
  if(GetLocalVarInt(name + "_exist")!=1) return false;
  //Else reduce all vars to min size - mark as not existing
  SetLocalVarInt(name + "_exist",0);  //State list doesn't exist
  SetLocalVarInt(name + "_count",0);  //Change the list count
  SetLocalVarString(name,"");         //Define list w/ empty string
  return true;
}

bool stringListExists(string &in asName) {
  return (GetLocalVarInt(_STRLPFX + asName + "_exist") == 1);
}

int stringListSize(string &in asName) {
  return (GetLocalVarInt(_STRLPFX + asName + "_count"));
}

void stringListClear(string &in asName) {
  string name = _STRLPFX + asName;
  //Don't do anything if list doesn't exist
  if(GetLocalVarInt(name + "_exist")!=1) return;
  //Else reset list to defaults
  SetLocalVarInt(name + "_count",0);  //Put a count on the list to 0
  SetLocalVarString(name,"");         //Define list w/ empty string
}

//- List Management

//+ Item Management
string[] stringListItems(string &in asName) {
  string str = GetLocalVarString(_STRLPFX + asName);
  //Output array vars
  string[] output = {};
  int outputIndex = 0;
  //Early-out if string is faulty
  if(!StringContains(str,_STRLDLM)) return output;
  //String matching vars
  uint8 dlm = _STRLDLM[0];
  int last = 0;
  //Loop and add each substring
  for(uint i =0; i<str.length(); i++) //For each char
   {
    if(str[i] == dlm) //If char matches delimiter
     {
      int len = int(i) - last; //Determine length of token to read
      if(len >= 0)
       {
        output.resize(outputIndex+1); //Increase array size
        output[outputIndex] = StringSub(str,last,len); //Get token into array
        outputIndex++; //Location of next token
       }
      last = i+1; //Say token begins at the next char
     }
   }
  //Return array of substrings
  return output;
}

int stringListAddItem(string &in asName, string &in asItem) {
  string name = _STRLPFX + asName;
  //Return error value if list doesn't exist
  if(GetLocalVarInt(name + "_exist")!=1) return -1;
  //Add the item with the delimiter, increment count
  int index = GetLocalVarInt(name + "_count");
  AddLocalVarInt(name + "_count",1);
  AddLocalVarString(name,asItem + _STRLDLM);
  return index;
}

void stringListAddItems(string &in asName, string[] asItem) {
  //Doesnt exist / Bad parameter? return.
  string name = _STRLPFX + asName;
  if(GetLocalVarInt(name + "_exist")!=1  || asItem.length()==0) return;
  //Append all items together w/ the delimiter
  string item = "";
  for(uint i =0; i<asItem.length(); i++) item += asItem[i] + _STRLDLM;
  //Add this new item string, Increment count
  AddLocalVarString(name,item);
  AddLocalVarInt(name + "_count",asItem.length());
}

string stringListGetItem(string &in asName, int alIndex) {
  //This is just an array fetch + grab at index
  string name = _STRLPFX + asName;
  string output = "";
  if(alIndex >= 0 && GetLocalVarInt(name + "_exist") == 1) //Parameters valid enough to progress?
   {
    string[] names = stringListItems(asName); //Get list of items
    if(alIndex < int(names.length()))
     {
      output = names[alIndex]; //Index in bounds: set ouput to item
     }
   }
  return output;
}

int stringListGetLastIndexof(string &in asName, string &in asItem) {
  //This is a linear search of the list of items
  string name = _STRLPFX + asName;
  int index = -1;
  if(GetLocalVarInt(name + "_exist") == 1)
   {
    string[] items = stringListItems(asName); //Get list of items
    for(int i=0; i<int(items.length()); i++)
     { if(asItem == items[i]) index = i; } //Search for match. If match set index to index of match.
   }
  return index;
}

int stringListGetFirstIndexof(string &in asName, string &in asItem) {
  //This is a linear search of the list of items
  string name = _STRLPFX + asName;
  int index = -1;
  if(GetLocalVarInt(name + "_exist") == 1)
   {
    string[] items = stringListItems(asName); //Get list of items
    for(uint i=0; i<items.length(); i++)
     {
      if(asItem == items[i])
        {
         index = int(i);
         i = items.length();
        }
     }
   }
  return index;
}

bool stringListContains(string &in asName, string &in asItem) {
  return stringListGetLastIndexof(asName, asItem)>=0;
}

bool stringListRemoveItemAt(string &in asName, uint alIndex) {
    string name = _STRLPFX + asName;
    //List exists?
    if(GetLocalVarInt(name + "_exist")!=1) return false;
    //Get list
    string[] list = stringListItems(asName);
    //Re-add all but deleted item
    string item = "";
    int count = 0;
    bool op = false;
    for(uint i =0; i<list.length(); i++)
    {
     if(i != alIndex)
      {
       item += list[i] + _STRLDLM;
       count++;
      }
     else op=true;
    }
    //Set back to the array
    SetLocalVarInt(name + "_count",count);  //Change count
    SetLocalVarString(name,item);           //Redefine list
    //Return if anything was deleted
    return op;
}

int stringListRemoveItems(string &in asName, string asItem) {
    string name = _STRLPFX + asName;
    //List exists?
    if(GetLocalVarInt(name + "_exist")!=1) return 0;
    //Get list
    string[] list = stringListItems(asName);
    //Re-add all but deleted items
    string item = "";
    int count = 0;
    int delamt = 0;
    for(uint i =0; i<list.length(); i++)
    {
     if(asItem != list[i])
      {
       item += list[i] + _STRLDLM;
       count++;
      }
     else delamt++;
    }
    //Set back to the array
    SetLocalVarInt(name + "_count",count);  //Change count
    SetLocalVarString(name,item);           //Redefine list
    //Return if anything was deleted
    return delamt;
}
//- Item Management

///////////////////////////////
//End String List
///////////////////////////////