Remove the userdata package.

game/debriefing.py

@@ -0,0 +1,201 @@
+import json
+import logging
+import os
+import threading
+import time
+import typing
+
+from game import db
+
+DEBRIEFING_LOG_EXTENSION = "log"
+
+class DebriefingDeadUnitInfo:
+    country_id = -1
+    player_unit = False
+    type = None
+
+    def __init__(self, country_id, player_unit , type):
+        self.country_id = country_id
+        self.player_unit = player_unit
+        self.type = type
+
+    def __repr__(self):
+        return str(self.country_id) + " " + str(self.player_unit) + " " + str(self.type)
+
+class Debriefing:
+    def __init__(self, state_data, game):
+        self.base_capture_events = state_data["base_capture_events"]
+        self.killed_aircrafts = state_data["killed_aircrafts"]
+        self.killed_ground_units = state_data["killed_ground_units"]
+        self.weapons_fired = state_data["weapons_fired"]
+        self.mission_ended = state_data["mission_ended"]
+        self.destroyed_units = state_data["destroyed_objects_positions"]
+
+        self.__destroyed_units = []
+        logging.info("--------------------------------")
+        logging.info("Starting Debriefing preprocessing")
+        logging.info("--------------------------------")
+        logging.info(self.base_capture_events)
+        logging.info(self.killed_aircrafts)
+        logging.info(self.killed_ground_units)
+        logging.info(self.weapons_fired)
+        logging.info(self.mission_ended)
+        logging.info(self.destroyed_units)
+        logging.info("--------------------------------")
+
+        self.player_country_id = db.country_id_from_name(game.player_country)
+        self.enemy_country_id = db.country_id_from_name(game.enemy_country)
+
+        self.dead_aircraft = []
+        self.dead_units = []
+        self.dead_aaa_groups = []
+        self.dead_buildings = []
+
+        for aircraft in self.killed_aircrafts:
+            try:
+                country = int(aircraft.split("|")[1])
+                type = db.unit_type_from_name(aircraft.split("|")[4])
+                player_unit = (country == self.player_country_id)
+                aircraft = DebriefingDeadUnitInfo(country, player_unit, type)
+                if type is not None:
+                    self.dead_aircraft.append(aircraft)
+            except Exception as e:
+                logging.error(e)
+
+        for unit in self.killed_ground_units:
+            try:
+                country = int(unit.split("|")[1])
+                type = db.unit_type_from_name(unit.split("|")[4])
+                player_unit = (country == self.player_country_id)
+                unit = DebriefingDeadUnitInfo(country, player_unit, type)
+                if type is not None:
+                    self.dead_units.append(unit)
+            except Exception as e:
+                logging.error(e)
+
+        for unit in self.killed_ground_units:
+            for cp in game.theater.controlpoints:
+
+                logging.info(cp.name)
+                logging.info(cp.captured)
+
+                if cp.captured:
+                    country = self.player_country_id
+                else:
+                    country = self.enemy_country_id
+                player_unit = (country == self.player_country_id)
+
+                for i, ground_object in enumerate(cp.ground_objects):
+                    logging.info(unit)
+                    logging.info(ground_object.string_identifier)
+                    if ground_object.matches_string_identifier(unit):
+                        unit = DebriefingDeadUnitInfo(country, player_unit, ground_object.dcs_identifier)
+                        self.dead_buildings.append(unit)
+                    elif ground_object.dcs_identifier in ["AA", "CARRIER", "LHA"]:
+                        for g in ground_object.groups:
+                            for u in g.units:
+                                if u.name == unit:
+                                    unit = DebriefingDeadUnitInfo(country, player_unit, db.unit_type_from_name(u.type))
+                                    self.dead_units.append(unit)
+
+        self.player_dead_aircraft = [a for a in self.dead_aircraft if a.country_id == self.player_country_id]
+        self.enemy_dead_aircraft = [a for a in self.dead_aircraft if a.country_id == self.enemy_country_id]
+        self.player_dead_units = [a for a in self.dead_units if a.country_id == self.player_country_id]
+        self.enemy_dead_units = [a for a in self.dead_units if a.country_id == self.enemy_country_id]
+        self.player_dead_buildings = [a for a in self.dead_buildings if a.country_id == self.player_country_id]
+        self.enemy_dead_buildings = [a for a in self.dead_buildings if a.country_id == self.enemy_country_id]
+
+        logging.info(self.player_dead_aircraft)
+        logging.info(self.enemy_dead_aircraft)
+        logging.info(self.player_dead_units)
+        logging.info(self.enemy_dead_units)
+
+        self.player_dead_aircraft_dict = {}
+        for a in self.player_dead_aircraft:
+            if a.type in self.player_dead_aircraft_dict.keys():
+                self.player_dead_aircraft_dict[a.type] = self.player_dead_aircraft_dict[a.type] + 1
+            else:
+                self.player_dead_aircraft_dict[a.type] = 1
+
+        self.enemy_dead_aircraft_dict = {}
+        for a in self.enemy_dead_aircraft:
+            if a.type in self.enemy_dead_aircraft_dict.keys():
+                self.enemy_dead_aircraft_dict[a.type] = self.enemy_dead_aircraft_dict[a.type] + 1
+            else:
+                self.enemy_dead_aircraft_dict[a.type] = 1
+
+        self.player_dead_units_dict = {}
+        for a in self.player_dead_units:
+            if a.type in self.player_dead_units_dict.keys():
+                self.player_dead_units_dict[a.type] = self.player_dead_units_dict[a.type] + 1
+            else:
+                self.player_dead_units_dict[a.type] = 1
+
+        self.enemy_dead_units_dict = {}
+        for a in self.enemy_dead_units:
+            if a.type in self.enemy_dead_units_dict.keys():
+                self.enemy_dead_units_dict[a.type] = self.enemy_dead_units_dict[a.type] + 1
+            else:
+                self.enemy_dead_units_dict[a.type] = 1
+
+        self.player_dead_buildings_dict = {}
+        for a in self.player_dead_buildings:
+            if a.type in self.player_dead_buildings_dict.keys():
+                self.player_dead_buildings_dict[a.type] = self.player_dead_buildings_dict[a.type] + 1
+            else:
+                self.player_dead_buildings_dict[a.type] = 1
+
+        self.enemy_dead_buildings_dict = {}
+        for a in self.enemy_dead_buildings:
+            if a.type in self.enemy_dead_buildings_dict.keys():
+                self.enemy_dead_buildings_dict[a.type] = self.enemy_dead_buildings_dict[a.type] + 1
+            else:
+                self.enemy_dead_buildings_dict[a.type] = 1
+
+        logging.info("--------------------------------")
+        logging.info("Debriefing pre process results :")
+        logging.info("--------------------------------")
+        logging.info(self.player_dead_aircraft_dict)
+        logging.info(self.enemy_dead_aircraft_dict)
+        logging.info(self.player_dead_units_dict)
+        logging.info(self.enemy_dead_units_dict)
+        logging.info(self.player_dead_buildings_dict)
+        logging.info(self.enemy_dead_buildings_dict)
+
+
+class PollDebriefingFileThread(threading.Thread):
+    """Thread class with a stop() method. The thread itself has to check
+    regularly for the stopped() condition."""
+
+    def __init__(self,  callback: typing.Callable, game):
+        super(PollDebriefingFileThread, self).__init__()
+        self._stop_event = threading.Event()
+        self.callback = callback
+        self.game = game
+
+    def stop(self):
+        self._stop_event.set()
+
+    def stopped(self):
+        return self._stop_event.is_set()
+
+    def run(self):
+        if os.path.isfile("state.json"):
+            last_modified = os.path.getmtime("state.json")
+        else:
+            last_modified = 0
+        while not self.stopped():
+            if os.path.isfile("state.json") and os.path.getmtime("state.json") > last_modified:
+                with open("state.json", "r") as json_file:
+                    json_data = json.load(json_file)
+                    debriefing = Debriefing(json_data, self.game)
+                    self.callback(debriefing)
+                break
+            time.sleep(5)
+
+
+def wait_for_debriefing(callback: typing.Callable, game)->PollDebriefingFileThread:
+    thread = PollDebriefingFileThread(callback, game)
+    thread.start()
+    return thread
+

