Reworked campaign selection wizard. Added two small scale camapaigns on PG map

qt_ui/windows/QLiberationWindow.py

@@ -12,10 +12,9 @@ from game import Game
 from qt_ui.uiconstants import URLS
 from qt_ui.widgets.QTopPanel import QTopPanel
 from qt_ui.widgets.map.QLiberationMap import QLiberationMap
-from qt_ui.windows.preferences import QLiberationPreferences
 from qt_ui.windows.GameUpdateSignal import GameUpdateSignal, DebriefingSignal
 from qt_ui.windows.QDebriefingWindow import QDebriefingWindow
-from qt_ui.windows.QNewGameWizard import NewGameWizard
+from qt_ui.windows.newgame.QNewGameWizard import NewGameWizard
 from qt_ui.windows.infos.QInfoPanel import QInfoPanel
 from qt_ui.windows.preferences.QLiberationPreferencesWindow import QLiberationPreferencesWindow
 from userdata import persistency

qt_ui/windows/newgame/QCampaignList.py

@@ -0,0 +1,72 @@
+from PySide2 import QtGui
+from PySide2.QtCore import QSize, QItemSelectionModel
+from PySide2.QtGui import QStandardItemModel, QStandardItem
+from PySide2.QtWidgets import QListView, QAbstractItemView
+
+from theater import caucasus, nevada, persiangulf, normandy, thechannel
+import qt_ui.uiconstants as CONST
+
+CAMPAIGNS = [
+    ("Caucasus - Western Georgia", caucasus.WesternGeorgia, "Terrain_Caucasus"),
+    ("Caucasus - Russia Small", caucasus.RussiaSmall, "Terrain_Caucasus"),
+    ("Caucasus - North Caucasus", caucasus.NorthCaucasus, "Terrain_Caucasus"),
+    ("Caucasus - Full Map", caucasus.CaucasusTheater, "Terrain_Caucasus"),
+    ("Nevada - North Nevada", nevada.NevadaTheater, "Terrain_Nevada"),
+    ("Persian Gulf - Invasion of Iran", persiangulf.IranianCampaign, "Terrain_Persian_Gulf"),
+    ("Persian Gulf - Invasion of Iran [Lite]", persiangulf.IranInvasionLite, "Terrain_Persian_Gulf"),
+    ("Persian Gulf - Emirates", persiangulf.Emirates, "Terrain_Persian_Gulf"),
+    ("Persian Gulf - Desert War", persiangulf.DesertWar, "Terrain_Persian_Gulf"),
+    ("Persian Gulf - Full Map", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+
+    ("Syria - Golan heights battle", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+    ("Syria - Invasion from Turkey", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+    ("Syria - Syrian Civil War", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+    ("Syria - War on Insurgents", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+    ("Syria - Full Map", persiangulf.PersianGulfTheater, "Terrain_Persian_Gulf"),
+
+    ("Normandy - Normandy", normandy.NormandyTheater, "Terrain_Normandy"),
+    ("Normandy - Normandy Small", normandy.NormandySmall, "Terrain_Normandy"),
+    ("The Channel - Battle of Britain", thechannel.BattleOfBritain, "Terrain_Channel"),
+    ("The Channel - Dunkirk", thechannel.Dunkirk, "Terrain_Channel"),
+]
+
+
+class QCampaignItem(QStandardItem):
+
+    def __init__(self, text, theater, icon):
+        super(QCampaignItem, self).__init__()
+        self.theater = theater
+        self.setIcon(QtGui.QIcon(CONST.ICONS[icon]))
+        self.setEditable(False)
+        self.setText(text)
+
+class QCampaignList(QListView):
+
+    def __init__(self):
+        super(QCampaignList, self).__init__()
+        self.model = QStandardItemModel(self)
+        self.setModel(self.model)
+        self.setMinimumWidth(250)
+        self.setMinimumHeight(350)
+        self.campaigns = []
+        self.setSelectionBehavior(QAbstractItemView.SelectItems)
+        self.setup_content()
+
+    def setup_content(self):
+        for i, campaign in enumerate(CAMPAIGNS):
+            self.campaigns.append(campaign)
+            item = QCampaignItem(*campaign)
+            self.model.appendRow(item)
+        self.setSelectedCampaign(0)
+        self.repaint()
+
+    def setSelectedCampaign(self, row):
+        self.selectionModel().clearSelection()
+        index = self.model.index(row, 0)
+        if not index.isValid():
+            index = self.model.index(0, 0)
+        self.selectionModel().setCurrentIndex(index, QItemSelectionModel.Select)
+        self.repaint()
+
+    def clear_layout(self):
+        self.model.removeRows(0, self.model.rowCount())

qt_ui/windows/newgame/QNewGameWizard.py

@@ -1,8 +1,10 @@
 from __future__ import unicode_literals
 
 import datetime
+import logging
 
 from PySide2 import QtGui, QtWidgets
+from PySide2.QtCore import QPoint, QItemSelectionModel
 from PySide2.QtWidgets import QHBoxLayout, QVBoxLayout
 from dcs.task import CAP, CAS
 
@@ -10,6 +12,7 @@ import qt_ui.uiconstants as CONST
 from game import db, Game
 from game.settings import Settings
 from gen import namegen
+from qt_ui.windows.newgame.QCampaignList import QCampaignList
 from theater import start_generator, persiangulf, nevada, caucasus, ConflictTheater, normandy, thechannel
 
 
@@ -32,19 +35,15 @@ class NewGameWizard(QtWidgets.QWizard):
 
     def accept(self):
 
+        logging.info("New Game Wizard accept")
+        logging.info("======================")
+
         blueFaction = [c for c in db.FACTIONS][self.field("blueFaction")]
         redFaction = [c for c in db.FACTIONS][self.field("redFaction")]
-        isTerrainPg = self.field("isTerrainPg")
+
-        isTerrainNttr = self.field("isTerrainNttr")
+        selectedCampaign = self.field("selectedCampaign")
-        isTerrainCaucasusSmall = self.field("isTerrainCaucasusSmall")
+        conflictTheater = selectedCampaign[1]()
-        isTerrainRussia = self.field("isTerrainRussia")
+
-        isTerrainCaucasusNorth= self.field("isTerrainCaucasusNorth")
-        isIranianCampaignTheater = self.field("isIranianCampaignTheater")
-        isTerrainNormandy = self.field("isTerrainNormandy")
-        isTerrainNormandySmall = self.field("isTerrainNormandySmall")
-        isTerrainChannel = self.field("isTerrainChannel")
-        isTerrainChannelComplete = self.field("isTerrainChannelComplete")
-        isTerrainEmirates = self.field("isTerrainEmirates")
         timePeriod = db.TIME_PERIODS[list(db.TIME_PERIODS.keys())[self.field("timePeriod")]]
         midGame = self.field("midGame")
         multiplier = self.field("multiplier")
@@ -58,31 +57,6 @@ class NewGameWizard(QtWidgets.QWizard):
         player_name = blueFaction
         enemy_name = redFaction
 
-        if isTerrainPg:
-            conflicttheater = persiangulf.PersianGulfTheater()
-        elif isTerrainNttr:
-            conflicttheater = nevada.NevadaTheater()
-        elif isTerrainCaucasusSmall:
-            conflicttheater = caucasus.WesternGeorgia()
-        elif isTerrainRussia:
-            conflicttheater = caucasus.RussiaSmall()
-        elif isTerrainCaucasusNorth:
-            conflicttheater = caucasus.NorthCaucasus()
-        elif isIranianCampaignTheater:
-            conflicttheater = persiangulf.IranianCampaign()
-        elif isTerrainEmirates:
-            conflicttheater = persiangulf.Emirates()
-        elif isTerrainNormandy:
-            conflicttheater = normandy.NormandyTheater()
-        elif isTerrainNormandySmall:
-            conflicttheater = normandy.NormandySmall()
-        elif isTerrainChannel:
-            conflicttheater = thechannel.ChannelTheater()
-        elif isTerrainChannelComplete:
-            conflicttheater = thechannel.ChannelTheaterComplete()
-        else:
-            conflicttheater = caucasus.CaucasusTheater()
-
         settings = Settings()
         settings.inverted = invertMap
         settings.supercarrier = supercarrier
@@ -91,40 +65,40 @@ class NewGameWizard(QtWidgets.QWizard):
         settings.do_not_generate_player_navy = no_player_navy
         settings.do_not_generate_enemy_navy = no_enemy_navy
 
-        self.generatedGame = self.start_new_game(player_name, enemy_name, conflicttheater, midGame, multiplier,
+        self.generatedGame = self.start_new_game(player_name, enemy_name, conflictTheater, midGame, multiplier,
                                                  timePeriod, settings)
 
         super(NewGameWizard, self).accept()
 
-    def start_new_game(self, player_name: str, enemy_name: str, conflicttheater: ConflictTheater,
+    def start_new_game(self, player_name: str, enemy_name: str, conflictTheater: ConflictTheater,
                        midgame: bool, multiplier: float, period: datetime, settings:Settings):
 
         # Reset name generator
         namegen.reset()
-        start_generator.prepare_theater(conflicttheater, settings, midgame)
+        start_generator.prepare_theater(conflictTheater, settings, midgame)
 
         print("-- Starting New Game Generator")
         print("Enemy name : " + enemy_name)
         print("Player name : " + player_name)
         print("Midgame : " + str(midgame))
-        start_generator.generate_inital_units(conflicttheater, enemy_name, True, multiplier)
+        start_generator.generate_inital_units(conflictTheater, enemy_name, True, multiplier)
 
         print("-- Initial units generated")
         game = Game(player_name=player_name,
                     enemy_name=enemy_name,
-                    theater=conflicttheater,
+                    theater=conflictTheater,
                     start_date=period,
                     settings=settings)
 
         print("-- Game Object generated")
-        start_generator.generate_groundobjects(conflicttheater, game)
+        start_generator.generate_groundobjects(conflictTheater, game)
         game.budget = int(game.budget * multiplier)
         game.settings.multiplier = multiplier
         game.settings.sams = True
         game.settings.version = "2.0.10"
 
         if midgame:
-            game.budget = game.budget * 4 * len(list(conflicttheater.conflicts()))
+            game.budget = game.budget * 4 * len(list(conflictTheater.conflicts()))
 
         return game
 
@@ -295,6 +269,21 @@ class TheaterConfiguration(QtWidgets.QWizardPage):
         terrainChannelComplete.setIcon(QtGui.QIcon(CONST.ICONS["Terrain_Channel"]))
         terrainCaucasusSmall.setChecked(True)
 
+        # List of campaigns
+        campaignList = QCampaignList()
+        self.registerField("selectedCampaign", campaignList)
+
+        def on_campaign_selected():
+            index = campaignList.selectionModel().currentIndex().row()
+            campaign = campaignList.campaigns[index]
+            self.setField("selectedCampaign", campaign)
+
+        campaignList.selectionModel().setCurrentIndex(campaignList.indexAt(QPoint(1, 1)), QItemSelectionModel.Rows)
+        campaignList.selectionModel().selectionChanged.connect(on_campaign_selected)
+        on_campaign_selected()
+
+
+
         # Campaign settings
         mapSettingsGroup = QtWidgets.QGroupBox("Map Settings")
         invertMap = QtWidgets.QCheckBox()
@@ -314,35 +303,8 @@ class TheaterConfiguration(QtWidgets.QWizardPage):
         timePeriodSelect.setCurrentIndex(21)
 
         # Register fields
-        self.registerField('isTerrainCaucasus', terrainCaucasus)
-        self.registerField('isTerrainCaucasusSmall', terrainCaucasusSmall)
-        self.registerField('isTerrainRussia', terrainRussia)
-        self.registerField('isTerrainCaucasusNorth', terrainCaucasusNorth)
-        self.registerField('isTerrainPg', terrainPg)
-        self.registerField('isIranianCampaignTheater', terrainIran)
-        self.registerField('isTerrainEmirates', terrainEmirates)
-        self.registerField('isTerrainNttr', terrainNttr)
-        self.registerField('isTerrainNormandy', terrainNormandy)
-        self.registerField('isTerrainNormandySmall', terrainNormandySmall)
-        self.registerField('isTerrainChannel', terrainChannel)
-        self.registerField('isTerrainChannelComplete', terrainChannelComplete)
         self.registerField('timePeriod', timePeriodSelect)
-
+        self.registerField('timePeriod', timePeriodSelect)
-        # Build layout
-        terrainGroupLayout = QtWidgets.QVBoxLayout()
-        terrainGroupLayout.addWidget(terrainCaucasusSmall)
-        terrainGroupLayout.addWidget(terrainRussia)
-        terrainGroupLayout.addWidget(terrainCaucasusNorth)
-        terrainGroupLayout.addWidget(terrainCaucasus)
-        terrainGroupLayout.addWidget(terrainIran)
-        terrainGroupLayout.addWidget(terrainEmirates)
-        terrainGroupLayout.addWidget(terrainPg)
-        terrainGroupLayout.addWidget(terrainNttr)
-        terrainGroupLayout.addWidget(terrainNormandy)
-        terrainGroupLayout.addWidget(terrainNormandySmall)
-        terrainGroupLayout.addWidget(terrainChannelComplete)
-        terrainGroupLayout.addWidget(terrainChannel)
-        terrainGroup.setLayout(terrainGroupLayout)
 
         timeGroupLayout = QtWidgets.QGridLayout()
         timeGroupLayout.addWidget(timePeriod, 0, 0)
@@ -351,7 +313,7 @@ class TheaterConfiguration(QtWidgets.QWizardPage):
 
         layout = QtWidgets.QGridLayout()
         layout.setColumnMinimumWidth(0, 20)
-        layout.addWidget(terrainGroup, 0, 0, 3, 1)
+        layout.addWidget(campaignList, 0, 0, 3, 1)
         layout.addWidget(mapSettingsGroup, 0, 1, 1, 1)
         layout.addWidget(timeGroup, 1, 1, 1, 1)
         self.setLayout(layout)

theater/persiangulf.py

@@ -209,3 +209,90 @@ class Emirates(ConflictTheater):
         self.tarawa_carrier.captured_invert = True
         self.east_carrier.captured_invert = True
         self.fujairah.captured_invert = True
+
+
+class DesertWar(ConflictTheater):
+    terrain = dcs.terrain.PersianGulf()
+    overview_image = "persiangulf.gif"
+    reference_points = {
+        (persiangulf.Shiraz_International_Airport.position.x, persiangulf.Shiraz_International_Airport.position.y): (
+        772, -1970),
+        (persiangulf.Liwa_Airbase.position.x, persiangulf.Liwa_Airbase.position.y): (1188, 78), }
+    landmap = load_landmap("resources\\gulflandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (8, 16),
+        "dusk": (16, 18),
+        "night": (0, 5),
+    }
+
+
+    def __init__(self):
+        super(DesertWar, self).__init__()
+
+        self.liwa = ControlPoint.from_airport(persiangulf.Liwa_Airbase, LAND, SIZE_BIG, IMPORTANCE_MEDIUM)
+        self.al_maktoum = ControlPoint.from_airport(persiangulf.Al_Maktoum_Intl, LAND, SIZE_BIG, IMPORTANCE_LOW)
+        self.al_minhad = ControlPoint.from_airport(persiangulf.Al_Minhad_AB, LAND, SIZE_REGULAR, IMPORTANCE_LOW)
+        self.al_ain = ControlPoint.from_airport(persiangulf.Al_Ain_International_Airport, LAND, SIZE_BIG,IMPORTANCE_LOW)
+
+        self.carrier = ControlPoint.carrier("Carrier", Point(-124000, -303000), 1001)
+        self.tarawa_carrier = ControlPoint.lha("LHA Carrier", Point(-164000, -257000), 1002)
+
+        self.add_controlpoint(self.liwa, connected_to=[self.al_ain])
+        self.add_controlpoint(self.al_ain, connected_to=[self.al_maktoum, self.liwa])
+        self.add_controlpoint(self.al_maktoum, connected_to=[self.al_minhad, self.al_ain])
+        self.add_controlpoint(self.al_minhad, connected_to=[self.al_maktoum])
+
+        self.add_controlpoint(self.tarawa_carrier)
+        self.add_controlpoint(self.carrier)
+
+        self.tarawa_carrier.captured = True
+        self.carrier.captured = True
+        self.liwa.captured = True
+
+        self.tarawa_carrier.captured_invert = True
+        self.carrier.captured_invert = True
+        self.al_ain.captured_invert = True
+
+
+class IranInvasionLite(ConflictTheater):
+    terrain = dcs.terrain.PersianGulf()
+    overview_image = "persiangulf.gif"
+    reference_points = {
+        (persiangulf.Shiraz_International_Airport.position.x, persiangulf.Shiraz_International_Airport.position.y): (
+        772, -1970),
+        (persiangulf.Liwa_Airbase.position.x, persiangulf.Liwa_Airbase.position.y): (1188, 78), }
+    landmap = load_landmap("resources\\gulflandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (8, 16),
+        "dusk": (16, 18),
+        "night": (0, 5),
+    }
+
+    def __init__(self):
+        super(IranInvasionLite, self).__init__()
+
+        self.bandar_lengeh = ControlPoint.from_airport(persiangulf.Bandar_Lengeh, [270, 315, 0, 45], SIZE_SMALL, IMPORTANCE_HIGH)
+        self.lar = ControlPoint.from_airport(persiangulf.Lar_Airbase, LAND, SIZE_REGULAR, IMPORTANCE_HIGH)
+        self.shiraz = ControlPoint.from_airport(persiangulf.Shiraz_International_Airport, LAND, SIZE_BIG, IMPORTANCE_HIGH)
+        self.kerman = ControlPoint.from_airport(persiangulf.Kerman_Airport, LAND, SIZE_BIG, IMPORTANCE_HIGH)
+        self.jiroft = ControlPoint.from_airport(persiangulf.Jiroft_Airport, LAND, SIZE_BIG, IMPORTANCE_HIGH)
+        self.carrier = ControlPoint.carrier("Carrier", Point(72000.324335475, -376000), 1001)
+        self.lha = ControlPoint.lha("LHA", Point(-27500.813952358, -147000.65947136), 1002)
+
+        self.add_controlpoint(self.bandar_lengeh, connected_to=[self.lar])
+        self.add_controlpoint(self.shiraz, connected_to=[self.lar, self.kerman])
+        self.add_controlpoint(self.jiroft, connected_to=[self.kerman])
+        self.add_controlpoint(self.kerman, connected_to=[self.shiraz, self.jiroft])
+        self.add_controlpoint(self.lar, connected_to=[self.bandar_lengeh, self.shiraz])
+
+        self.add_controlpoint(self.carrier)
+        self.add_controlpoint(self.lha)
+
+        self.carrier.captured = True
+        self.lha.captured = True
+
+        self.shiraz.captured_invert = True
+        self.bandar_lengeh.captured = True
+

theater/thechannel.py

@@ -4,7 +4,7 @@ from .conflicttheater import *
 from .landmap import *
 
 
-class ChannelTheater(ConflictTheater):
+class Dunkirk(ConflictTheater):
     terrain = dcs.terrain.TheChannel()
     overview_image = "thechannel.gif"
     reference_points = {(thechannel.Abbeville_Drucat.position.x, thechannel.Abbeville_Drucat.position.y): (2400, 4100),
@@ -18,7 +18,7 @@ class ChannelTheater(ConflictTheater):
     }
 
     def __init__(self):
-        super(ChannelTheater, self).__init__()
+        super(Dunkirk, self).__init__()
 
         self.abeville = ControlPoint.from_airport(thechannel.Abbeville_Drucat, LAND, SIZE_SMALL, IMPORTANCE_LOW)
         #self.detling = ControlPoint.from_airport(thechannel.Detling, LAND, SIZE_SMALL, IMPORTANCE_LOW)
@@ -57,7 +57,7 @@ class ChannelTheater(ConflictTheater):
         self.abeville.captured_invert = True
 
 
-class ChannelTheaterComplete(ConflictTheater):
+class BattleOfBritain(ConflictTheater):
     terrain = dcs.terrain.TheChannel()
     overview_image = "thechannel.gif"
     reference_points = {(thechannel.Abbeville_Drucat.position.x, thechannel.Abbeville_Drucat.position.y): (2400, 4100),
@@ -71,7 +71,7 @@ class ChannelTheaterComplete(ConflictTheater):
     }
 
     def __init__(self):
-        super(ChannelTheaterComplete, self).__init__()
+        super(BattleOfBritain, self).__init__()
 
         self.abeville = ControlPoint.from_airport(thechannel.Abbeville_Drucat, LAND, SIZE_SMALL, IMPORTANCE_LOW)
         #self.detling = ControlPoint.from_airport(thechannel.Detling, LAND, SIZE_SMALL, IMPORTANCE_LOW)