QTfrontend/gamecfgwidget.cpp
branchexperimental3D
changeset 4812 f924be23ffb4
parent 4720 a9f9c96db60c
child 4936 d65d438acd23
equal deleted inserted replaced
4347:0ddb100fea61 4812:f924be23ffb4
    28 
    28 
    29 #include "gamecfgwidget.h"
    29 #include "gamecfgwidget.h"
    30 #include "igbox.h"
    30 #include "igbox.h"
    31 #include "hwconsts.h"
    31 #include "hwconsts.h"
    32 #include "ammoSchemeModel.h"
    32 #include "ammoSchemeModel.h"
    33 
    33 #include "proto.h"
    34 GameCFGWidget::GameCFGWidget(QWidget* parent, bool externalControl) :
    34 
       
    35 GameCFGWidget::GameCFGWidget(QWidget* parent) :
    35   QGroupBox(parent), mainLayout(this)
    36   QGroupBox(parent), mainLayout(this)
    36 {
    37 {
    37     mainLayout.setMargin(0);
    38     mainLayout.setMargin(0);
    38 //  mainLayout.setSizeConstraint(QLayout::SetMinimumSize);
    39 //  mainLayout.setSizeConstraint(QLayout::SetMinimumSize);
    39 
    40 
    40     pMapContainer = new HWMapContainer(this);
    41     pMapContainer = new HWMapContainer(this);
    41     mainLayout.addWidget(pMapContainer, 0, 0);
    42     mainLayout.addWidget(pMapContainer, 0, 0);
    42 
    43 
    43     IconedGroupBox *GBoxOptions = new IconedGroupBox(this);
    44     IconedGroupBox *GBoxOptions = new IconedGroupBox(this);
    44     GBoxOptions->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
    45     GBoxOptions->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
    45     mainLayout.addWidget(GBoxOptions);
    46     mainLayout.addWidget(GBoxOptions, 1, 0);
    46 
    47 
    47     QGridLayout *GBoxOptionsLayout = new QGridLayout(GBoxOptions);
    48     QGridLayout *GBoxOptionsLayout = new QGridLayout(GBoxOptions);
    48 
    49 
    49     GameSchemes = new QComboBox(GBoxOptions);
    50     GBoxOptionsLayout->addWidget(new QLabel(QLabel::tr("Gameplay"), GBoxOptions), 0, 0);
    50     GBoxOptionsLayout->addWidget(GameSchemes, 0, 1);
    51 
       
    52     Scripts = new QComboBox(GBoxOptions);
       
    53     GBoxOptionsLayout->addWidget(Scripts, 0, 1);
       
    54 
       
    55     Scripts->addItem("Normal");
       
    56     Scripts->insertSeparator(1);
       
    57 
       
    58     for (int i = 0; i < scriptList->size(); ++i) {
       
    59         QString script = (*scriptList)[i].remove(".lua", Qt::CaseInsensitive);
       
    60         QList<QVariant> scriptInfo;
       
    61         scriptInfo.push_back(script);
       
    62         QFile scriptCfgFile(QString("%1/Scripts/Multiplayer/%2.cfg").arg(datadir->absolutePath()).arg(script));
       
    63         if (scriptCfgFile.exists() && scriptCfgFile.open(QFile::ReadOnly)) {
       
    64             QString scheme;
       
    65             QString weapons;
       
    66             QTextStream input(&scriptCfgFile);
       
    67             input >> scheme;
       
    68             input >> weapons;
       
    69             if (scheme.isEmpty())
       
    70                 scheme = "locked";
       
    71             scheme.replace("_", " ");
       
    72             if (weapons.isEmpty())
       
    73                 weapons = "locked";
       
    74             weapons.replace("_", " ");
       
    75             scriptInfo.push_back(scheme);
       
    76             scriptInfo.push_back(weapons);
       
    77             scriptCfgFile.close();
       
    78         }
       
    79         else
       
    80         {
       
    81             scriptInfo.push_back("locked");
       
    82             scriptInfo.push_back("locked");
       
    83         }
       
    84         Scripts->addItem(script.replace("_", " "), scriptInfo);
       
    85     }
       
    86 
       
    87     connect(Scripts, SIGNAL(currentIndexChanged(int)), this, SLOT(scriptChanged(int)));
       
    88 
       
    89     QWidget *SchemeWidget = new QWidget(GBoxOptions);
       
    90     GBoxOptionsLayout->addWidget(SchemeWidget, 1, 0, 1, 2);
       
    91 
       
    92     QGridLayout *SchemeWidgetLayout = new QGridLayout(SchemeWidget);
       
    93     SchemeWidgetLayout->setMargin(0);
       
    94 
       
    95     GameSchemes = new QComboBox(SchemeWidget);
       
    96     SchemeWidgetLayout->addWidget(GameSchemes, 0, 2);
    51     connect(GameSchemes, SIGNAL(currentIndexChanged(int)), this, SLOT(schemeChanged(int)));
    97     connect(GameSchemes, SIGNAL(currentIndexChanged(int)), this, SLOT(schemeChanged(int)));
    52 
    98 
    53     GBoxOptionsLayout->addWidget(new QLabel(QLabel::tr("Game scheme"), GBoxOptions), 0, 0);
    99     SchemeWidgetLayout->addWidget(new QLabel(QLabel::tr("Game scheme"), SchemeWidget), 0, 0);
    54 
   100 
    55     QPixmap pmEdit(":/res/edit.png");
   101     QPixmap pmEdit(":/res/edit.png");
    56     
   102     
    57     QPushButton * goToSchemePage = new QPushButton(GBoxOptions);
   103     QPushButton * goToSchemePage = new QPushButton(SchemeWidget);
    58     goToSchemePage->setToolTip(tr("Edit schemes"));
   104     goToSchemePage->setToolTip(tr("Edit schemes"));
    59     goToSchemePage->setIconSize(pmEdit.size());
   105     goToSchemePage->setIconSize(pmEdit.size());
    60     goToSchemePage->setIcon(pmEdit);
   106     goToSchemePage->setIcon(pmEdit);
    61     goToSchemePage->setMaximumWidth(pmEdit.width() + 6);
   107     goToSchemePage->setMaximumWidth(pmEdit.width() + 6);
    62     GBoxOptionsLayout->addWidget(goToSchemePage, 0, 2);
   108     SchemeWidgetLayout->addWidget(goToSchemePage, 0, 3);
    63     connect(goToSchemePage, SIGNAL(clicked()), this, SIGNAL(goToSchemes()));
   109     connect(goToSchemePage, SIGNAL(clicked()), this, SLOT(jumpToSchemes()));
    64 
   110 
    65     GBoxOptionsLayout->addWidget(new QLabel(QLabel::tr("Weapons"), GBoxOptions), 1, 0);
   111     SchemeWidgetLayout->addWidget(new QLabel(QLabel::tr("Weapons"), SchemeWidget), 1, 0);
    66 
   112 
    67     WeaponsName = new QComboBox(GBoxOptions);
   113     WeaponsName = new QComboBox(SchemeWidget);
    68     GBoxOptionsLayout->addWidget(WeaponsName, 1, 1);
   114     SchemeWidgetLayout->addWidget(WeaponsName, 1, 2);
    69 
   115 
    70     connect(WeaponsName, SIGNAL(currentIndexChanged(int)), this, SLOT(ammoChanged(int)));
   116     connect(WeaponsName, SIGNAL(currentIndexChanged(int)), this, SLOT(ammoChanged(int)));
    71 
   117 
    72     QPushButton * goToWeaponPage = new QPushButton(GBoxOptions);
   118     QPushButton * goToWeaponPage = new QPushButton(SchemeWidget);
    73     goToWeaponPage->setToolTip(tr("Edit weapons"));
   119     goToWeaponPage->setToolTip(tr("Edit weapons"));
    74     goToWeaponPage->setIconSize(pmEdit.size());
   120     goToWeaponPage->setIconSize(pmEdit.size());
    75     goToWeaponPage->setIcon(pmEdit);
   121     goToWeaponPage->setIcon(pmEdit);
    76     goToWeaponPage->setMaximumWidth(pmEdit.width() + 6);
   122     goToWeaponPage->setMaximumWidth(pmEdit.width() + 6);
    77     GBoxOptionsLayout->addWidget(goToWeaponPage, 1, 2);
   123     SchemeWidgetLayout->addWidget(goToWeaponPage, 1, 3);
    78 
       
    79     connect(goToWeaponPage, SIGNAL(clicked()), this, SLOT(jumpToWeapons()));
   124     connect(goToWeaponPage, SIGNAL(clicked()), this, SLOT(jumpToWeapons()));
    80 
   125 
    81     GBoxOptionsLayout->addWidget(new QLabel(QLabel::tr("Bind schemes and weapons"), GBoxOptions), 2, 0);
   126     //GBoxOptionsLayout->addWidget(new QLabel(QLabel::tr("Bind schemes with weapons"), GBoxOptions), 2, 0);
    82 
   127 
    83     bindEntries = new QCheckBox(GBoxOptions);
   128     bindEntries = new QCheckBox(SchemeWidget);
    84     bindEntries->setToolTip(tr("When this option is enabled selecting a game scheme will auto-select a weapon (and viceversa)"));
   129     bindEntries->setToolTip(tr("When this option is enabled selecting a game scheme will auto-select a weapon"));
    85     bindEntries->setChecked(true);
   130     bindEntries->setChecked(true);
    86     GBoxOptionsLayout->addWidget(bindEntries, 2, 2);
   131     bindEntries->setMaximumWidth(42);
       
   132     bindEntries->setStyleSheet( "QCheckBox::indicator:checked   { image: url(\":/res/lock.png\"); }"
       
   133                                 "QCheckBox::indicator:unchecked { image: url(\":/res/unlock.png\");   }" );
       
   134     SchemeWidgetLayout->addWidget(bindEntries, 0, 1, 0, 1, Qt::AlignVCenter);
       
   135     //GBoxOptionsLayout->addWidget(bindEntries, 2, 2);
    87 
   136 
    88     connect(pMapContainer, SIGNAL(seedChanged(const QString &)), this, SLOT(seedChanged(const QString &)));
   137     connect(pMapContainer, SIGNAL(seedChanged(const QString &)), this, SLOT(seedChanged(const QString &)));
    89     connect(pMapContainer, SIGNAL(mapChanged(const QString &)), this, SLOT(mapChanged(const QString &)));
   138     connect(pMapContainer, SIGNAL(mapChanged(const QString &)), this, SLOT(mapChanged(const QString &)));
    90     connect(pMapContainer, SIGNAL(mapgenChanged(MapGenerator)), this, SLOT(mapgenChanged(MapGenerator)));
   139     connect(pMapContainer, SIGNAL(mapgenChanged(MapGenerator)), this, SLOT(mapgenChanged(MapGenerator)));
    91     connect(pMapContainer, SIGNAL(maze_sizeChanged(int)), this, SLOT(maze_sizeChanged(int)));
   140     connect(pMapContainer, SIGNAL(maze_sizeChanged(int)), this, SLOT(maze_sizeChanged(int)));
    92     connect(pMapContainer, SIGNAL(themeChanged(const QString &)), this, SLOT(themeChanged(const QString &)));
   141     connect(pMapContainer, SIGNAL(themeChanged(const QString &)), this, SLOT(themeChanged(const QString &)));
    93     connect(pMapContainer, SIGNAL(newTemplateFilter(int)), this, SLOT(templateFilterChanged(int)));
   142     connect(pMapContainer, SIGNAL(newTemplateFilter(int)), this, SLOT(templateFilterChanged(int)));
       
   143     connect(pMapContainer, SIGNAL(drawMapRequested()), this, SIGNAL(goToDrawMap()));
       
   144     connect(pMapContainer, SIGNAL(drawnMapChanged(const QByteArray &)), this, SLOT(onDrawnMapChanged(const QByteArray &)));
       
   145 }
       
   146 
       
   147 void GameCFGWidget::jumpToSchemes()
       
   148 {
       
   149     emit goToSchemes(GameSchemes->currentIndex());
    94 }
   150 }
    95 
   151 
    96 void GameCFGWidget::jumpToWeapons()
   152 void GameCFGWidget::jumpToWeapons()
    97 {
   153 {
    98     emit goToWeapons(WeaponsName->currentText());
   154     emit goToWeapons(WeaponsName->currentIndex());
    99 }
   155 }
   100 
   156 
   101 QVariant GameCFGWidget::schemeData(int column) const
   157 QVariant GameCFGWidget::schemeData(int column) const
   102 {
   158 {
   103     return GameSchemes->model()->data(GameSchemes->model()->index(GameSchemes->currentIndex(), column));
   159     return GameSchemes->model()->data(GameSchemes->model()->index(GameSchemes->currentIndex(), column));
   160 quint32 GameCFGWidget::getInitHealth() const
   216 quint32 GameCFGWidget::getInitHealth() const
   161 {
   217 {
   162     return schemeData(26).toInt();
   218     return schemeData(26).toInt();
   163 }
   219 }
   164 
   220 
   165 QStringList GameCFGWidget::getFullConfig() const
   221 QByteArray GameCFGWidget::getFullConfig() const
   166 {
   222 {
   167     QStringList sl;
   223     QList<QByteArray> bcfg;
   168     sl.append("eseed " + pMapContainer->getCurrentSeed());
   224     int mapgen = pMapContainer->get_mapgen();
   169     sl.append(QString("e$gmflags %1").arg(getGameFlags()));
   225 
   170     sl.append(QString("e$damagepct %1").arg(schemeData(24).toInt()));
   226     bcfg << QString("eseed " + pMapContainer->getCurrentSeed()).toUtf8();
   171     sl.append(QString("e$turntime %1").arg(schemeData(25).toInt() * 1000));
   227     bcfg << QString("e$gmflags %1").arg(getGameFlags()).toUtf8();
   172     sl.append(QString("e$sd_turns %1").arg(schemeData(27).toInt()));
   228     bcfg << QString("e$damagepct %1").arg(schemeData(24).toInt()).toUtf8();
   173     sl.append(QString("e$casefreq %1").arg(schemeData(28).toInt()));
   229     bcfg << QString("e$turntime %1").arg(schemeData(25).toInt() * 1000).toUtf8();
   174     sl.append(QString("e$minestime %1").arg(schemeData(29).toInt()));
   230     bcfg << QString("e$sd_turns %1").arg(schemeData(27).toInt()).toUtf8();
   175     sl.append(QString("e$minesnum %1").arg(schemeData(30).toInt()));
   231     bcfg << QString("e$casefreq %1").arg(schemeData(28).toInt()).toUtf8();
   176     sl.append(QString("e$minedudpct %1").arg(schemeData(31).toInt()));
   232     bcfg << QString("e$minestime %1").arg(schemeData(29).toInt() * 1000).toUtf8();
   177     sl.append(QString("e$explosives %1").arg(schemeData(32).toInt()));
   233     bcfg << QString("e$minesnum %1").arg(schemeData(30).toInt()).toUtf8();
   178     sl.append(QString("e$healthprob %1").arg(schemeData(33).toInt()));
   234     bcfg << QString("e$minedudpct %1").arg(schemeData(31).toInt()).toUtf8();
   179     sl.append(QString("e$hcaseamount %1").arg(schemeData(34).toInt()));
   235     bcfg << QString("e$explosives %1").arg(schemeData(32).toInt()).toUtf8();
   180     sl.append(QString("e$waterrise %1").arg(schemeData(35).toInt()));
   236     bcfg << QString("e$healthprob %1").arg(schemeData(33).toInt()).toUtf8();
   181     sl.append(QString("e$healthdec %1").arg(schemeData(36).toInt()));
   237     bcfg << QString("e$hcaseamount %1").arg(schemeData(34).toInt()).toUtf8();
   182     sl.append(QString("e$template_filter %1").arg(pMapContainer->getTemplateFilter()));
   238     bcfg << QString("e$waterrise %1").arg(schemeData(35).toInt()).toUtf8();
   183     sl.append(QString("e$mapgen %1").arg(pMapContainer->get_mapgen()));
   239     bcfg << QString("e$healthdec %1").arg(schemeData(36).toInt()).toUtf8();
   184     sl.append(QString("e$maze_size %1").arg(pMapContainer->get_maze_size()));
   240     bcfg << QString("e$ropepct %1").arg(schemeData(37).toInt()).toUtf8();
       
   241     bcfg << QString("e$template_filter %1").arg(pMapContainer->getTemplateFilter()).toUtf8();
       
   242     bcfg << QString("e$mapgen %1").arg(mapgen).toUtf8();
       
   243 
       
   244     switch (mapgen)
       
   245     {
       
   246         case MAPGEN_MAZE:
       
   247             bcfg << QString("e$maze_size %1").arg(pMapContainer->get_maze_size()).toUtf8();
       
   248             break;
       
   249 
       
   250         case MAPGEN_DRAWN:
       
   251         {
       
   252             QByteArray data = pMapContainer->getDrawnMapData();
       
   253             while(data.size() > 0)
       
   254             {
       
   255                 QByteArray tmp = data;
       
   256                 tmp.truncate(200);
       
   257                 tmp.prepend("edraw ");
       
   258                 bcfg << tmp;
       
   259                 data.remove(0, 200);
       
   260             }
       
   261             break;
       
   262         }
       
   263         default: ;
       
   264     }
   185 
   265 
   186     QString currentMap = pMapContainer->getCurrentMap();
   266     QString currentMap = pMapContainer->getCurrentMap();
   187     if (currentMap.size() > 0)
   267     if (currentMap.size() > 0)
   188     {
   268     {
   189         sl.append("emap " + currentMap);
   269         bcfg << QString("emap " + currentMap).toUtf8();
   190         if(pMapContainer->getCurrentIsMission())
   270         if(pMapContainer->getCurrentIsMission())
   191             sl.append(QString("escript Maps/%1/map.lua")
   271             bcfg << QString("escript Maps/%1/map.lua").arg(currentMap).toUtf8();
   192                 .arg(currentMap));
   272     }
   193     }
   273     bcfg << QString("etheme " + pMapContainer->getCurrentTheme()).toUtf8();
   194     sl.append("etheme " + pMapContainer->getCurrentTheme());
   274 
   195     return sl;
   275     if (Scripts->currentIndex() > 0)
       
   276     {
       
   277         bcfg << QString("escript Scripts/Multiplayer/%1.lua").arg(Scripts->itemData(Scripts->currentIndex()).toList()[0].toString()).toUtf8();
       
   278     }
       
   279 
       
   280     QByteArray result;
       
   281 
       
   282     foreach(QByteArray ba, bcfg)
       
   283         HWProto::addByteArrayToBuffer(result, ba);
       
   284 
       
   285     return result;
   196 }
   286 }
   197 
   287 
   198 void GameCFGWidget::setNetAmmo(const QString& name, const QString& ammo)
   288 void GameCFGWidget::setNetAmmo(const QString& name, const QString& ammo)
   199 {
   289 {
   200     bool illegal = ammo.size() != cDefaultAmmoStore->size();
   290     bool illegal = ammo.size() != cDefaultAmmoStore->size();
   218     seedChanged(pMapContainer->getCurrentSeed());
   308     seedChanged(pMapContainer->getCurrentSeed());
   219     templateFilterChanged(pMapContainer->getTemplateFilter());
   309     templateFilterChanged(pMapContainer->getTemplateFilter());
   220     themeChanged(pMapContainer->getCurrentTheme());
   310     themeChanged(pMapContainer->getCurrentTheme());
   221 
   311 
   222     schemeChanged(GameSchemes->currentIndex());
   312     schemeChanged(GameSchemes->currentIndex());
       
   313     scriptChanged(Scripts->currentIndex());
   223 
   314 
   224     mapgenChanged(pMapContainer->get_mapgen());
   315     mapgenChanged(pMapContainer->get_mapgen());
   225     maze_sizeChanged(pMapContainer->get_maze_size());
   316     maze_sizeChanged(pMapContainer->get_maze_size());
   226 
   317 
   227     // map must be the last
   318     // map must be the last
   239             pMapContainer->setMap(value);
   330             pMapContainer->setMap(value);
   240             return;
   331             return;
   241         }
   332         }
   242         if (param == "SEED") {
   333         if (param == "SEED") {
   243             pMapContainer->setSeed(value);
   334             pMapContainer->setSeed(value);
       
   335             if (!QRegExp("\\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\}").exactMatch(value)) {
       
   336                 pMapContainer->seedEdit->setVisible(true);
       
   337                 }
   244             return;
   338             return;
   245         }
   339         }
   246         if (param == "THEME") {
   340         if (param == "THEME") {
   247             pMapContainer->setTheme(value);
   341             pMapContainer->setTheme(value);
   248             return;
   342             return;
   255             pMapContainer->setMapgen((MapGenerator)value.toUInt());
   349             pMapContainer->setMapgen((MapGenerator)value.toUInt());
   256             return;
   350             return;
   257         }
   351         }
   258         if (param == "MAZE_SIZE") {
   352         if (param == "MAZE_SIZE") {
   259             pMapContainer->setMaze_size(value.toUInt());
   353             pMapContainer->setMaze_size(value.toUInt());
       
   354             return;
       
   355         }
       
   356         if (param == "SCRIPT") {
       
   357             Scripts->setCurrentIndex(Scripts->findText(value));
       
   358             return;
       
   359         }
       
   360         if (param == "DRAWNMAP") {
       
   361             pMapContainer->setDrawnMapData(qUncompress(QByteArray::fromBase64(slValue[0].toLatin1())));
   260             return;
   362             return;
   261         }
   363         }
   262     }
   364     }
   263 
   365 
   264     if (slValue.size() == 2)
   366     if (slValue.size() == 2)
   277     if (index >= 0) {
   379     if (index >= 0) {
   278         emit paramChanged(
   380         emit paramChanged(
   279             "AMMO",
   381             "AMMO",
   280             QStringList() << WeaponsName->itemText(index) << WeaponsName->itemData(index).toString()
   382             QStringList() << WeaponsName->itemText(index) << WeaponsName->itemData(index).toString()
   281         );
   383         );
   282         if (bindEntries->isChecked() == true) {
       
   283             QString weapName = WeaponsName->itemText(index);
       
   284             for (int i = 0; i < GameSchemes->count(); i++) {
       
   285                  QString schemeName = GameSchemes->itemText(i);
       
   286                  int res = QString::compare(weapName, schemeName, Qt::CaseSensitive);
       
   287                  if (0 == res) {
       
   288                      GameSchemes->setCurrentIndex(i);
       
   289                      break;
       
   290                  }
       
   291             }
       
   292         }
       
   293     }
   384     }
   294 }
   385 }
   295 
   386 
   296 void GameCFGWidget::mapChanged(const QString & value)
   387 void GameCFGWidget::mapChanged(const QString & value)
   297 {
   388 {
   298     if(pMapContainer->getCurrentIsMission())
   389     if(isEnabled() && pMapContainer->getCurrentIsMission())
   299     {
   390     {
   300         GameSchemes->setEnabled(false);
   391         Scripts->setEnabled(false);
   301         WeaponsName->setEnabled(false);
   392         Scripts->setCurrentIndex(0);
   302         bindEntries->setEnabled(false);
   393 
   303         GameSchemes->setCurrentIndex(GameSchemes->findText("Default"));
   394         if (pMapContainer->getCurrentScheme() == "locked")
   304         WeaponsName->setCurrentIndex(WeaponsName->findText("Default"));
   395         {
       
   396             GameSchemes->setEnabled(false);
       
   397             GameSchemes->setCurrentIndex(GameSchemes->findText("Default"));
       
   398         }
       
   399         else
       
   400         {
       
   401             GameSchemes->setEnabled(true);
       
   402             int num = GameSchemes->findText(pMapContainer->getCurrentScheme());
       
   403             if (num != -1)
       
   404                 GameSchemes->setCurrentIndex(num);
       
   405             else
       
   406                 GameSchemes->setCurrentIndex(GameSchemes->findText("Default"));
       
   407         }
       
   408 
       
   409         if (pMapContainer->getCurrentWeapons() == "locked")
       
   410         {
       
   411             WeaponsName->setEnabled(false);
       
   412             WeaponsName->setCurrentIndex(WeaponsName->findText("Default"));
       
   413         }
       
   414         else
       
   415         {
       
   416             WeaponsName->setEnabled(true);
       
   417             int num = WeaponsName->findText(pMapContainer->getCurrentWeapons());
       
   418             if (num != -1)
       
   419                 WeaponsName->setCurrentIndex(num);
       
   420             else
       
   421                 WeaponsName->setCurrentIndex(WeaponsName->findText("Default"));
       
   422         }
       
   423 
       
   424         if (pMapContainer->getCurrentScheme() != "locked" && pMapContainer->getCurrentWeapons() != "locked")
       
   425             bindEntries->setEnabled(true);
       
   426         else
       
   427             bindEntries->setEnabled(false);
   305     }
   428     }
   306     else
   429     else
   307     {
   430     {
       
   431         Scripts->setEnabled(true);
   308         GameSchemes->setEnabled(true);
   432         GameSchemes->setEnabled(true);
   309         WeaponsName->setEnabled(true);
   433         WeaponsName->setEnabled(true);
   310         bindEntries->setEnabled(true);
   434         bindEntries->setEnabled(true);
   311     }
   435     }
   312     emit paramChanged("MAP", QStringList(value));
   436     emit paramChanged("MAP", QStringList(value));
   335     for(int i = 0; i < size; ++i)
   459     for(int i = 0; i < size; ++i)
   336         sl << schemeData(i).toString();
   460         sl << schemeData(i).toString();
   337 
   461 
   338     emit paramChanged("SCHEME", sl);
   462     emit paramChanged("SCHEME", sl);
   339 
   463 
   340     if (bindEntries->isChecked() == true) {
   464     if (isEnabled() && bindEntries->isEnabled() && bindEntries->isChecked()) {
   341         QString schemeName = GameSchemes->itemText(index);
   465         QString schemeName = GameSchemes->itemText(index);
   342         for (int i = 0; i < WeaponsName->count(); i++) {
   466         for (int i = 0; i < WeaponsName->count(); i++) {
   343              QString weapName = WeaponsName->itemText(i);
   467              QString weapName = WeaponsName->itemText(i);
   344              int res = QString::compare(weapName, schemeName, Qt::CaseSensitive);
   468              int res = QString::compare(weapName, schemeName, Qt::CaseSensitive);
   345              if (0 == res) {
   469              if (0 == res) {
   346                  WeaponsName->setCurrentIndex(i);
   470                  WeaponsName->setCurrentIndex(i);
       
   471                  emit ammoChanged(i);
   347                  break;
   472                  break;
   348              }
   473              }
   349         }
   474         }
   350     }
   475     }
   351 }
   476 }
   352 
   477 
       
   478 void GameCFGWidget::scriptChanged(int index)
       
   479 {
       
   480     if(isEnabled() && index > 0)
       
   481     {
       
   482         QString scheme = Scripts->itemData(Scripts->currentIndex()).toList()[1].toString();
       
   483         QString weapons = Scripts->itemData(Scripts->currentIndex()).toList()[2].toString();
       
   484 
       
   485         if (scheme == "locked")
       
   486         {
       
   487             GameSchemes->setEnabled(false);
       
   488             GameSchemes->setCurrentIndex(GameSchemes->findText("Default"));
       
   489         }
       
   490         else
       
   491         {
       
   492             GameSchemes->setEnabled(true);
       
   493             int num = GameSchemes->findText(scheme);
       
   494             if (num != -1)
       
   495                 GameSchemes->setCurrentIndex(num);
       
   496             else
       
   497                 GameSchemes->setCurrentIndex(GameSchemes->findText("Default"));
       
   498         }
       
   499 
       
   500         if (weapons == "locked")
       
   501         {
       
   502             WeaponsName->setEnabled(false);
       
   503             WeaponsName->setCurrentIndex(WeaponsName->findText("Default"));
       
   504         }
       
   505         else
       
   506         {
       
   507             WeaponsName->setEnabled(true);
       
   508             int num = WeaponsName->findText(weapons);
       
   509             if (num != -1)
       
   510                 WeaponsName->setCurrentIndex(num);
       
   511             else
       
   512                 WeaponsName->setCurrentIndex(WeaponsName->findText("Default"));
       
   513         }
       
   514 
       
   515         if (scheme != "locked" && weapons != "locked")
       
   516             bindEntries->setEnabled(true);
       
   517         else
       
   518             bindEntries->setEnabled(false);
       
   519     }
       
   520     else
       
   521     {
       
   522         GameSchemes->setEnabled(true);
       
   523         WeaponsName->setEnabled(true);
       
   524         bindEntries->setEnabled(true);
       
   525     }
       
   526     emit paramChanged("SCRIPT", QStringList(Scripts->itemText(index)));
       
   527 }
       
   528 
   353 void GameCFGWidget::mapgenChanged(MapGenerator m)
   529 void GameCFGWidget::mapgenChanged(MapGenerator m)
   354 {
   530 {
   355     emit paramChanged("MAPGEN", QStringList(QString::number(m)));
   531     emit paramChanged("MAPGEN", QStringList(QString::number(m)));
   356 }
   532 }
   357 
   533 
   362 
   538 
   363 void GameCFGWidget::resendSchemeData()
   539 void GameCFGWidget::resendSchemeData()
   364 {
   540 {
   365     schemeChanged(GameSchemes->currentIndex());
   541     schemeChanged(GameSchemes->currentIndex());
   366 }
   542 }
       
   543 
       
   544 void GameCFGWidget::onDrawnMapChanged(const QByteArray & data)
       
   545 {
       
   546     emit paramChanged("DRAWNMAP", QStringList(qCompress(data, 9).toBase64()));
       
   547 }