game/event/event.py

@@ -1,25 +1,13 @@
-import typing
-import logging
-
-from dcs.action import Coalition
-from dcs.unittype import UnitType
-from dcs.task import *
-from dcs.vehicles import AirDefence
 from dcs.unittype import UnitType
 
 from game import *
+from game import persistency
+from game.debriefing import Debriefing
 from game.infos.information import Information
-from theater import *
 from gen.environmentgen import EnvironmentSettings
-from gen.conflictgen import Conflict
-from game.db import assigned_units_from, unitdict_from
+from theater import *
 from theater.start_generator import generate_airbase_defense_group
 
-from userdata.debriefing import Debriefing
-from userdata import persistency
-
-import game.db as db
-
 DIFFICULTY_LOG_BASE = 1.1
 EVENT_DEPARTURE_MAX_DISTANCE = 340000
 
@@ -28,6 +16,7 @@ MINOR_DEFEAT_INFLUENCE = 0.1
 DEFEAT_INFLUENCE = 0.3
 STRONG_DEFEAT_INFLUENCE = 0.5
 
+
 class Event:
     silent = False
     informational = False

game/event/frontlineattack.py

@@ -1,6 +1,6 @@
 from game.event import *
 from game.operation.frontlineattack import FrontlineAttackOperation
-from userdata.debriefing import Debriefing
+from ..debriefing import Debriefing
 
 
 class FrontlineAttackEvent(Event):

