doomcc/dcc/doom_base.py

from abc import abstractmethod
from cliff.command import Command
import dcc.config
import io
import os
import re
import tomlkit


class Wad(dcc.config.Base):
    def get_parser(self, prog_name):
        parser = super().get_parser(prog_name)
        parser.add_argument("wad")
        return parser

    def wad_init(self, parsed_args):
        self.init_base(parsed_args)
        self._wad = parsed_args.wad
        wcp = self.pwads.joinpath(self.wad).joinpath(self.config_name)
        if wcp.exists():
            self._wad_config = tomlkit.toml_file.TOMLFile(wcp).read()
            for k, v in self._wad_config.items():
                if isinstance(v, dict):
                    if k not in self._config:
                        self._config[k] = {}
                    for sk in v:
                        self._config[k][sk] = v[sk]
                else:
                    self._config[k] = v
        self.finalize()

    def run(self, parsed_args):
        self.wad_init(parsed_args)
        self.take_action(parsed_args)

    @property
    def wad(self):
        return self._wad

    @property
    def pwad_path(self):
        return self.pwads.joinpath(self.wad)

    @property
    def iwad_path(self):
        iwad = self.iwads.joinpath(self._config.get("iwad"))
        iwadpath = self.pwad_path.joinpath("iwad")
        if iwadpath.exists():
            with io.open(iwadpath) as f:
                iwad = self.iwads.joinpath(f.read().strip() + ".WAD")
        return iwad

    def load_order(self):
        wads = self._config.get("load_order")
        if wads is None:
            wads = sorted(self.pwad_path.glob("*.wad", case_sensitive=False))
        else:
            wads = [self.pwad_path.joinpath(wad) for wad in wads]
        return wads

    def options_dict(self):
        return self._config.get("options", {})

    def options(self):
        options = []
        for k, v in self.options_dict().items():
            list.append(options, f"{k}={v}")
        if len(options) > 0:
            return ["-assign", ",".join(options)]
        return []


class WadMap(Wad):
    def get_parser(self, prog_name):
        parser = super().get_parser(prog_name)
        parser.add_argument("map")
        parser.add_argument("-n", "--name", "--demo_name")
        return parser

    def run(self, parsed_args):
        self._map = parsed_args.map
        self._name = parsed_args.name
        self.wad_init(parsed_args)

        self.take_action(parsed_args)

    @property
    def map(self):
        return self._map

    @property
    def name_string(self):
        return "" if self._name is None else "_" + self._name

    def dsda_preamble(self, warp=True):
        args = ["-iwad", self.iwad_path]

        wads = self.load_order()
        if len(wads) > 0:
            args = args + ["-file"] + wads

        dehs = sorted(self.pwad_path.glob("*.deh", case_sensitive=False))
        if len(dehs) > 0:
            args = args + ["-deh"] + dehs

        args = args + ["-complevel", str(self.complevel())]
        args = args + ["-skill", "4"]
        if warp:
            args = args + ["-warp", self.map]
        args = args + self.options()
        return args

    def complevel(self):
        complevel = self.pwads.joinpath(self.wad).joinpath("complevel")
        if not complevel.exists():
            complevel = self._config.get("complevel")
            if complevel is not None:
                return complevel
            raise Exception("No complevel set for wad {}.".format(self.wad))

        with io.open(complevel) as f:
            return f.read().strip()

    def demo_in_path(self):
        candidates = [
            x for x in self.demos.joinpath(self.wad)
            .glob(self._file_base("*.lmp"))
        ]
        if len(candidates) == 0:
            raise Exception(
                "no suitable demo candidates for WAD {} MAP {} name {}."
                .format(self.wad, self.map, self.name_string)
            )
        if len(candidates) == 1:
            return candidates[0]
        return sorted(filter(lambda s: re.search("-", str(s)), candidates))[-1]

    def dsda_text_path(self):
        return (
            self._ensure(self.demos.joinpath(self.wad))
            .joinpath(self._file_base(".txt"))
        )

    def video_path(self):
        return (
            self._ensure(self.fabricate.joinpath(self.wad))
            .joinpath(self._file_base(".mp4"))
        )

    def demo_out_path(self):
        return (
            self._ensure(self.demos.joinpath(self.wad))
            .joinpath(self._file_base(".lmp"))
        )

    def target_bucket(self):
        return "doom/" + self._file_base(".lmp")

    def base_thumb_path(self):
        return (
            self._ensure(self.fabricate.joinpath(self.wad))
            .joinpath(self._file_base("_base.png"))
        )

    def m_doom_path(self):
        return (
            self._ensure(self.fabricate.joinpath(self.wad))
            .joinpath("M_DOOM_scaled.png")
        )

    def text_thumb_path(self):
        return (
            self._ensure(self.fabricate.joinpath(self.wad))
            .joinpath(self._file_base("_text.png"))
        )

    def thumb_path(self):
        return (
            self._ensure(self.fabricate.joinpath(self.wad))
            .joinpath(self._file_base("_thumb.png"))
        )

    def _file_base(self, ext):
        return "{}_map{}{}{}".format(self.wad, self.map, self.name_string, ext)

    def _ensure(self, path):
        if not path.exists():
            os.mkdir(path)
        return path