[FIX] general is now merged into pokemod

[FIX] Added ItemEffect widget code

git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@153 6ecfd1a5-f3ed-3746-8530-beee90d26b22

1 files changed, 443 insertions, 0 deletions

diff --git a/pokemodr/ItemEffectUI.cpp b/pokemodr/ItemEffectUI.cpp
new file mode 100644
index 00000000..bece9c10
--- /dev/null
+++ b/pokemodr/ItemEffectUI.cpp
@@ -0,0 +1,443 @@
+/*
+ * Copyright 2008 Ben Boeckel <MathStuf@gmail.com>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Header include
+#include "ItemEffectUI.h"
+
+// Pokemod includes
+#include "../pokemod/ItemEffect.h"
+#include "../pokemod/MapWildList.h"
+#include "../pokemod/Pokemod.h"
+#include "../pokemod/Rules.h"
+#include "../pokemod/Time.h"
+#include "../pokemod/Type.h"
+
+ItemEffectUI::ItemEffectUI(ItemEffect* effect, QWidget* parent) :
+        ObjectUI(parent),
+        m_lastEffect(-1),
+        m_lastValue2(-1),
+        m_lastValue4(-1)
+{
+    setupUi(this);
+    QMetaObject::connectSlotsByName(this);
+    setObjects(effect, new ItemEffect(*effect));
+    init();
+}
+
+ItemEffectUI::~ ItemEffectUI()
+{
+}
+
+void ItemEffectUI::initGui()
+{
+    varEffect->addItems(ItemEffect::EffectStr);
+}
+
+void ItemEffectUI::setGui()
+{
+    const bool resetEffect = (static_cast<ItemEffect*>(modified())->effect() == m_lastEffect);
+    const bool resetValue2 = ((static_cast<ItemEffect*>(modified())->value2() == m_lastValue2) || m_lastEffect);
+    const bool resetValue4 = ((static_cast<ItemEffect*>(modified())->value4() == m_lastValue4) || m_lastEffect);
+    const bool isSplit = static_cast<const Pokemod*>(original()->pokemod())->rules()->specialSplit();
+    varOverworld->setChecked(static_cast<ItemEffect*>(modified())->overworld() ? Qt::Checked : Qt::Unchecked);
+    varBattle->setChecked(static_cast<ItemEffect*>(modified())->battle() ? Qt::Checked : Qt::Unchecked);
+    varHeld->setChecked(static_cast<ItemEffect*>(modified())->held() ? Qt::Checked : Qt::Unchecked);
+    varEffect->setCurrentIndex(static_cast<ItemEffect*>(modified())->effect());
+    m_lastEffect = static_cast<ItemEffect*>(modified())->effect();
+    if (resetEffect)
+    {
+        switch (m_lastEffect)
+        {
+            case ItemEffect::E_Revive:
+            case ItemEffect::E_LevelBoost:
+            case ItemEffect::E_StatBoost:
+            case ItemEffect::E_PPBoost:
+            case ItemEffect::E_Fish:
+            case ItemEffect::E_Repel:
+            case ItemEffect::E_Escape:
+            case ItemEffect::E_TM:
+            case ItemEffect::E_HM:
+            case ItemEffect::E_Map:
+            case ItemEffect::E_Itemfinder:
+            case ItemEffect::E_Bike:
+            case ItemEffect::E_Scope:
+            case ItemEffect::E_Coin:
+            case ItemEffect::E_CoinCase:
+            case ItemEffect::E_Acorn:
+            case ItemEffect::E_Evolution:
+            case ItemEffect::E_Flinch:
+            case ItemEffect::E_First:
+            case ItemEffect::E_KeepAlive:
+            case ItemEffect::E_ModifyStatBattle:
+            case ItemEffect::E_ShieldBattle:
+            case ItemEffect::E_RunBattle:
+            case ItemEffect::E_TypeBoost:
+            case ItemEffect::E_ExpShare:
+            case ItemEffect::E_Ball:
+            case ItemEffect::E_Berry:
+                varOverworld->setEnabled(false);
+                break;
+            default:
+                varOverworld->setEnabled(true);
+                break;
+        }
+        varValue1->setEnabled(true);
+        varValue2->clear();
+        varValue2->setEnabled(true);
+        varValue3->clear();
+        varValue3->setEnabled(true);
+        varValue4->setEnabled(true);
+        varValue4->setBehavior(((ItemEffect::E_TypeBoost == m_lastEffect) || (ItemEffect::E_PPBoost == m_lastEffect)) ? -1 : 1);
+        switch (m_lastEffect)
+        {
+            case ItemEffect::E_HPCure:
+            case ItemEffect::E_Revive:
+                // Value 4 dependent
+            case ItemEffect::E_Ball:
+                // Value 2 dependent
+                break;
+            case ItemEffect::E_LevelBoost:
+            case ItemEffect::E_ShieldBattle:
+            case ItemEffect::E_PPBoost:
+            case ItemEffect::E_Repel:
+                varValue1->setRange(1, INT_MAX);
+                break;
+            case ItemEffect::E_StatBoost:
+            case ItemEffect::E_Acorn:
+                varValue1->setRange(0, 65535);
+                break;
+            case ItemEffect::E_ModifyStatBattle:
+                varValue1->setRange(-12, 12);
+                break;
+            case ItemEffect::E_Fish:
+            case ItemEffect::E_Coin:
+            case ItemEffect::E_CoinCase:
+                varValue1->setRange(0, INT_MAX);
+                break;
+            default:
+                varValue1->setEnabled(false);
+                break;
+        }
+        switch (m_lastEffect)
+        {
+            // TODO: Value2 code
+//             case ItemEffect::E_HPCure:
+//             case ItemEffect::E_Revive:
+//                 if (ItemEffect::R_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_CureStatus:
+//                 if (Pokemod::STS_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_StatBoost:
+//                 if ((value2 <= 0) || (65536 <= value2))
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_ModifyStatBattle:
+//                 if (Pokemod::ST_End_Battle <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_ShieldBattle:
+//                 if (ItemEffect::SP_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_TypeBoost:
+//                 if (static_cast<const Pokemod*>(pokemod())->typeIndex(value2) == INT_MAX)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_PPRestore:
+//                 if (ItemEffect::A_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Repel:
+//                 if (ItemEffect::RP_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Escape:
+//                 if (ItemEffect::ES_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_TM:
+//             case ItemEffect::E_HM:
+//                 if (static_cast<const Pokemod*>(pokemod())->moveIndex(value2) == INT_MAX)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Ball:
+//                 if (ItemEffect::B_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Scope:
+//                 break;
+//             case ItemEffect::E_Berry:
+//                 if (ItemEffect::B2_End <= value2)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Coin:
+//             case ItemEffect::E_CoinCase:
+//                 if (value2 <= 0)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             case ItemEffect::E_Acorn:
+//                 if (static_cast<const Pokemod*>(pokemod())->itemIndex(value2) == INT_MAX)
+//                 {
+//                     emit(error(bounds("value2")));
+//                     return;
+//                 }
+//                 break;
+//             default:
+//                 varValue2->setEnabled(false);
+//                 break;
+        }
+        switch (m_lastEffect)
+        {
+            case ItemEffect::E_StatBoost:
+                for (int i = 0; i < (isSplit ? Pokemod::ST_End_GSC : Pokemod::ST_End_RBY); ++i)
+                    varValue3->addItem((isSplit ? Pokemod::StatGSCStr : Pokemod::StatRBYStr)[i], i);
+                break;
+            case ItemEffect::E_Ball:
+                // Value 2 dependent
+            case ItemEffect::E_Berry:
+                // Value 2 dependent
+                break;
+            default:
+                varValue3->setEnabled(false);
+                break;
+        }
+        switch (m_lastEffect)
+        {
+            case ItemEffect::E_CureStatus:
+            case ItemEffect::E_LevelBoost:
+            case ItemEffect::E_StatBoost:
+            case ItemEffect::E_ModifyStatBattle:
+            case ItemEffect::E_Fish:
+            case ItemEffect::E_Escape:
+            case ItemEffect::E_TM:
+            case ItemEffect::E_HM:
+            case ItemEffect::E_Map:
+            case ItemEffect::E_Itemfinder:
+            case ItemEffect::E_Bike:
+            case ItemEffect::E_Scope:
+            case ItemEffect::E_Coin:
+            case ItemEffect::E_CoinCase:
+            case ItemEffect::E_Acorn:
+            case ItemEffect::E_Evolution:
+                varValue4->setEnabled(false);
+                break;
+            case ItemEffect::E_Ball:
+                if (m_lastValue2 == ItemEffect::B_Master)
+                    varValue4->setEnabled(false);
+                break;
+            case ItemEffect::E_Berry:
+                if (m_lastValue2 != ItemEffect::B2_HPCure)
+                    varValue4->setEnabled(false);
+                break;
+        }
+    }
+    varValue2->setCurrentIndex(varValue2->findData(static_cast<ItemEffect*>(modified())->value2()));
+    m_lastValue2 = static_cast<ItemEffect*>(modified())->value2();
+    if (resetValue2)
+    {
+        if (m_lastEffect == ItemEffect::E_Ball)
+        {
+            switch (m_lastValue2)
+            {
+                case ItemEffect::B_Regular:
+                    varValue1->setRange(0, 255);
+                    break;
+                case ItemEffect::B_Level:
+                    varValue1->setRange(0, static_cast<const Pokemod*>(original()->pokemod())->rules()->maxLevel());
+                    break;
+                case ItemEffect::B_Master:
+                case ItemEffect::B_Love:
+                case ItemEffect::B_Area:
+                case ItemEffect::B_Time:
+                case ItemEffect::B_Battle:
+                case ItemEffect::B_Friend:
+                case ItemEffect::B_Stat:
+                case ItemEffect::B_Type:
+                case ItemEffect::B_Weight:
+                    break;
+                default:
+                    varValue1->setEnabled(false);
+                    break;
+            }
+            switch (m_lastValue2)
+            {
+                case ItemEffect::B_Level:
+                case ItemEffect::B_Friend:
+                case ItemEffect::B_Weight:
+                    // TODO: ???
+                    break;
+                case ItemEffect::B_Area:
+                    varValue3->addItems(MapWildList::ControlStr);
+                    for (int i = 0; i < MapWildList::End; ++i)
+                        varValue3->setItemData(i, i);
+                    break;
+                case ItemEffect::B_Time:
+                    for (int i = 0; i < static_cast<const Pokemod*>(original()->pokemod())->timeCount(); ++i)
+                    {
+                        const Time* time = static_cast<const Pokemod*>(original()->pokemod())->time(i);
+                        varValue3->addItem(time->name(), time->id());
+                    }
+                    break;
+                case ItemEffect::B_Stat:
+                    for (int i = 0; i < (isSplit ? Pokemod::ST_End_GSC : Pokemod::ST_End_RBY); ++i)
+                        varValue3->addItem((isSplit ? Pokemod::StatGSCStr : Pokemod::StatRBYStr)[i], i);
+                    break;
+                case ItemEffect::B_Type:
+                    for (int i = 0; i < static_cast<const Pokemod*>(original()->pokemod())->typeCount(); ++i)
+                    {
+                        const Type* type = static_cast<const Pokemod*>(original()->pokemod())->type(i);
+                        varValue3->addItem(type->name(), type->id());
+                    }
+                    break;
+                case ItemEffect::B_Regular:
+                case ItemEffect::B_Master:
+                case ItemEffect::B_Love:
+                case ItemEffect::B_Battle:
+                    varValue3->setEnabled(false);
+                    break;
+            }
+        }
+        else if (m_lastEffect == ItemEffect::E_Berry)
+        {
+            switch (m_lastValue2)
+            {
+                case ItemEffect::B2_HPCure:
+                    varValue3->addItems(Pokemod::RelativeStr);
+                    for (int i = 0; i < Pokemod::REL_End; ++i)
+                        varValue3->setItemData(i, i);
+                    break;
+                case ItemEffect::B2_StatusCure:
+                    varValue3->addItems(Pokemod::StatusStr);
+                    for (int i = 0; i < Pokemod::STS_End; ++i)
+                        varValue3->setItemData(i, i);
+                    break;
+                default:
+                    varValue3->setEnabled(false);
+                    break;
+            }
+        }
+    }
+    varValue4->setValue(static_cast<ItemEffect*>(modified())->value4());
+    m_lastValue4 = static_cast<ItemEffect*>(modified())->value4();
+    if (resetValue4)
+    {
+        if ((m_lastValue4 == ItemEffect::E_HPCure) || (m_lastValue4 == ItemEffect::E_Revive))
+        {
+            if (m_lastValue4 == ItemEffect::R_Absolute)
+                varValue1->setRange(1, INT_MAX);
+            else
+                varValue1->setEnabled(false);
+        }
+    }
+    varValue1->setValue(static_cast<ItemEffect*>(modified())->value1());
+    varValue3->setCurrentIndex(varValue3->findData(static_cast<ItemEffect*>(modified())->value3()));
+}
+
+void ItemEffectUI::apply()
+{
+    *static_cast<ItemEffect*>(original()) = *static_cast<ItemEffect*>(modified());
+    emit(changed(false));
+}
+
+void ItemEffectUI::discard()
+{
+    *static_cast<ItemEffect*>(modified()) = *static_cast<ItemEffect*>(original());
+    setGui();
+    emit(changed(false));
+}
+
+void ItemEffectUI::on_varOverworld_toggled(const bool overworld)
+{
+    static_cast<ItemEffect*>(modified())->setOverworld(overworld);
+}
+
+void ItemEffectUI::on_varBattle_toggled(const bool battle)
+{
+    static_cast<ItemEffect*>(modified())->setBattle(battle);
+}
+
+void ItemEffectUI::on_varHeld_toggled(const bool held)
+{
+    static_cast<ItemEffect*>(modified())->setHeld(held);
+}
+
+void ItemEffectUI::on_varEffect_currentIndexChanged(const int effect)
+{
+    static_cast<ItemEffect*>(modified())->setEffect(effect);
+}
+
+void ItemEffectUI::on_varValue1_valueChanged(const int value1)
+{
+    static_cast<ItemEffect*>(modified())->setValue1(value1);
+}
+
+void ItemEffectUI::on_varValue2_currentIndexChanged(const int value2)
+{
+    static_cast<ItemEffect*>(modified())->setValue2(varValue2->itemData(value2).toInt());
+}
+
+void ItemEffectUI::on_varValue3_currentIndexChanged(const int value3)
+{
+    static_cast<ItemEffect*>(modified())->setValue3(varValue3->itemData(value3).toInt());
+}
+
+void ItemEffectUI::on_varValue4_valueChanged(const Fraction& value4)
+{
+    static_cast<ItemEffect*>(modified())->setValue4(value4);
+}