Ejemplo n.º 1
0
        public override String GetSQLRequest()
        {
            String returnSql = "";

            if (m_creatureTemplateData.id == 0 || isError)
            {
                return(returnSql);
            }

            // Creature Template
            if (IsCheckboxChecked("template"))
            {
                m_creatureTemplateBuilder = new SqlBuilder("creature_template", "entry");
                m_creatureTemplateBuilder.SetFieldsNames("minlevel", "maxlevel", "name", "subname", "modelid1", "rank", "type", "family");

                m_creatureTemplateBuilder.AppendFieldsValue(m_creatureTemplateData.id, m_creatureTemplateData.minlevel, m_creatureTemplateData.maxlevel, m_creatureTemplateData.name, m_subname ?? "", m_modelid, m_isBoss ? "3" : "0", m_creatureTemplateData.type, m_creatureTemplateData.family);
                returnSql += m_creatureTemplateBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("health modifier") && m_creatureTemplateData.health != null)
            {
                SqlBuilder builder = new SqlBuilder("creature_template", "entry", SqlQueryType.Update);
                builder.SetFieldsNames("HealthModifier");

                String healthModifier = Tools.GetHealthModifier(float.Parse(m_creatureTemplateData.health), 6, m_creatureTemplateData.minlevel, 1);

                builder.AppendFieldsValue(m_creatureTemplateData.id, healthModifier);
                returnSql += builder.ToString() + "\n";
            }

            // faction
            if (IsCheckboxChecked("simple faction"))
            {
                SqlBuilder m_creatureFactionBuilder = new SqlBuilder("creature_template", "entry", SqlQueryType.Update);
                m_creatureFactionBuilder.SetFieldsNames("faction");

                m_creatureFactionBuilder.AppendFieldsValue(m_creatureTemplateData.id, m_faction);
                returnSql += m_creatureFactionBuilder.ToString() + "\n";
            }

            // Creature Template
            if (IsCheckboxChecked("money"))
            {
                SqlBuilder m_creatureMoneyBuilder = new SqlBuilder("creature_template", "entry", SqlQueryType.Update);
                m_creatureMoneyBuilder.SetFieldsNames("mingold", "maxgold");

                m_creatureMoneyBuilder.AppendFieldsValue(m_creatureTemplateData.id, m_creatureTemplateData.minGold, m_creatureTemplateData.maxGold);
                returnSql += m_creatureMoneyBuilder.ToString() + "\n";
            }

            // Locales
            if (IsCheckboxChecked("locale"))
            {
                LocaleConstant localeIndex = (LocaleConstant)Properties.Settings.Default.localIndex;

                String localeName = localeIndex.ToString();

                if (localeIndex != 0)
                {
                    m_creatureLocalesBuilder = new SqlBuilder("creature_template_locales", "entry");
                    m_creatureLocalesBuilder.SetFieldsNames("locale", "Name", "Title");

                    m_creatureLocalesBuilder.AppendFieldsValue(m_creatureTemplateData.id, localeIndex.ToString(), m_creatureTemplateData.name, m_subname ?? "");
                    returnSql += m_creatureLocalesBuilder.ToString() + "\n";
                }
                else
                {
                    m_creatureLocalesBuilder = new SqlBuilder("creature_template", "entry");
                    m_creatureLocalesBuilder.SetFieldsNames("name", "subname");

                    m_creatureLocalesBuilder.AppendFieldsValue(m_creatureTemplateData.id, m_creatureTemplateData.name, m_subname ?? "");
                    returnSql += m_creatureLocalesBuilder.ToString() + "\n";
                }
            }

            if (IsCheckboxChecked("vendor") && m_npcVendorDatas != null)
            {
                m_npcVendorBuilder = new SqlBuilder("npc_vendor", "entry", SqlQueryType.DeleteInsert);
                m_npcVendorBuilder.SetFieldsNames("slot", "item", "maxcount", "incrtime", "ExtendedCost", "type", "PlayerConditionID");

                foreach (NpcVendorParsing npcVendorData in m_npcVendorDatas)
                {
                    m_npcVendorBuilder.AppendFieldsValue(m_creatureTemplateData.id, npcVendorData.slot, npcVendorData.id, npcVendorData.avail, npcVendorData.incrTime, npcVendorData.integerExtendedCost, 1, 0);
                }

                returnSql += m_npcVendorBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("loot") && m_creatureLootDatas != null)
            {
                bool referenceAdded   = false;
                int  maxReferenceLoot = 2; // A voir si on peut trouver

                int templateEntry = m_creatureTemplateData.id;
                m_creatureLootBuilder = new SqlBuilder("creature_loot_template", "entry", SqlQueryType.DeleteInsert);
                m_creatureLootBuilder.SetFieldsNames("Item", "Reference", "Chance", "QuestRequired", "LootMode", "GroupId", "MinCount", "MaxCount", "Comment");

                m_creatureReferenceLootBuilder = new SqlBuilder("reference_loot_template", "entry", SqlQueryType.DeleteInsert);
                m_creatureReferenceLootBuilder.SetFieldsNames("Item", "Reference", "Chance", "QuestRequired", "LootMode", "GroupId", "MinCount", "MaxCount", "Comment");

                returnSql += "UPDATE creature_template SET lootid = " + templateEntry + " WHERE entry = " + templateEntry + " AND lootid = 0;\n";
                foreach (CreatureLootParsing creatureLootData in m_creatureLootDatas)
                {
                    List <int> entryList = new List <int>();

                    CreatureLootItemParsing creatureLootItemData = null;
                    try
                    {
                        creatureLootItemData = (CreatureLootItemParsing)creatureLootData;
                    }
                    catch (Exception ex) { }

                    CreatureLootCurrencyParsing creatureLootCurrencyData = null;
                    try
                    {
                        creatureLootCurrencyData = (CreatureLootCurrencyParsing)creatureLootData;
                    }
                    catch (Exception ex) { }

                    int minLootCount = creatureLootData.stack.Length >= 1 ? creatureLootData.stack[0] : 1;
                    int maxLootCount = creatureLootData.stack.Length >= 2 ? creatureLootData.stack[1] : minLootCount;

                    // If bonuses, certainly an important loot, set to references
                    if (!IsCheckboxChecked("Is Dungeon/Raid Boss") || (creatureLootItemData == null || creatureLootItemData.bonustrees == null))
                    {
                        switch (creatureLootData.mode)
                        {
                        default:
                            entryList.Add(templateEntry);
                            break;;
                        }

                        foreach (int entry in entryList)
                        {
                            int idMultiplier = creatureLootCurrencyData != null ? -1 : 1;

                            if (idMultiplier < 1)
                            {
                                continue;
                            }

                            m_creatureLootBuilder.AppendFieldsValue(entry,                              // Entry
                                                                    creatureLootData.id * idMultiplier, // Item
                                                                    0,                                  // Reference
                                                                    creatureLootData.percent,           // Chance
                                                                    creatureLootData.questRequired,     // QuestRequired
                                                                    1,                                  // LootMode
                                                                    0,                                  // GroupId
                                                                    minLootCount,                       // MinCount
                                                                    maxLootCount,                       // MaxCount
                                                                    "");                                // Comment
                        }
                    }
                    else
                    {
                        if (!referenceAdded)
                        {
                            m_creatureLootBuilder.AppendFieldsValue(templateEntry,    // Entry
                                                                    0,                // Item
                                                                    templateEntry,    // Reference
                                                                    100,              // Chance
                                                                    0,                // QuestRequired
                                                                    1,                // LootMode
                                                                    0,                // GroupId
                                                                    maxReferenceLoot, // MinCount
                                                                    maxReferenceLoot, // MaxCount
                                                                    "");              // Comment
                            referenceAdded = true;
                        }

                        m_creatureReferenceLootBuilder.AppendFieldsValue(templateEntry,                  // Entry
                                                                         creatureLootData.id,            // Item
                                                                         0,                              // Reference
                                                                         creatureLootData.percent,       // Chance
                                                                         creatureLootData.questRequired, // QuestRequired
                                                                         1,                              // LootMode
                                                                         1,                              // GroupId
                                                                         minLootCount,                   // MinCount
                                                                         maxLootCount,                   // MaxCount
                                                                         "");                            // Comment
                    }
                }

                returnSql += m_creatureLootBuilder.ToString() + "\n";
                returnSql += m_creatureReferenceLootBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("skinning") && m_creatureSkinningDatas != null)
            {
                m_creatureSkinningBuilder = new SqlBuilder("skinning_loot_template", "entry", SqlQueryType.DeleteInsert);
                m_creatureSkinningBuilder.SetFieldsNames("Item", "Reference", "Chance", "QuestRequired", "LootMode", "GroupId", "MinCount", "MaxCount", "Comment");

                returnSql += "UPDATE creature_template SET skinloot = " + m_creatureTemplateData.id + " WHERE entry = " + m_creatureTemplateData.id + " AND skinloot = 0;\n";
                foreach (CreatureLootParsing creatureSkinningData in m_creatureSkinningDatas)
                {
                    m_creatureSkinningBuilder.AppendFieldsValue(m_creatureTemplateData.id,     // Entry
                                                                creatureSkinningData.id,       // Item
                                                                0,                             // Reference
                                                                creatureSkinningData.percent,  // Chance
                                                                0,                             // QuestRequired
                                                                1,                             // LootMode
                                                                0,                             // GroupId
                                                                creatureSkinningData.stack[0], // MinCount
                                                                creatureSkinningData.stack[1], // MaxCount
                                                                "");                           // Comment
                }

                returnSql += m_creatureSkinningBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("trainer") && m_creatureTrainerDatas != null)
            {
                m_creatureTrainerBuilder = new SqlBuilder("npc_trainer", "entry", SqlQueryType.DeleteInsert);
                m_creatureTrainerBuilder.SetFieldsNames("spell", "spellcost", "reqskill", "reqskillvalue", "reqlevel");

                returnSql += "UPDATE creature_template SET npc_flag = 16 WHERE entry = " + m_creatureTemplateData.id + ";\n";
                foreach (CreatureTrainerParsing creatureTrainerData in m_creatureTrainerDatas)
                {
                    int reqskill = creatureTrainerData.learnedat > 0 ? creatureTrainerData.skill[0] : 0;
                    m_creatureTrainerBuilder.AppendFieldsValue(m_creatureTemplateData.id, creatureTrainerData.id, creatureTrainerData.trainingcost, reqskill, creatureTrainerData.learnedat, creatureTrainerData.level);
                }

                returnSql += m_creatureTrainerBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("quest starter") && m_creatureQuestStarterDatas != null)
            {
                m_creatureQuestStarterBuilder = new SqlBuilder("creature_queststarter", "entry", SqlQueryType.DeleteInsert);
                m_creatureQuestStarterBuilder.SetFieldsNames("quest");

                foreach (QuestStarterEnderParsing creatureQuestStarterData in m_creatureQuestStarterDatas)
                {
                    m_creatureQuestStarterBuilder.AppendFieldsValue(m_creatureTemplateData.id, creatureQuestStarterData.id);
                }

                returnSql += m_creatureQuestStarterBuilder.ToString() + "\n";
            }

            if (IsCheckboxChecked("quest ender") && m_creatureQuestEnderDatas != null)
            {
                m_creatureQuestEnderBuilder = new SqlBuilder("creature_questender", "entry", SqlQueryType.DeleteInsert);
                m_creatureQuestEnderBuilder.SetFieldsNames("quest");

                foreach (QuestStarterEnderParsing creatureQuestEnderData in m_creatureQuestEnderDatas)
                {
                    m_creatureQuestEnderBuilder.AppendFieldsValue(m_creatureTemplateData.id, creatureQuestEnderData.id);
                }

                returnSql += m_creatureQuestEnderBuilder.ToString() + "\n";
            }

            return(returnSql);
        }
