Beispiel #1
0
 public virtual bool OnDraw(ScrollTemplate scroll)
 {
     return false;
 }
        public void CreateScroll(ScrollTemplate scrollTemplate)
        {
            var scrollInstance = new ScrollInstance(scrollTemplate);
            scrollInstance.Id         = AssetManager.GetNewScrollInstanceId();
            scrollInstance.Timestamp  = DateTime.UtcNow.Ticks;
            scrollInstance.SaveNeeded = true;

            Scrolls.Add(scrollInstance);
        }
        private static void LoadScrollTemplates()
        {
            DateTime startTime = DateTime.Now;

            ScrollTemplateStore = new List<ScrollTemplate>();

            SqlResult scrollResult = DatabaseManager.Database.Select("SELECT * FROM `scroll_template`");
            if (scrollResult != null)
            {
                for (int i = 0; i < scrollResult.Count; i++)
                {
                    var scrollTemplate = new ScrollTemplate();
                    scrollTemplate.Entry          = scrollResult.Read<ushort>(i, "entry");
                    scrollTemplate.Name           = scrollResult.Read<string>(i, "name");
                    scrollTemplate.Description    = scrollResult.Read<string>(i, "description");
                    scrollTemplate.Flavor         = scrollResult.Read<string>(i, "flavor");

                    SqlResult subTypeResult = DatabaseManager.Database.Select("SELECT `subType` FROM `scroll_template_subtype` WHERE `entry` = ?", scrollTemplate.Entry);
                    if (subTypeResult != null)
                    {
                        for (int j = 0; j < subTypeResult.Count; j++)
                        {
                            var subType = subTypeResult.Read<ScrollSubType>(j, "subType");
                            if (subType > ScrollSubType.Cat)
                            {
                                LogManager.Write("Asset Manager", "Failed to add subtype {0} to scroll template {1}, subtype is invalid!",
                                    scrollTemplate.Entry, subType);
                                continue;
                            }

                            scrollTemplate.SubTypes.Add(subType);
                        }
                    }

                    // generate sub type string
                    for (int j = 0; j < scrollTemplate.SubTypes.Count; j++ )
                    {
                        scrollTemplate.SubTypesStr += scrollTemplate.SubTypes[j].ToString();
                        if (j + 1 < scrollTemplate.SubTypes.Count)
                            scrollTemplate.SubTypesStr += ",";
                    }

                    scrollTemplate.Kind           = scrollResult.Read<ScrollKind>(i, "kind");

                    if (scrollTemplate.Kind > ScrollKind.STRUCTURE)
                    {
                        LogManager.Write("Asset Manager", "Failed to load scroll template {0}, template has invalid scroll kind {1}!",
                            scrollTemplate.Entry, scrollTemplate.Kind);
                        continue;
                    }

                    scrollTemplate.Rarity         = scrollResult.Read<byte>(i, "rarity");
                    scrollTemplate.Health         = scrollResult.Read<byte>(i, "health");
                    scrollTemplate.Attack         = scrollResult.Read<byte>(i, "attack");
                    scrollTemplate.Cooldown       = scrollResult.Read<sbyte>(i, "cooldown");
                    scrollTemplate.Resource       = scrollResult.Read<ResourceType>(i, "resource");

                    if (scrollTemplate.Resource > ResourceType.DECAY)
                    {
                        LogManager.Write("Asset Manager", "Failed to load scroll template {0}, template has invalid scroll resource type {1}!",
                            scrollTemplate.Entry, scrollTemplate.Resource);
                        continue;
                    }

                    scrollTemplate.Cost           = scrollResult.Read<byte>(i, "cost");

                    // calculate cost data for client
                    switch (scrollTemplate.Resource)
                    {
                        case ResourceType.ORDER:
                            scrollTemplate.CostOrder = scrollTemplate.Cost;
                            break;
                        case ResourceType.ENERGY:
                            scrollTemplate.CostEnergy = scrollTemplate.Cost;
                            break;
                        case ResourceType.GROWTH:
                            scrollTemplate.CostGrowth = scrollTemplate.Cost;
                            break;
                        case ResourceType.DECAY:
                            scrollTemplate.CostDecay = scrollTemplate.Cost;
                            break;
                    }

                    scrollTemplate.Set            = scrollResult.Read<byte>(i, "set");
                    scrollTemplate.LimitedWeight  = scrollResult.Read<float>(i, "limitedWeight");

                    // link tags to scroll template
                    var tagResult = DatabaseManager.Database.Select("SELECT `tagEntry`, `value` FROM `scroll_template_tag` WHERE `entry` = ?", scrollTemplate.Entry);
                    if (tagResult != null)
                    {
                        for (int j = 0; j < tagResult.Count; j++)
                        {
                            ushort tagEntry = tagResult.Read<ushort>(j, "tagEntry");

                            var tagTemplate = GetTagTemplate(tagEntry);
                            if (tagTemplate == null)
                            {
                                LogManager.Write("Asset Manager", "Failed to add tag {0} to scroll template {1}, tag entry is invalid!",
                                    tagEntry, scrollTemplate.Entry);
                                continue;
                            }

                            var scrollTag = new ScrollTag();
                            scrollTag.Name  = tagTemplate.Name;
                            scrollTag.Type  = tagTemplate.Type;
                            scrollTag.Value = tagResult.Read<string>(j, "value");
                            scrollTemplate.Tags.Add(scrollTag);
                        }
                    }

                    scrollTemplate.CardImage       = scrollResult.Read<ushort>(i, "cardImage");

                    if (scrollTemplate.CardImage == 0)
                    {
                        LogManager.Write("Asset Manager", "Failed to load scroll template {0}, template has invalid card image!", scrollTemplate.Entry);
                        continue;
                    }

                    scrollTemplate.AnimationImage  = scrollResult.Read<ushort>(i, "animationImage");
                    scrollTemplate.AnimationInfo   = scrollResult.Read<string>(i, "animationInfo");
                    scrollTemplate.AnimationBundle = scrollResult.Read<ushort>(i, "animationBundle");

                    // link abilities to scroll template
                    var abilityResult = DatabaseManager.Database.Select("SELECT `abilityEntry` FROM `scroll_template_ability` WHERE `entry` = ?", scrollTemplate.Entry);
                    if (abilityResult != null)
                    {
                        for (int j = 0; j < abilityResult.Count; j++)
                        {
                            ushort abilityEntry = abilityResult.Read<ushort>(j, "abilityEntry");

                            var abilityTemplate = GetAbilityTemplate(abilityEntry);
                            if (abilityTemplate == null)
                            {
                                LogManager.Write("Asset Manager", "Failed to add ability {0} to scroll template {1}, ability entry is invalid!",
                                    abilityEntry, scrollTemplate.Entry);
                                continue;
                            }

                            scrollTemplate.Abilities.Add(abilityTemplate);
                        }
                    }

                    scrollTemplate.TargetArea      = scrollResult.Read<ScrollTargetArea>(i, "targetArea");

                    if (scrollTemplate.TargetArea > ScrollTargetArea.ROW_FULL)
                    {
                        LogManager.Write("Asset Manager", "Failed to load scroll template {0}, template has invalid target area {1}!",
                            scrollTemplate.Entry, scrollTemplate.TargetArea);
                        continue;
                    }

                    // link passives to scroll template
                    var passiveResult = DatabaseManager.Database.Select("SELECT `passiveEntry` FROM `scroll_template_passive` WHERE `entry` = ?", scrollTemplate.Entry);
                    if (passiveResult != null)
                    {
                        for (int j = 0; j < passiveResult.Count; j++)
                        {
                            ushort passiveEntry = passiveResult.Read<ushort>(j, "passiveEntry");

                            var passiveTemplate = GetPassiveTemplate(passiveEntry);
                            if (passiveTemplate == null)
                            {
                                LogManager.Write("Asset Manager", "Failed to add passive {0} to scroll template {1}, passive entry is invalid!",
                                    passiveEntry, scrollTemplate.Entry);
                                continue;
                            }

                            scrollTemplate.Passives.Add(passiveTemplate);
                        }
                    }

                    ScrollTemplateStore.Add(scrollTemplate);
                }
            }

            LogManager.Write("Asset Manager", "Loaded {0} scroll(s) from database {1} milliseconds(s).", ScrollTemplateStore.Count, (DateTime.Now - startTime).Milliseconds);
        }
 public ScrollInstance(ScrollTemplate scrollTemplate)
 {
     Scroll = scrollTemplate;
     Stats  = new ScrollStats();
 }