- added the manage exclusive encounters tab to start to build those out

DBEditor/db_controller.py

@@ -24,6 +24,14 @@ class DBController:
         event_system.add_listener('refresh_in_memory_db', self.refresh_in_memory_db)
         event_system.add_listener('clear_encounters_for_pokemon', self.clear_encounters_for_pokemon)
         event_system.add_listener('get_game_id_for_name', self.get_game_id_for_name)
+        event_system.add_listener('get_exclusive_encounter_sets', self.get_exclusive_encounter_sets)
+        event_system.add_listener('get_exclusive_set_details', self.get_exclusive_set_details)
+        event_system.add_listener('get_set_encounters', self.get_set_encounters)
+        event_system.add_listener('delete_encounter_from_set', self.delete_encounter_from_set)
+        event_system.add_listener('get_available_encounters', self.get_available_encounters)
+        event_system.add_listener('add_encounter_to_set', self.add_encounter_to_set)
+        event_system.add_listener('get_games_list', self.get_games_list)
+        event_system.add_listener('add_new_exclusive_set', self.add_new_exclusive_set)
 
     def init_database(self):
         disk_conn = sqlite3.connect('pokemon_forms.db')
@@ -35,6 +43,7 @@ class DBController:
         self.create_pokemon_storage_table(disk_cursor)
         self.create_evolution_chains_table(disk_cursor)
         self.create_exclusive_encounter_groups_table(disk_cursor)
+        self.create_encounter_exclusive_group_table(disk_cursor)
         self.create_encounters_table(disk_cursor)
         self.create_mark_table(disk_cursor)
 
@@ -380,3 +389,50 @@ class DBController:
     def clear_encounters_for_pokemon(self, pfic):
         self.cursor.execute('DELETE FROM encounters WHERE pfic = ?', (pfic,))
         self.conn.commit()
+
+    def get_games_list(self, data):
+        self.cursor.execute('SELECT id, name FROM games')
+        return self.cursor.fetchall()
+    
+    def get_exclusive_encounter_sets(self, data):
+        self.cursor.execute('SELECT id, group_name FROM exclusive_encounter_groups')
+        return self.cursor.fetchall()   
+    
+    def get_exclusive_set_details(self, set_id):
+        self.cursor.execute('SELECT group_name, description, game_id FROM exclusive_encounter_groups WHERE id = ?', (set_id,))
+        return self.cursor.fetchone()   
+    
+    def get_set_encounters(self, set_id):
+        self.cursor.execute('''
+            SELECT e.id, e.pfic, e.location, pf.name, pf.form_name
+            FROM encounters e
+            JOIN encounter_exclusive_groups eeg ON e.id = eeg.encounter_id
+            JOIN pokemon_forms pf ON e.pfic = pf.PFIC
+            WHERE eeg.group_id = ?
+        ''', (set_id,))
+        return self.cursor.fetchall()
+    
+    def delete_encounter_from_set(self, set_id, encounter_id):
+        self.cursor.execute('DELETE FROM encounter_exclusive_groups WHERE group_id = ? AND encounter_id = ?', (set_id, encounter_id))
+        self.conn.commit()
+
+    def add_encounter_to_set(self, data):
+        set_id, encounter_id = data
+        self.cursor.execute('INSERT INTO encounter_exclusive_groups (group_id, encounter_id) VALUES (?, ?)', (set_id, encounter_id))
+        self.conn.commit()
+
+    def add_new_exclusive_set(self, data):
+        set_name, description, game_id = data
+        self.cursor.execute('INSERT INTO exclusive_encounter_groups (group_name, description, game_id) VALUES (?, ?, ?)', (set_name, description, game_id))
+        self.conn.commit()  
+
+    def get_available_encounters(self, data):
+        game_id = data
+        self.cursor.execute('''
+            SELECT e.id, e.pfic, e.location, pf.name, pf.form_name
+            FROM encounters e
+            JOIN games g ON e.game_id = g.id
+            JOIN pokemon_forms pf ON e.pfic = pf.PFIC
+            WHERE g.id = ?
+        ''', (game_id,))
+        return self.cursor.fetchall()

DBEditor/pokemon_db_ui.py

@@ -60,6 +60,83 @@ class EvolutionEditDialog(QDialog):
     def delete_evolution(self):
         self.done(2)  # Use a custom return code for delete action
 