Ejemplo n.º 2
0
        public void SetCreatureLootData(CreatureLootItemParsing[] creatureLootItemDatas, CreatureLootCurrencyParsing[] creatureLootCurrencyDatas)
        {
            List <CreatureLootParsing> lootsData = new List <CreatureLootParsing>();

            List <String> modes = new List <String>()
            {
                "4", "8", "16", "32", "64", "65536", "131072", "33554432"
            };

            CreatureLootParsing[] allLootData = new CreatureLootParsing[creatureLootItemDatas.Length + creatureLootCurrencyDatas.Length];
            Array.Copy(creatureLootItemDatas, allLootData, creatureLootItemDatas.Length);
            Array.Copy(creatureLootCurrencyDatas, 0, allLootData, creatureLootItemDatas.Length, creatureLootCurrencyDatas.Length);

            for (uint i = 0; i < allLootData.Length; ++i)
            {
                float  count       = 0.0f;
                float  outof       = 0.0f;
                float  percent     = 0.0f;
                String currentMode = "";

                try
                {
                    String realItemMode      = allLootData[i].modes["mode"];
                    String treatmentItemMode = realItemMode;

                    switch (realItemMode)
                    {
                    case "24":
                        treatmentItemMode = "8";
                        break;

                    case "33554433":
                    case "33554434":
                        treatmentItemMode = "4";
                        break;
                    }

                    count = (float)Convert.ToDouble(allLootData[i].modes[treatmentItemMode]["count"]);
                    outof = (float)Convert.ToDouble(allLootData[i].modes[treatmentItemMode]["outof"]);

                    if (count == -1 || count > outof)
                    {
                        percent = 0;
                    }
                    else
                    {
                        percent = count * 100 / outof;
                    }

                    if (count < 25 && percent < 0.05f)
                    {
                        continue;
                    }

                    currentMode = realItemMode;
                }
                catch (Exception)
                {
                    foreach (String mode in modes)
                    {
                        try
                        {
                            count   = (float)Convert.ToDouble(allLootData[i].modes[mode]["count"]);
                            outof   = (float)Convert.ToDouble(allLootData[i].modes[mode]["outof"]);
                            percent = count * 100 / outof;

                            if (count < 25 && percent < 0.05f)
                            {
                                continue;
                            }

                            currentMode = mode;
                            break;
                        }
                        catch (Exception)
                        {
                        }
                    }
                }

                if (currentMode == "")
                {
                    continue;
                }

                CreatureLootItemParsing currentItemParsing = null;
                try
                {
                    currentItemParsing = (CreatureLootItemParsing)allLootData[i];
                }
                catch (Exception ex) { }

                allLootData[i].questRequired = (currentItemParsing != null && currentItemParsing.classs == 12) ? "1" : "0";
                allLootData[i].percent       = Tools.NormalizeFloat(percent);
                allLootData[i].mode          = currentMode;
                lootsData.Add(allLootData[i]);
            }

            m_creatureLootDatas = lootsData.ToArray();
        }