Browse Source

Merge pull request #162 from Hoikas/launch_plasma

Add the ability to launch URU from Korman.
pull/164/head
Adam Johnson 5 years ago committed by GitHub
parent
commit
b177067f33
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 36
      korman/addon_prefs.py
  2. 1
      korman/exporter/__init__.py
  3. 10
      korman/exporter/explosions.py
  4. 4
      korman/exporter/logger.py
  5. 114
      korman/operators/op_export.py
  6. 201
      korman/plasma_launcher.py
  7. 54
      korman/ui/ui_world.py

36
korman/addon_prefs.py

@ -33,6 +33,23 @@ class PlasmaGame(bpy.types.PropertyGroup):
items=game_versions, items=game_versions,
options=set()) options=set())
player = StringProperty(name="Player",
description="Name of the player to use when launching the game",
options=set())
ki = IntProperty(name="KI",
description="KI Number of the player to use when launching the game",
options=set(), min=0)
serverini = StringProperty(name="Server INI",
description="Name of the server configuation to use when launching the game",
options=set())
@property
def can_launch(self):
if self.version == "pvMoul":
return self.is_property_set("ki") and self.ki
else:
return self.is_property_set("player") and bool(self.player.strip())
class KormanAddonPreferences(bpy.types.AddonPreferences): class KormanAddonPreferences(bpy.types.AddonPreferences):
bl_idname = __package__ bl_idname = __package__
@ -120,14 +137,23 @@ class KormanAddonPreferences(bpy.types.AddonPreferences):
col.label("Game Configuration:") col.label("Game Configuration:")
box = col.box().column() box = col.box().column()
box.prop(active_game, "path", emboss=False)
box.prop(active_game, "version")
box.separator()
row = box.row(align=True) row = box.row(align=True)
op = row.operator("world.plasma_game_add", icon="FILE_FOLDER", text="Change Path") row.prop(active_game, "path")
op = row.operator("world.plasma_game_add", icon="FILE_FOLDER", text="")
op.filepath = active_game.path op.filepath = active_game.path
op.game_index = active_game_index op.game_index = active_game_index
box.prop(active_game, "version")
box.separator()
box.separator()
if active_game.version == "pvMoul":
box.alert = not active_game.is_property_set("ki")
box.prop(active_game, "ki", slider=False)
box.alert = False
box.prop(active_game, "serverini")
else:
box.alert = not active_game.is_property_set("player")
box.prop(active_game, "player")
# Python Installs # Python Installs
assert self.python_validated assert self.python_validated

1
korman/exporter/__init__.py

@ -19,5 +19,6 @@ from PyHSPlasma import *
from .convert import * from .convert import *
from .explosions import * from .explosions import *
from .locman import * from .locman import *
from .logger import *
from .python import * from .python import *
from . import utils from . import utils

10
korman/exporter/explosions.py