game/game.py

@@ -4,6 +4,7 @@ from game.db import REWARDS, PLAYER_BUDGET_BASE, sys
 from game.inventory import GlobalAircraftInventory
 from game.models.game_stats import GameStats
 from gen.ato import AirTaskingOrder
+from gen.conflictgen import Conflict
 from gen.flights.ai_flight_planner import CoalitionMissionPlanner
 from gen.flights.closestairfields import ObjectiveDistanceCache
 from gen.ground_forces.ai_ground_planner import GroundPlanner

game/operation/operation.py

@@ -8,7 +8,7 @@ from gen.tacan import TacanRegistry
 from dcs.countries import country_dict
 from dcs.lua.parse import loads
 from dcs.terrain.terrain import Terrain
-from userdata.debriefing import *
+from ..debriefing import Debriefing
 
 
 class Operation:

game/persistency.py

@@ -0,0 +1,80 @@
+import logging
+import os
+import pickle
+import shutil
+
+_dcs_saved_game_folder = None  # type: str
+_file_abs_path = None
+
+def setup(user_folder: str):
+    global _dcs_saved_game_folder
+    _dcs_saved_game_folder = user_folder
+    _file_abs_path = os.path.join(base_path(), "default.liberation")
+
+def base_path() -> str:
+    global _dcs_saved_game_folder
+    assert _dcs_saved_game_folder
+    return _dcs_saved_game_folder
+
+def _save_file() -> str:
+    return os.path.join(base_path(), "default.liberation")
+
+def _temporary_save_file() -> str:
+    return os.path.join(base_path(), "tmpsave.liberation")
+
+def _autosave_path() -> str:
+    return os.path.join(base_path(), "autosave.liberation")
+
+def _save_file_exists() -> bool:
+    return os.path.exists(_save_file())
+
+def mission_path_for(name: str) -> str:
+    return os.path.join(base_path(), "Missions", "{}".format(name))
+
+
+def restore_game():
+    if not _save_file_exists():
+        return None
+
+    with open(_save_file(), "rb") as f:
+        try:
+            save = pickle.load(f)
+            return save
+        except:
+            logging.error("Invalid Save game")
+            return None
+
+def load_game(path):
+    with open(path, "rb") as f:
+        try:
+            save = pickle.load(f)
+            save.savepath = path
+            return save
+        except:
+            logging.error("Invalid Save game")
+            return None
+
+def save_game(game) -> bool:
+    try:
+        with open(_temporary_save_file(), "wb") as f:
+            pickle.dump(game, f)
+        shutil.copy(_temporary_save_file(), game.savepath)
+        return True
+    except Exception as e:
+        logging.error(e)
+        return False
+
+def autosave(game) -> bool:
+    """
+    Autosave to the autosave location
+    :param game: Game to save
+    :return: True if saved succesfully
+    """
+    try:
+        with open(_autosave_path(), "wb") as f:
+            pickle.dump(game, f)
+        return True
+    except Exception as e:
+        logging.error(e)
+        return False
+