public bool AddMaximumAmount(RecourceType type, int amount, out int changed)
    {
        int freeSpace = GetFreeSpace();

        //  Debug.Log("free " + freeSpace + " amount " + amount);
        if (AcceptableTypes.Contains(RecourceType.all) || AcceptableTypes.Contains(type))
        {
            if (freeSpace >= amount)
            {
                // Debug.Log("f>=a, changed for a");
                changeRecource(type, amount);
                changed = amount;
                return(true);
            }
            else
            {
                // Debug.Log("f<a, changed for f");
                changeRecource(type, freeSpace);
                changed = freeSpace;
                return(false);
            }
        }
        // Debug.Log("unacceptable type");
        changed = 0;
        return(false);
    }
Exemplo n.º 2
0
        public override void Write(ISerializerStream stream)
        {
            foreach (var viewModelPropertyData in Ctx.Data.LocalProperties)
            {
                var relatedNode = viewModelPropertyData.RelatedTypeNode;
                if (relatedNode is EnumNode)
                {
                    Ctx._("stream.SerializeInt(\"{0}\", (int)this.{0});", viewModelPropertyData.Name);
                }
                else if (relatedNode is ElementNode)
                {
                    Ctx._("if (stream.DeepSerialize) stream.SerializeObject(\"{0}\", this.{0});",
                          viewModelPropertyData.Name);
                }
                else if (relatedNode is StateMachineNode)
                {
                    Ctx._("stream.SerializeString(\"{0}\", this.{0}.Name);", viewModelPropertyData.Name);
                }
                else
                {
                    if (viewModelPropertyData.Type == null)
                    {
                        continue;
                    }
                    if (!AcceptableTypes.ContainsKey(viewModelPropertyData.Type))
                    {
                        continue;
                    }
                    Ctx._("stream.Serialize{0}(\"{1}\", this.{1})", AcceptableTypes[viewModelPropertyData.Type],
                          viewModelPropertyData.Name);
                }
            }
            foreach (var collection in Ctx.Data.LocalCollections)
            {
                var relatedNode = collection.RelatedTypeNode;
                if (relatedNode is EnumNode)
                {
                    //var statement = new CodeSnippetStatement(string.Format("\t\tstream.SerializeInt(\"{0}\", (int)this.{0});", viewModelPropertyData.Name));
                    //writeMethod.Statements.Add(statement);

                    //var dstatement = new CodeSnippetStatement(string.Format("\t\tthis.{0} = ({1})stream.DeserializeInt(\"{0}\");", viewModelPropertyData.Name, viewModelPropertyData.RelatedTypeName));
                    //readMethod.Statements.Add(dstatement);
                }
                else if (relatedNode is ElementNode)
                {
                    Ctx._("if (stream.DeepSerialize) stream.SerializeArray(\"{0}\", this.{0})",
                          collection.Name);
                }
                else
                {
                    //if (collection.Type == null) continue;
                    //if (!AcceptableTypes.ContainsKey(viewModelPropertyData.Type)) continue;
                    //viewModelPropertyData.IsEnum(data.OwnerData);
                    //var statement = new CodeSnippetStatement(string.Format("\t\tstream.Serialize{0}(\"{1}\", this.{1});", AcceptableTypes[viewModelPropertyData.Type], viewModelPropertyData.Name));
                    //writeMethod.Statements.Add(statement);

                    //var dstatement = new CodeSnippetStatement(string.Format("\t\tthis.{0} = stream.Deserialize{1}(\"{0}\");", viewModelPropertyData.Name, AcceptableTypes[viewModelPropertyData.Type]));
                    //readMethod.Statements.Add(dstatement);
                }
            }
        }