@ -42,6 +42,16 @@ class ExportAssertionError(ExportError):
super(ExportError, self).__init__("Assertion failed") super(ExportError, self).__init__("Assertion failed")
class PlasmaLaunchError(ExportError):
def __init__(self, *args, **kwargs):
if not args:
super(Exception, self).__init__("Failed to start Plasma")
elif len(args) > 1:
super(Exception, self).__init__(args[0].format(*args[1:], **kwargs))
else:
super(Exception, self).__init__(args[0])
class TooManyUVChannelsError(ExportError): class TooManyUVChannelsError(ExportError):
def __init__(self, obj, mat, numUVTexs, maxUVTexCount=8): def __init__(self, obj, mat, numUVTexs, maxUVTexCount=8):
msg = "There are too many UV Textures on the material '{}' associated with object '{}'. You can have at most {} (there are {})".format( msg = "There are too many UV Textures on the material '{}' associated with object '{}'. You can have at most {} (there are {})".format(

4
korman/exporter/logger.py

@ -34,8 +34,7 @@ class _ExportLogger:
self._time_start_overall = 0 self._time_start_overall = 0
def __enter__(self): def __enter__(self):
assert self._age_path is not None if self._age_path is not None:
# Make the log file name from the age file path -- this ensures we're not trying to write # Make the log file name from the age file path -- this ensures we're not trying to write
# the log file to the same directory Blender.exe is in, which might be a permission error # the log file to the same directory Blender.exe is in, which might be a permission error
my_path = self._age_path.with_name("{}_export".format(self._age_path.stem)).with_suffix(".log") my_path = self._age_path.with_name("{}_export".format(self._age_path.stem)).with_suffix(".log")
@ -45,6 +44,7 @@ class _ExportLogger:
def __exit__(self, type, value, traceback): def __exit__(self, type, value, traceback):
if value is not None: if value is not None:
ConsoleToggler().keep_console = not isinstance(value, NonfatalExportError) ConsoleToggler().keep_console = not isinstance(value, NonfatalExportError)
if self._file is not None:
self._file.close() self._file.close()
return False return False

114
korman/operators/op_export.py

@ -19,11 +19,12 @@ import cProfile
from pathlib import Path from pathlib import Path
from PyHSPlasma import * from PyHSPlasma import *
import pstats import pstats
import subprocess
from ..addon_prefs import game_versions from ..addon_prefs import game_versions
from .. import exporter from .. import exporter
from ..helpers import UiHelper from ..helpers import UiHelper
from .. import korlib from .. import korlib, plasma_launcher
from ..properties.prop_world import PlasmaAge from ..properties.prop_world import PlasmaAge
class ExportOperator: class ExportOperator:
@ -54,10 +55,6 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
# over on the PlasmaAge world properties. We've got a helper so we can access them like they're actually on us... # over on the PlasmaAge world properties. We've got a helper so we can access them like they're actually on us...
# If you want a volatile property, register it directly on this operator! # If you want a volatile property, register it directly on this operator!
_properties = { _properties = {
"profile_export": (BoolProperty, {"name": "Profile",
"description": "Profiles the exporter using cProfile",
"default": False}),
"verbose": (BoolProperty, {"name": "Display Verbose Log", "verbose": (BoolProperty, {"name": "Display Verbose Log",
"description": "Shows the verbose export log in the console", "description": "Shows the verbose export log in the console",
"default": False}), "default": False}),
@ -119,19 +116,49 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
default=True, default=True,
options={"HIDDEN"}) options={"HIDDEN"})
actions = EnumProperty(name="Actions",
description="Actions for the exporter to perform",
default={"EXPORT"},
items=[("EXPORT", "Export", "Export the age data"),
("PROFILE", "Profile", "Profile the exporter"),
("LAUNCH", "Launch Age", "Launch the age in Plasma")],
options={"ENUM_FLAG"})
ki = IntProperty(name="KI",
description="KI Number of the player to use when launching the game",
options=set())
player = StringProperty(name="Player",
description="Name of the player to use when launching the game",
options=set())
serverini = StringProperty(name="Server INI",
description="Name of the server configuation to use when launching the game",
options=set())
def draw(self, context): def draw(self, context):
layout = self.layout layout = self.layout
age = context.scene.world.plasma_age age = context.scene.world.plasma_age
# The crazy mess we're doing with props on the fly means we have to explicitly draw them :( # The crazy mess we're doing with props on the fly means we have to explicitly draw them :(
layout.prop(self, "actions")
layout.prop(self, "version") layout.prop(self, "version")
if "LAUNCH" in self.actions:
if self.version == "pvMoul":
layout.alert = not self.ki
layout.prop(self, "ki")
layout.alert = False
layout.prop(self, "serverini")
else:
layout.alert = not self.player.strip()
layout.prop(self, "player")
layout.alert = False
layout.prop(age, "texcache_method", text="") layout.prop(age, "texcache_method", text="")
layout.prop(age, "lighting_method") layout.prop(age, "lighting_method")
row = layout.row() row = layout.row()
row.enabled = korlib.ConsoleToggler.is_platform_supported() row.enabled = korlib.ConsoleToggler.is_platform_supported()
row.prop(age, "show_console") row.prop(age, "show_console")
layout.prop(age, "verbose") layout.prop(age, "verbose")
layout.prop(age, "profile_export")
def __getattr__(self, attr): def __getattr__(self, attr):
if attr in self._properties: if attr in self._properties:
@ -146,6 +173,10 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
def execute(self, context): def execute(self, context):
# Before we begin, do some basic sanity checking... # Before we begin, do some basic sanity checking...
if not self.actions:
self.report({"ERROR"}, "Nothing to do?")
return {"CANCELLED"}
path = Path(self.filepath) path = Path(self.filepath)
if not self.filepath: if not self.filepath:
self.error = "No file specified" self.error = "No file specified"
@ -168,12 +199,21 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
self.report({"ERROR"}, "The Age name conflicts with the Python keyword '{}'".format(ageName)) self.report({"ERROR"}, "The Age name conflicts with the Python keyword '{}'".format(ageName))
return {"CANCELLED"} return {"CANCELLED"}
# This prevents us from finding out at the very end that very, very bad things happened...
if "LAUNCH" in self.actions:
try:
self._sanity_check_run_plasma()
except exporter.ExportError as error:
self.report({"ERROR"}, str(error))
return {"CANCELLED"}
# Separate blender operator and actual export logic for my sanity # Separate blender operator and actual export logic for my sanity
if "EXPORT" in self.actions:
with UiHelper(context) as _ui: with UiHelper(context) as _ui:
e = exporter.Exporter(self) e = exporter.Exporter(self)
try: try:
self.export_active = True self.export_active = True
if self.profile_export: if "PROFILE" in self.actions:
profile_path = str(path.with_name("{}_cProfile".format(ageName))) profile_path = str(path.with_name("{}_cProfile".format(ageName)))
profile = cProfile.runctx("e.run()", globals(), locals(), profile_path) profile = cProfile.runctx("e.run()", globals(), locals(), profile_path)
else: else:
@ -183,18 +223,25 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
return {"CANCELLED"} return {"CANCELLED"}
except exporter.NonfatalExportError as error: except exporter.NonfatalExportError as error:
self.report({"ERROR"}, str(error)) self.report({"ERROR"}, str(error))
return {"FINISHED"}
else: else:
if self.profile_export: if "PROFILE" in self.actions:
stats_out = path.with_name("{}_profile.log".format(ageName)) stats_out = path.with_name("{}_profile.log".format(ageName))
with open(str(stats_out), "w") as out: with open(str(stats_out), "w") as out:
stats = pstats.Stats(profile_path, stream=out) stats = pstats.Stats(profile_path, stream=out)
stats = stats.sort_stats("time", "calls") stats = stats.sort_stats("time", "calls")
stats.print_stats() stats.print_stats()
return {"FINISHED"}
finally: finally:
self.export_active = False self.export_active = False
if "LAUNCH" in self.actions:
try:
self._run_plasma(context)
except exporter.ExportError as error:
self.report({"ERROR"}, str(error))
return {"CANCELLED"}
return {"FINISHED"}
def invoke(self, context, event): def invoke(self, context, event):
# Called when a user hits "export" from the menu # Called when a user hits "export" from the menu
# We will prompt them for the export info, then call execute() # We will prompt them for the export info, then call execute()
@ -217,11 +264,52 @@ class PlasmaAgeExportOperator(ExportOperator, bpy.types.Operator):
# Now do the majick # Now do the majick
setattr(PlasmaAge, name, prop(**age_options)) setattr(PlasmaAge, name, prop(**age_options))
def _sanity_check_run_plasma(self):
if not bpy.app.binary_path_python:
raise exporter.PlasmaLaunchError("Can't Launch Plasma: No Python executable available")
if self.version == "pvMoul":
if not self.ki:
raise exporter.PlasmaLaunchError("Can't Launch Plasma: Player KI not set")
else:
if not self.player:
raise exporter.PlasmaLaunchError("Can't Launch Plasma: Player Name not set")
def _run_plasma(self, context):
path = Path(self.filepath)
client_dir = path.parent.parent
# It would be nice to launch URU right here. Unfortunately, for single player URUs, we will
# need to actually wait for the whole rigamaroll to finish. Therefore, we need to kick
# open a separate python exe to launch URU and wait.
args = [bpy.app.binary_path_python, plasma_launcher.__file__,
str(client_dir), path.stem, self.version]
if self.version == "pvMoul":
if self.serverini:
args.append("--serverini")
args.append(self.serverini)
args.append(str(self.ki))
else:
args.append(self.player)
with exporter.ExportVerboseLogger() as log:
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
cwd=str(client_dir), universal_newlines=True)
while True:
line = proc.stdout.readline().strip()
if line == "DIE":
raise exporter.PlasmaLaunchError(proc.stderr.read().strip())
elif line in {"PLASMA_RUNNING", "DONE"}:
break
elif proc.returncode is not None:
break
elif line:
log.msg(line)
class PlasmaLocalizationExportOperator(ExportOperator, bpy.types.Operator): class PlasmaLocalizationExportOperator(ExportOperator, bpy.types.Operator):
bl_idname = "export.plasma_loc" bl_idname = "export.plasma_loc"
bl_label = "Export Localization" bl_label = "Export Localization"
bl_description = "Export Age Localization Data" bl_description = "Export Age localization data"
filepath = StringProperty(subtype="DIR_PATH") filepath = StringProperty(subtype="DIR_PATH")
filter_glob = StringProperty(default="*.pak", options={'HIDDEN'}) filter_glob = StringProperty(default="*.pak", options={'HIDDEN'})
@ -268,8 +356,8 @@ class PlasmaLocalizationExportOperator(ExportOperator, bpy.types.Operator):
class PlasmaPythonExportOperator(ExportOperator, bpy.types.Operator): class PlasmaPythonExportOperator(ExportOperator, bpy.types.Operator):
bl_idname = "export.plasma_pak" bl_idname = "export.plasma_pak"
bl_label = "Package Scripts" bl_label = "Export Python Scripts"
bl_description = "Package Age Python scripts" bl_description = "Export Age python script package"
filepath = StringProperty(subtype="FILE_PATH") filepath = StringProperty(subtype="FILE_PATH")
filter_glob = StringProperty(default="*.pak", options={'HIDDEN'}) filter_glob = StringProperty(default="*.pak", options={'HIDDEN'})

201
korman/plasma_launcher.py

@ -0,0 +1,201 @@
# This file is part of Korman.
#
# Korman is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Korman is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Korman. If not, see <http://www.gnu.org/licenses/>.
import argparse
from pathlib import Path
from PyHSPlasma import *
import shutil
import subprocess
import sys
import time
import traceback
main_parser = argparse.ArgumentParser(description="Korman Plasma Launcher")
main_parser.add_argument("cwd", type=Path, help="Working directory of the client")
main_parser.add_argument("age", type=str, help="Name of the age to launch into")
sub_parsers = main_parser.add_subparsers(title="Plasma Version", dest="version",)
moul_parser = sub_parsers.add_parser("pvMoul")
moul_parser.add_argument("ki", type=int, help="KI Number of the desired player")
moul_parser.add_argument("--serverini", type=str, default="server.ini")
sp_parser = sub_parsers.add_parser("pvPots", aliases=["pvPrime"])
sp_parser.add_argument("player", type=str, help="Name of the desired player")
autolink_chron_name = "OfflineKIAutoLink"
if sys.platform == "win32":
client_executables = {
"pvMoul": "plClient.exe",
"pvPots": "UruExplorer.exe"
}
else:
client_executables = {
"pvMoul": "plClient",
"pvPots": "UruExplorer"
}
def die(*args, **kwargs):
assert args
if len(args) == 1 and not kwargs:
sys.stderr.write(args[0])
else:
sys.stderr.write(args[0].format(*args[1:], **kwargs))
sys.stdout.write("DIE\n")
sys.exit(1)
def write(*args, **kwargs):
assert args
if len(args) == 1 and not kwargs:
sys.stdout.write(args[0])
else:
sys.stdout.write(args[0].format(*args[1:], **kwargs))
sys.stdout.write("\n")
# And this is why we aren't using print()...
sys.stdout.flush()
def backup_vault_dat(path):
backup_path = path.with_suffix(".dat.korman_backup")
shutil.copy2(str(path), str(backup_path))
write("DBG: Copied vault backup: {}", backup_path)
def set_link_chronicle(store, new_value, cond_value=None):
chron_folder = next((i for i in store.getChildren(store.firstNodeID)
if getattr(i, "folderType", None) == plVault.kChronicleFolder), None)
if chron_folder is None:
die("Could not locate vault chronicle folder.")
autolink_chron = next((i for i in store.getChildren(chron_folder.nodeID)
if getattr(i, "entryName", None) == autolink_chron_name), None)
if autolink_chron is None:
write("DBG: Creating AutoLink chronicle...")
autolink_chron = plVaultChronicleNode()
autolink_chron.entryName = autolink_chron_name
previous_value = ""
store.addRef(chron_folder.nodeID, store.lastNodeID + 1)
else:
write("DBG: Found AutoLink chronicle...")
previous_value = autolink_chron.entryValue
# Have to submit the changed node to the store
if cond_value is None or previous_value == cond_value:
write("DBG: AutoLink = '{}' (previously: '{}')", new_value, previous_value)
autolink_chron.entryValue = new_value
store.addNode(autolink_chron)
else:
write("DBG: ***Not*** changing chronicle! AutoLink = '{}' (expected: '{}')", previous_value, cond_value)
return previous_value
def find_player_vault(cwd, name):
sav_dir = cwd.joinpath("sav")
if not sav_dir.is_dir():
die("Could not locate sav directory.")
for i in sav_dir.iterdir():
if not i.is_dir():
continue
current_dir = i.joinpath("current")
if not current_dir.is_dir():
continue
vault_dat = current_dir.joinpath("vault.dat")
if not vault_dat.is_file():
continue
store = plVaultStore()
store.Import(str(vault_dat))
# First node is the Player node...
playerNode = store[store.firstNodeID]
if playerNode.playerName == name:
write("DBG: Vault found: {}", vault_dat)
return vault_dat, store
die("Could not locate the requested player vault.")
def main():
print("DBG: alive")
args = main_parser.parse_args()
executable = args.cwd.joinpath(client_executables[args.version])
if not executable.is_file():
die("Failed to locate client executable.")
# Have to find and mod the single player vault...
if args.version == "pvPots":
vault_path, vault_store = find_player_vault(args.cwd, args.player)
backup_vault_dat(vault_path)
vault_prev_autolink = set_link_chronicle(vault_store, args.age)
write("DBG: Saving vault...")
vault_store.Export(str(vault_path))
# Update init file for this schtuff...
init_path = args.cwd.joinpath("init", "net_age.fni")
with plEncryptedStream().open(str(init_path), fmWrite, plEncryptedStream.kEncXtea) as ini:
ini.writeLine("# This file was automatically generated by Korman.")
ini.writeLine("Nav.PageInHoldList GlobalAnimations")
ini.writeLine("Net.SetPlayer {}".format(vault_store.firstNodeID))
ini.writeLine("Net.SetPlayerByName \"{}\"".format(args.player))
# BUT WHY??? You ask...
# Because, sayeth Hoikas, if this command is not executed, you will remain ensconsed
# in the black void of the Link... forever... Sadly, it accepts no arguments and determines
# whether to link to AvatarCustomization, Cleft, Demo (whee!), or Personal all by itself.
ini.writeLine("Net.JoinDefaultAge")
# When URU runs, the player may change the vault. Remove any temptation to play with
# the stale vault...
del vault_store
# Sigh...
time.sleep(1.0)
# EXE args
plasma_args = [str(executable), "-iinit", "To_Dni"]
else:
write("DBG: Using a superior client :) :) :)")
plasma_args = [str(executable), "-LocalData", "-SkipLoginDialog", "-ServerIni={}".format(args.serverini),
"-PlayerId={}".format(args.ki), "-Age={}".format(args.age)]
try:
proc = subprocess.Popen(plasma_args, cwd=str(args.cwd), shell=True)
# signal everything is a-ok -- causes blender to detach
write("PLASMA_RUNNING")
# Wait for things to finish
proc.wait()
finally:
# Restore sp vault, if needed.
if args.version == "pvPots":
# Path of the Shell seems to have some sort of weird racing with the vault.dat around
# shutdown. This delay helps somewhat in that regard.
time.sleep(1.0)
vault_store = plVaultStore()
vault_store.Import(str(vault_path))
new_prev_autolink = set_link_chronicle(vault_store, vault_prev_autolink, args.age)
if new_prev_autolink != args.age:
write("DBG: ***Not*** resaving the vault!")
else:
write("DBG: Resaving vault...")
vault_store.Export(str(vault_path))
# All good!
write("DONE")
sys.exit(0)
if __name__ == "__main__":
try:
main()
except Exception as e:
if isinstance(e, SystemExit):
raise
else:
die(traceback.format_exc())

54
korman/ui/ui_world.py

@ -45,7 +45,7 @@ class PlasmaGameHelper:
if active_game is None: if active_game is None:
return "" return ""
age_name = bpy.context.world.plasma_age.age_name age_name = bpy.context.world.plasma_age.age_name
return str((Path(active_game.path) / dirname / age_name).with_suffix(ext)) return Path(active_game.path, dirname, age_name).with_suffix(ext)
@property @property
def legal_game(self): def legal_game(self):
@ -55,6 +55,7 @@ class PlasmaGameHelper:
class PlasmaGameExportMenu(PlasmaGameHelper, bpy.types.Menu): class PlasmaGameExportMenu(PlasmaGameHelper, bpy.types.Menu):
bl_label = "Plasma Export Menu" bl_label = "Plasma Export Menu"
bl_description = "Additional export methods"
def draw(self, context): def draw(self, context):
layout = self.layout layout = self.layout
@ -62,7 +63,7 @@ class PlasmaGameExportMenu(PlasmaGameHelper, bpy.types.Menu):
active_game = self.active_game active_game = self.active_game
legal_game = self.legal_game legal_game = self.legal_game
# Localization # Export Localization
row = layout.row() row = layout.row()
row.operator_context = "EXEC_DEFAULT" row.operator_context = "EXEC_DEFAULT"
row.enabled = legal_game row.enabled = legal_game
@ -71,15 +72,41 @@ class PlasmaGameExportMenu(PlasmaGameHelper, bpy.types.Menu):
op.filepath = active_game.path op.filepath = active_game.path
op.version = active_game.version op.version = active_game.version
# Python # Export Python
row = layout.row() row = layout.row()
row.operator_context = "EXEC_DEFAULT" row.operator_context = "EXEC_DEFAULT"
row.enabled = legal_game and active_game.version != "pvMoul" row.enabled = legal_game and active_game.version != "pvMoul"
op = row.operator("export.plasma_pak", icon="FILE_SCRIPT") op = row.operator("export.plasma_pak", icon="FILE_SCRIPT")
op.filepath = self.format_path("Python", ".pak") op.filepath = str(self.format_path("Python", ".pak"))
if active_game is not None: if active_game is not None:
op.version = active_game.version op.version = active_game.version
# Launch Age
row = layout.row()
row.operator_context = "EXEC_DEFAULT"
age_path = self.format_path()
row.active = legal_game and active_game.can_launch and age_path.exists()
op = row.operator("export.plasma_age", icon="RENDER_ANIMATION", text="Launch Age")
if active_game is not None:
op.actions = {"LAUNCH"}
op.dat_only = False
op.filepath = str(age_path)
op.version = active_game.version
op.player = active_game.player
op.ki = active_game.ki
op.serverini = active_game.serverini
# Package Age
row = layout.row()
row.operator_context = "INVOKE_DEFAULT"
row.enabled = legal_game
op = row.operator("export.plasma_age", icon="PACKAGE", text="Package Age")
if active_game is not None:
op.actions = {"EXPORT"}
op.dat_only = False
op.filepath = "{}.zip".format(age_name)
op.version = active_game.version
class PlasmaGamePanel(AgeButtonsPanel, PlasmaGameHelper, bpy.types.Panel): class PlasmaGamePanel(AgeButtonsPanel, PlasmaGameHelper, bpy.types.Panel):
bl_label = "Plasma Games" bl_label = "Plasma Games"
@ -106,22 +133,29 @@ class PlasmaGamePanel(AgeButtonsPanel, PlasmaGameHelper, bpy.types.Panel):
row.enabled = legal_game row.enabled = legal_game
op = row.operator("export.plasma_age", icon="EXPORT") op = row.operator("export.plasma_age", icon="EXPORT")
if active_game is not None: if active_game is not None:
op.actions = {"EXPORT"}
op.dat_only = False op.dat_only = False
op.filepath = self.format_path() op.filepath = str(self.format_path())
op.version = active_game.version op.version = active_game.version
# Package Age # Test Age (exports and tests the age)
row = row.row(align=True) row = row.row(align=True)
row.operator_context = "EXEC_DEFAULT"
# Sadly, if we nuke this row, the menu is nuked as well...
row.enabled = legal_game row.enabled = legal_game
row.operator_context = "INVOKE_DEFAULT" op = row.operator("export.plasma_age", icon="RENDER_ANIMATION", text="Test Age")
op = row.operator("export.plasma_age", icon="PACKAGE", text="Package Age")
op.dat_only = False
op.filepath = "{}.zip".format(age.age_name)
if active_game is not None: if active_game is not None:
op.actions = {"EXPORT", "LAUNCH"}
op.dat_only = False
op.filepath = str(self.format_path())
op.version = active_game.version op.version = active_game.version
op.player = active_game.player
op.ki = active_game.ki
op.serverini = active_game.serverini
# Special Menu # Special Menu
row = row.row(align=True) row = row.row(align=True)
row.enabled = True
row.menu("PlasmaGameExportMenu", icon='DOWNARROW_HLT', text="") row.menu("PlasmaGameExportMenu", icon='DOWNARROW_HLT', text="")

Loading…
Cancel
Save