+class AddEncounterToSetDialog(QDialog):
+    def __init__(self, parent, set_id, game_id):
+        super().__init__(parent)
+        self.set_id = set_id
+        self.game_id = game_id
+        self.setWindowTitle("Add Encounter to Set")
+        layout = QVBoxLayout(self)
+
+        self.encounter_list = QListWidget()
+        layout.addWidget(QLabel("Available Encounters:"))
+        layout.addWidget(self.encounter_list)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+        self.load_available_encounters()
+
+    def load_available_encounters(self):
+        encounters = event_system.call_sync('get_available_encounters', (self.game_id))
+        for encounter in encounters:
+            encounter_id = encounter[0]
+            pfic = encounter[1] 
+            location = encounter[2]
+            name = encounter[3]
+            form = encounter[4]
+
+            display_text = f"{name} ({form if form else 'Normal'}) - {location}"
+            item = QListWidgetItem(display_text)
+            item.setData(Qt.ItemDataRole.UserRole, (encounter_id))
+            self.encounter_list.addItem(item)
+
+    def accept(self):
+        selected_items = self.encounter_list.selectedItems()
+        if selected_items:
+            for item in selected_items:
+                encounter_id = item.data(Qt.ItemDataRole.UserRole)
+                event_system.emit_sync('add_encounter_to_set', (self.set_id, encounter_id))
+        super().accept()
+
+class NewExclusiveSetDialog(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.setWindowTitle("Add New Exclusive Encounter Set")
+        layout = QFormLayout(self)
+
+        self.name_edit = QLineEdit()
+        self.description_edit = QTextEdit()
+        self.game_combo = QComboBox()
+
+        layout.addRow("Name:", self.name_edit)
+        layout.addRow("Description:", self.description_edit)
+        layout.addRow("Game:", self.game_combo)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addRow(buttons)
+
+        self.load_games()
+
+    def load_games(self):
+        games = event_system.call_sync('get_games_list')
+        for game_id, game_name in games:
+            self.game_combo.addItem(game_name, game_id)
+
+    def accept(self):
+        name = self.name_edit.text()
+        description = self.description_edit.toPlainText()
+        game_id = self.game_combo.currentData()
+        if name and game_id:
+            event_system.emit_sync('add_new_exclusive_set', (name, description, game_id))
+            super().accept()
+        else:
+            QMessageBox.warning(self, "Invalid Input", "Please provide a name and select a game.")
+
 class PokemonUI(QWidget):  # Change from QMainWindow to QWidget
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -242,9 +319,110 @@ class PokemonUI(QWidget):  # Change from QMainWindow to QWidget
         reinit_db_btn.clicked.connect(self.reinitialize_database)
         db_tab_layout.addWidget(reinit_db_btn)
 
-        encounter_tab = QWidget()
-        encounter_tab_layout = QVBoxLayout(encounter_tab)
-        self.tab_widget.addTab(encounter_tab, "Manage Encounters")
+        manage_encounters = QWidget()
+        self.manage_encounters_tab = QHBoxLayout(manage_encounters)
+        self.tab_widget.addTab(manage_encounters, "Manage Encounters")
+
+        self.create_manage_encounters_ui()
+
+    def create_manage_encounters_ui(self):
+        # Left side: Exclusive encounter set list
+        left_layout = QVBoxLayout()
+        self.exclusive_set_list = QListWidget()
+        self.exclusive_set_list.currentItemChanged.connect(self.on_exclusive_set_selected)
+        left_layout.addWidget(QLabel("Exclusive Encounter Sets:"))
+        left_layout.addWidget(self.exclusive_set_list)
+
+        add_set_button = QPushButton("Add New Set")
+        add_set_button.clicked.connect(self.add_new_exclusive_set)
+        left_layout.addWidget(add_set_button)
+
+        # Right side: Set details and encounters
+        right_layout = QVBoxLayout()
+        self.set_name_label = QLabel()
+        self.set_description_label = QLabel()
+        self.set_game_label = QLabel()
+        right_layout.addWidget(self.set_name_label)
+        right_layout.addWidget(self.set_description_label)
+        right_layout.addWidget(self.set_game_label)
+
+        self.encounter_list = QListWidget()
+        self.encounter_list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.encounter_list.customContextMenuRequested.connect(self.show_encounter_context_menu)
+        right_layout.addWidget(QLabel("Encounters in Set:"))
+        right_layout.addWidget(self.encounter_list)
+
+        add_encounter_button = QPushButton("Add Encounter to Set")
+        add_encounter_button.clicked.connect(self.add_encounter_to_set)
+        right_layout.addWidget(add_encounter_button)
+
+        self.manage_encounters_tab.addLayout(left_layout, 1)
+        self.manage_encounters_tab.addLayout(right_layout, 2)
+
+        self.load_exclusive_sets()
+
+    def load_exclusive_sets(self):
+        self.exclusive_set_list.clear()
+        sets = event_system.call_sync('get_exclusive_encounter_sets')
+        for set_id, name in sets:
+            item = QListWidgetItem(name)
+            item.setData(Qt.ItemDataRole.UserRole, set_id)
+            self.exclusive_set_list.addItem(item)
+
+    def on_exclusive_set_selected(self, current, previous):
+        if current:
+            set_id = current.data(Qt.ItemDataRole.UserRole)
+            set_details = event_system.call_sync('get_exclusive_set_details', set_id)
+            self.update_set_details(set_details)
+            self.load_set_encounters(set_id)
+
+    def update_set_details(self, details):
+        name, description, game = details
+        self.set_name_label.setText(f"Name: {name}")
+        self.set_description_label.setText(f"Description: {description}")
+        self.set_game_label.setText(f"Game: {game}")
+
+    def load_set_encounters(self, set_id):
+        self.encounter_list.clear()
+        encounters = event_system.call_sync('get_set_encounters', set_id)
+        for encounter in encounters:
+            encounter_id = encounter[0]
+            pfic = encounter[1] 
+            location = encounter[2]
+            name = encounter[3]
+            form = encounter[4]
+
+            display_text = f"{name} ({form if form else 'Normal'}) - {location}"
+            item = QListWidgetItem(display_text)
+            item.setData(Qt.ItemDataRole.UserRole, (encounter_id))
+            self.encounter_list.addItem(item)
+
+    def show_encounter_context_menu(self, position):
+        item = self.encounter_list.itemAt(position)
+        if item:
+            context_menu = QMenu(self)
+            delete_action = QAction("Delete from Set", self)
+            delete_action.triggered.connect(lambda: self.delete_encounter_from_set(item))
+            context_menu.addAction(delete_action)
+            context_menu.exec(self.encounter_list.viewport().mapToGlobal(position))
+
+    def delete_encounter_from_set(self, item):
+        pfic, location = item.data(Qt.ItemDataRole.UserRole)
+        set_id = self.exclusive_set_list.currentItem().data(Qt.ItemDataRole.UserRole)
+        event_system.emit_sync('delete_encounter_from_set', (set_id, pfic, location))
+        self.load_set_encounters(set_id)
+
+    def add_encounter_to_set(self):
+        set_id = self.exclusive_set_list.currentItem().data(Qt.ItemDataRole.UserRole)
+        game = self.set_game_label.text().split(": ")[1]
+        dialog = AddEncounterToSetDialog(self, set_id, game)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            self.load_set_encounters(set_id)
+
+    def add_new_exclusive_set(self):
+        dialog = NewExclusiveSetDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            self.load_exclusive_sets()
 
     def on_pokemon_selected(self, item):
         pfic = item.data(Qt.ItemDataRole.UserRole)
@@ -546,9 +724,9 @@ class PokemonUI(QWidget):  # Change from QMainWindow to QWidget
             stars_edit.setText(stars or "")
             fishing_check.setChecked(bool(fishing))
             rods_edit.setText(rods or "")
-            index = exclusive_group_combo.findData(exclusive_group_id)
-            if index >= 0:
-                exclusive_group_combo.setCurrentIndex(index)
+            #index = exclusive_group_combo.findData(exclusive_group_id)
+            #if index >= 0:
+            #    exclusive_group_combo.setCurrentIndex(index)
 
         buttons = QDialogButtonBox(
             QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
@@ -751,3 +929,4 @@ class PokemonUI(QWidget):  # Change from QMainWindow to QWidget
     def gather_encounter_info(self):
         event_system.emit_sync('gather_encounter_info')
         
+