Exemplo n.º 1
0
        public static bool TryParse(string text, out GameObjectInstance instance)
        {
            // TODO: find an existing GameObject with the same name before creating one;
            //   parsing the output of GameObjectInstance.ToString() will require converting pluralized names back to singular;
            //   We might only be able to parse well-structured plurals, as in "N singular-name" or "singular-name (xN)".
            //   ToString() could emit well-structured plurals and leave conversational formatting up to the client,
            //   or it could have a pluralization format parameter, knowing that reverse-parsing conversational plurals will not work.
            char[]   blank  = { ' ' };
            string[] tokens = text.Trim().Split(blank, StringSplitOptions.RemoveEmptyEntries);

            int count;

            if (tokens.Length > 1 && int.TryParse(tokens[0], out count))
            {
                string     name = text.Trim().Substring(tokens[0].Length).Trim();
                GameObject obj  = new GameObject(name);
                instance = new GameObjectInstance(obj, count);
                return(true);
            }
            else
            {
                instance = null;
                return(false);
            }
        }
Exemplo n.º 2
0
 private void GameObjectInstanceWriteXml(GameObjectInstance obj)
 {
     writer.WriteStartElement("Instance");
     Utility.WriteAttribute(writer, "Count", obj.Count, 1);
     GameObjectWriteXml(obj.Item);
     SaveObject(obj.Contents, "Contains");
     writer.WriteEndElement();
 }
Exemplo n.º 3
0
        private GameObjectInstance GameObjectInstanceFromXml(XmlNode node)
        {
            GameObjectInstance obj = new GameObjectInstance();

            obj.Count    = Utility.ParseAttribute(node, "Count", 1);
            obj.Item     = GameObjectFromXml(node.SelectSingleNode("GameObject"));
            obj.Contents = ItemListFromXml(node.SelectSingleNode("Contains"));
            return(obj);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Performs a die roll to generate one or more IResolvers from Item
        /// </summary>
        /// <returns></returns>
        public IResolver Roll()
        {
            //GameObjectInstance result = new GameObjectInstance(Item, Dice.Roll() * Multiplier);
            if (Item is GameObject)
            {
                GameObjectInstance item = new GameObjectInstance((GameObject)Item, Dice.Roll() * Multiplier);
                Logger.Write("... rolled " + item.ToString());
                return(item);
            }
            else if (Item is TableRoll && IsGrouped)
            {
                // Number of dice in Dice determines number of TableRolls performed.
                // Dice rolled with a single die determines number of occurrences of each TableRoll results.
                // e.g. if Dice = 4d10+2, 4 TableRolls are performed, and d10+2 is rolled to determine number of occurrences of each result.

                TableRoll t = (TableRoll)Item;
                Logger.Write("... performing " + Dice.Dice.ToString() + " rolls on " + t.Table.TableName);

                ItemList list       = new ItemList();
                DieRoll  singleRoll = new DieRoll(1, Dice.Sides, Dice.Modifier);
                for (int i = 0; i < Dice.Dice; i++)
                {
                    IResolver item = Item.Resolve();
                    if (item != null)
                    {
                        int count = singleRoll.Roll();
                        Logger.Write("... occurring " + count + " times");
                        for (int j = 0; j < count; j++)
                        {
                            list.Add(item);
                        }
                    }
                }
                return(list);
            }
            else
            {
                ItemList list  = new ItemList();
                int      count = Dice.Roll() * Multiplier;

                Logger.Write("... rolled " + Dice.ToString() + ": " + count.ToString());

                for (int i = 0; i < count; i++)
                {
                    list.Add(Item.Resolve());
                }
                return(list);
            }
        }
Exemplo n.º 5
0
        public IResolver Resolve()
        {
            Logger.Write("Resolve GameObject: " + Name);
            GameObjectInstance instance = new GameObjectInstance(this, 1);

            if (this.Contents == null)
            {
                instance.Contents = null;
            }
            else
            {
                instance.Contents = new ItemList();
                instance.Contents = (ItemList)(this.Contents.Resolve());
            }
            return(instance);
        }
Exemplo n.º 6
0
        //public int CompareTo(object other)
        //{
        //	if (other == null)
        //	{
        //		return 1;
        //	}
        //	else
        //	{
        //		return String.Compare(this.ToString(), other.ToString());
        //	}
        //}

        public int CompareTo(object other)
        {
            if (other == null)
            {
                return(1);
            }
            else
            {
                if (other is GameObjectInstance)
                {
                    GameObjectInstance otherInstance = (GameObjectInstance)other;
                    if (this.Item.Name == otherInstance.Item.Name)
                    {
                        return(this.Count.CompareTo(otherInstance.Count));
                    }
                    else
                    {
                        return(this.Item.Name.CompareTo(otherInstance.Item.Name));
                    }
                }
                else if (other is GameObject)
                {
                    string otherName = other.ToString();
                    if (this.Item.Name == otherName)
                    {
                        return(this.Count.CompareTo(1));
                    }
                    else
                    {
                        return(this.Item.Name.CompareTo(otherName));
                    }
                }
                else
                {
                    return(String.Compare(this.ToString(), other.ToString()));
                }
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Convert a text string to an IResolver
        /// </summary>
        /// <param name="itemText"></param>
        /// <returns></returns>
        public static IResolver ParseItem(string itemText)
        {
            char[] comma = { ',' };
            char[] blank = { ' ' };

            // if the item is a comma-separated list, parse it as an ItemList
            string[] items = itemText.Split(comma, StringSplitOptions.RemoveEmptyEntries);
            if (items.Length > 1)
            {
                ItemList itemList = new ItemList();
                foreach (string item in items)
                {
                    IResolver obj = ParseItem(item);
                    if (obj != null)
                    {
                        itemList.Add(obj);
                    }
                }
                return(itemList);
            }

            // parse an individual item
            else if (items.Length == 1)
            {
                DieRoll    dieRoll;
                GameObject gameObject;
                string     item = items[0];

                // ItemRoll
                string[] tokens = item.Split(blank, StringSplitOptions.RemoveEmptyEntries);
                if (DieRoll.TryParse(tokens[0], out dieRoll))
                {
                    string theRest = item.Substring(tokens[0].Length).Trim();
                    if (GameObject.TryParse(theRest, out gameObject))
                    {
                        return(new ItemRoll(gameObject, dieRoll));
                    }
                }

                // GameObjectInstance
                GameObjectInstance gameObjectInstance;
                if (GameObjectInstance.TryParse(item, out gameObjectInstance))
                {
                    return(gameObjectInstance);
                }

                // TableRoll
                if (item.ToLower().StartsWith("roll"))
                {
                    TableRoll tableRoll;
                    if (TableRoll.TryParse(item.Remove(0, 5), out tableRoll))
                    {
                        return(tableRoll);
                    }
                }

                // GameObject
                if (GameObject.TryParse(item, out gameObject))
                {
                    return(gameObject);
                }
            }
            return(null);
        }