[PYTHON] Les débutants veulent créer quelque chose comme un cube rubic avec UE4 et en faire une bibliothèque pour un apprentissage amélioré # 4
Dans la continuité de la dernière fois, il s'agit d'un article dans lequel les débutants continueront à travailler à la création d'une bibliothèque Python qui implique UE4 (presque comme un mémorandum pour moi-même ...).
Premièrement: # 1 Dernière fois: # 3
Essayez d'importer avec un script Python, etc.
Je spécifie l'un des modules Python dans le plan PyActor, mais à ce moment-là, j'ai essayé d'importer les modules Python dans l'autre dossier Script. J'ai l'impression d'avoir essayé de sortir sur la console avec ue.log etc., et il semble que seul celui spécifié dans le plan PyActor soit exécuté. Il semble que l'importation elle-même d'autres modules ne provoque pas d'erreur, mais lorsque j'appelle une fonction ajoutée dans ce module, une erreur se produit. Celui installé avec pip peut être utilisé sans aucun problème, mais en gros, il semble préférable de le considérer comme un module pour un PyActor.
Cependant, si tel est le cas, vous aurez des problèmes avec le traitement courant. Alors, essayez d'ajouter un dossier tel que commun au dossier où la bibliothèque est ajoutée avec pip et importez-le.
Le dossier de la bibliothèque est ajouté par pip de Plugins \ UnrealEnginePython \ Binaries \ Win64 Un dossier appelé common est ajouté au répertoire du plugin, et un fichier appelé sqlite_utils.py est ajouté en supposant qu'un traitement commun pour les éléments liés à SQLite est écrit. Essayez la description suivante dans ce fichier.
sqlite_utils.py
def print_test(ue):
ue.log('sqlite_utils test')
Ensuite, ajoutez la description suivante dans le module spécifié par PyActor.
import unreal_engine as ue
from common import sqlite_utils
sqlite_utils.print_test(ue=ue)
Le répertoire géré par pip devrait être dans le chemin, donc je l'essaye en supposant qu'il devrait pouvoir être importé. Voyons un aperçu dans UE4 (ou plutôt, Play est le mot correct ...).
Il semble que le module importé soit appelé avec succès. Lorsque vous devez écrire du Python qui couvre plusieurs modules, il semble bon d'ajouter le module au dossier de la bibliothèque.
De plus, au lieu d'importer directement unreal_engine dans le module common.sqlite_utils, il est passé en tant qu'argument de fonction à partir du module spécifié par PyActor, mais si ce n'est pas le module spécifié par PyActor, il fonctionnera également comme ue.log. pas. Peut-être que vous ne pouvez pas utiliser l'importation du module unreal_engine autre que le module spécifié par PyActor. Par conséquent, si le module unreal_engine est requis du côté du module commun, passez-le comme argument cette fois.
Réfléchissez à ce qu'il faut faire avec le test des scripts Python
Pour le développement, j'aimerais écrire un test avec un script Python. Cependant, comme mentionné ci-dessus, il existe une restriction selon laquelle il y a un module pour chaque classe PyActor, et ceux impliquant le module unreal_engine ne peuvent pas être testés sans jouer sur UE4, donc un exécuteur de test tel que pytest ne peut pas être utilisé.
Donc, bien que cela semble irrégulier, je vais procéder comme suit.
- Ecrire la fonction de test avec le préfixe test_ dans le module lui-même spécifié par chaque PyActor. --Préparez un code simple pour votre propre testeur (ne faites pas de code élaboré) dans le module commun. --PyActor Passez votre propre module comme argument à votre propre lanceur de test au niveau supérieur du module spécifié, et exécutez la fonction de préfixe test_ du côté du lanceur de test réussi.
Pour le moment, nous allons commencer avec notre propre testeur.
py:common.python_test_runner.py
"""Un module qui gère l'exécution des tests pour chaque script Python.
Notes
-----
- unreal_Pour la commodité d'entrelacer le module moteur, sans séparer le module de test
Fonctionner.
"""
from datetime import datetime
import inspect
def run_tests(ue, target_module):
"""
Exécutez les tests définis pour le module cible.
Parameters
----------
ue : unreal_engine
Importé dans le module Python spécifié par chaque PyActor,
Module de bibliothèque Python UnrealEngine.
target_module : module
Le module à tester. Test en module_Du préfixe
La fonction est exécutée.
"""
ue.log(
'%s %Commencez à tester le module s...'
% (datetime.now(), target_module.__name__))
members = inspect.getmembers(target_module)
for obj_name, obj_val in members:
if not inspect.isfunction(obj_val):
continue
if not obj_name.startswith('test_'):
continue
ue.log(
'%Fonction cible: %s' % (datetime.now(), obj_name))
pre_dt = datetime.now()
obj_val()
timedelta = datetime.now() - pre_dt
ue.log('%s ok. %s secondes' % (datetime.now(), timedelta.total_seconds()))
J'ajusterai les détails plus tard, mais une fois que c'est une implémentation simple, tout va bien. Avec la fonction getmembers du module d'inspection intégré, vous pouvez prendre l'élément membre du module spécifié dans l'argument, donc tournez-le dans une boucle, vérifiez s'il s'agit d'une fonction avec la fonction isfunction, et le traitement de flux uniquement lorsque le nom de la fonction a un préfixe de test_ Je le fais. Le reste n'est que la description qui renvoie l'heure du test, le nom du module cible, le nom de la fonction, etc. vers la console.
Séparément, dans le module spécifié par PyActor, préparez un module d'écriture de SQLite pour transmettre des données dans le flux de la bibliothèque UE4 → Python. Là, j'ai préparé une fonction supplémentaire appelée add pour vérifier le fonctionnement du test runner, que j'effacerai plus tard.
to_python_sqlite_writer.py
"""Gère l'écriture de données depuis UE4 vers SQLite pour les bibliothèques Python
Module pour.
"""
import sys
import importlib
import time
import unittest
import unreal_engine as ue
from common import python_test_runner
importlib.reload(python_test_runner)
def add(a, b):
time.sleep(1)
return a + b
def test_add():
added_val = add(a=1, b=3)
assert added_val == 4
python_test_runner.run_tests(
ue=ue, target_module=sys.modules[__name__])
Pour vérifier l'affichage du temps de test, je l'ai volontairement mis en veille pendant 1 seconde dans la fonction.
Comme mentionné ci-dessus, j'essaye d'écrire des tests dans le même module.
Enfin, le processus de test runner est appelé au niveau supérieur. Vous pouvez obtenir votre propre module en faisant sys.moduels [__name __].
De plus, le module spécifié par PyActor est automatiquement rechargé du côté UE4 après la mise à jour du code (car la fenêtre contextuelle de configuration apparaît), mais il semble que le module commun, etc. ne soit pas rechargé automatiquement. Par conséquent, le changement de code peut ne pas être reflété immédiatement, donc je le recharge avec importlib pour une réflexion immédiate (peut-être qu'il sera supprimé à la fin ...).
Jouons avec UE4.
Le test a réussi. J'ajusterai les détails plus tard si nécessaire, mais pour le moment, cela semble correct ...
Mettez le nez dans la bibliothèque de tests
Récemment, lorsque j'écris du code en privé, j'utilise souvent pytest en raison de l'excellence des testeurs, mais cette fois je n'ai besoin que des fonctions assert (assert_equal et assert_raises), donc pour faciliter les choses, la bibliothèque de test de nose Je vais le mettre.
$ ./python.exe -m pip install --target . nose
Successfully installed nose-1.3.7
Pour m'assurer que cela fonctionne sur UE4, je vais ajuster le code que j'ai écrit dans la validation du test il y a quelque temps.
to_python_sqlite_writer.py
from nose.tools import assert_equal
...
def test_add():
added_val = add(a=1, b=3)
assert_equal(added_val, 4)
Cela semble marcher correctement.
Continuons avec la partie lecture et écriture dans SQLite
La dernière fois, j'ai mis SQLAlchemy pour SQLite et je l'ai soutenu au point où l'importation, etc. peut être effectuée au moins, mais je vais confirmer qu'il n'y a pas de problème de vérification un peu plus et organiser les fichiers provisoires. Tout d'abord, supprimez python_and_h5py_test.py utilisé pour la vérification, comme h5py et la classe de plan qui lui est associée.
Tout d'abord, ajoutez le processus pour obtenir la chaîne de caractères pour spécifier le chemin de SQLAlchemy de SQLite dans le module commun.
common\sqlite_utils.py
"""Un module qui décrit les traitements courants liés à SQLite.
"""
import os
import sys
DESKTOP_FOLDER_NAME = 'cubicePuzzle3x3'
def get_sqlite_engine_file_path(file_name):
"""
Obtenez le chemin du fichier pour spécifier le moteur de SQL Alchemy dans SQLite.
Parameters
----------
file_name : str
Le nom du fichier SQL cible qui contient l'extension.
Returns
-------
sqlite_file_path : str
Une chaîne de chemins pour spécifier le moteur de SQLite.
sqlite:///Un dossier pour SQLite est créé sur le bureau à partir de
Mettre en forme.
Notes
-----
Il est créé si le dossier de destination de l'enregistrement n'existe pas.
"""
dir_path = os.path.join(
os.environ['HOMEPATH'], 'Desktop', DESKTOP_FOLDER_NAME)
os.makedirs(dir_path, exist_ok=True)
sqlite_file_path = 'sqlite:///{dir_path}/{file_name}'.format(
dir_path=dir_path,
file_name=file_name,
)
return sqlite_file_path
Au fur et à mesure que je l'ai écrit, j'ai remarqué que je ne peux pas écrire de test pour un module commun (ce module lui-même n'importe pas le module ue).
Par conséquent, ajoutez un module pour exécuter le test du module commun et une classe blueprint de PyActor, et exécutez le test de chaque module commun via cela.
Content\Scripts\run_common_module_tests.py
"""Pour les modules sous le répertoire commun du plug-in Python
Exécutez le test.
"""
import sys
import inspect
import unreal_engine as ue
from common import python_test_runner
from common.tests import test_sqlite_utils
NOT_TEST_TARGET_MODULES = [
sys,
inspect,
ue,
python_test_runner,
]
members = inspect.getmembers(sys.modules[__name__])
for obj_name, obj_val in members:
if not inspect.ismodule(obj_val):
continue
is_in = obj_val in NOT_TEST_TARGET_MODULES
if is_in:
continue
python_test_runner.run_tests(ue=ue, target_module=obj_val)
Le côté BP l'a nommé BP_RunCommonModuleTests.
J'écrirai un test. Pour le module commun, l'importation du module ue est inutile en raison du code ci-dessus, et il n'y a pas de problème même si les modules sont séparés, donc test_ <nom du module avec le répertoire du module de test pris en sandwich comme un test normal Nous procéderons sous la forme de> .py.
common\tests\test_sqlite_utils.py
"""sqlite_Un module pour tester le module utils.
"""
from nose.tools import assert_equal, assert_true
from common import sqlite_utils
def test_get_sqlite_engine_file_path():
sqlite_file_path = sqlite_utils.get_sqlite_engine_file_path(
file_name='test_dbfile.sqlite')
assert_true(
sqlite_file_path.startswith('sqlite:///')
)
is_in = sqlite_utils.DESKTOP_FOLDER_NAME in sqlite_file_path
assert_true(is_in)
assert_true(
sqlite_file_path.endswith('/test_dbfile.sqlite')
)
Jouons à UE4.
Ça me va. Vous pouvez désormais également écrire des tests du côté du module commun. Le problème est qu'il n'est pas possible de tester uniquement des modules spécifiques ou des fonctions spécifiques, qui sont préparés par pytest etc. Je penserai à ce point lorsque le nombre de tests augmente et que cela me semble assez gênant (par exemple, permettre de tester rapidement uniquement des modules spécifiques). Il y a de fortes chances que le temps de test reste à un niveau qui ne vous dérange pas tant que l'implémentation n'est pas terminée ...
Vérifiez le comportement pour tester SQLite, envisagez le traitement d'initialisation et le test lorsqu'une classe est prise en sandwich entre les scripts PyActor
Lorsque je travaillais sur UE4 et que je testais avec SQLite, il y avait un cas où le fichier SQLite restait verrouillé même si Play était à nouveau exécuté (par exemple lorsqu'une erreur s'est produite au milieu). ).
Lorsqu'elle est réellement emballée, il semble que l'application sera supprimée une fois, mais pendant le développement, il est difficile de redémarrer UE4 à chaque fois pour la déverrouiller. Assurez-vous d'insérer les informations de date et d'heure au moment où vous appuyez sur Lecture dans le nom du fichier afin qu'il s'agisse d'un fichier SQLite différent à chaque lecture. Ajoutez le nom initializer.py et le plan PyActor.
Content\Scripts\initializer.py
"""Un module qui décrit le processus qui est exécuté en premier, comme le démarrage du jeu.
"""
import json
from datetime import datetime
import os
import sys
import time
import importlib
from nose.tools import assert_equal, assert_true
import unreal_engine as ue
from common import const, file_helper
from common.python_test_runner import run_tests
importlib.reload(const)
importlib.reload(file_helper)
def save_session_data_json():
"""
Pour conserver les informations au début d'une seule session de jeu
Enregistrez le fichier JSON.
"""
session_data_dict = {
const.SESSION_DATA_KEY_START_DATETIME: str(datetime.now()),
}
file_path = file_helper.get_session_json_file_path()
with open(file_path, mode='w') as f:
json.dump(session_data_dict, f)
ue.log('initialized.')
save_session_data_json()
def test_save_session_data_json():
pre_session_json_file_name = const.SESSION_JSON_FILE_NAME
const.SESSION_JSON_FILE_NAME = 'test_game_session.json'
expected_file_path = file_helper.get_session_json_file_path()
save_session_data_json()
assert_true(os.path.exists(expected_file_path))
with open(expected_file_path, 'r') as f:
json_str = f.read()
data_dict = json.loads(json_str)
expected_key_list = [
const.SESSION_DATA_KEY_START_DATETIME,
]
for key in expected_key_list:
has_key = key in data_dict
assert_true(has_key)
os.remove(expected_file_path)
const.SESSION_JSON_FILE_NAME = pre_session_json_file_name
run_tests(
ue=ue,
target_module=sys.modules[__name__])
Nous ajouterons également un module commun pour les opérations sur les fichiers et ses tests.
Win64\common\file_helper.py
"""Un module qui décrit les traitements courants liés aux opérations sur les fichiers.
"""
import os
import time
import json
from datetime import datetime
from common.const import DESKTOP_FOLDER_NAME
from common import const
def get_desktop_data_dir_path():
"""
Obtenez un répertoire pour enregistrer les données sur le bureau.
Returns
-------
dir_path : str
Chemin du répertoire pour stocker les données de bureau récupérées.
Notes
-----
Il est créé si le dossier de destination de l'enregistrement n'existe pas.
"""
dir_path = os.path.join(
os.environ['HOMEPATH'], 'Desktop', DESKTOP_FOLDER_NAME)
os.makedirs(dir_path, exist_ok=True)
return dir_path
def get_session_json_file_path():
"""
Pour conserver les informations au début d'une seule session de jeu
Obtenez le chemin du fichier JSON.
Returns
-------
file_path : str
Chemin du fichier cible.
"""
file_path = os.path.join(
get_desktop_data_dir_path(),
const.SESSION_JSON_FILE_NAME
)
return file_path
def get_session_start_time_str(remove_symbols=True):
"""
Récupérez la chaîne de date et d'heure au début d'une session de jeu à partir du fichier JSON.
Il est utilisé pour les noms de fichiers SQLite.
Parameters
----------
remove_symbols : bool, default True
Supprimez le symbole de la chaîne de valeur de retour pour en faire une valeur avec uniquement des entiers demi-largeur
Que ce soit pour convertir.
Returns
-------
session_start_time_str : str
Une chaîne de dates et d'heures au début d'une session de jeu.
"""
time.sleep(0.1)
file_path = get_session_json_file_path()
with open(file_path, mode='r') as f:
data_dict = json.load(f)
session_start_time_str = str(
data_dict[const.SESSION_DATA_KEY_START_DATETIME])
if remove_symbols:
session_start_time_str = session_start_time_str.replace('-', '')
session_start_time_str = session_start_time_str.replace('.', '')
session_start_time_str = session_start_time_str.replace(':', '')
session_start_time_str = session_start_time_str.replace(' ', '')
return session_start_time_str
Ajoutez également un module pour le traitement commun SQLite.
Win64\common\sqlite_utils.py
"""Un module qui décrit les traitements courants liés à SQLite.
"""
import os
import sys
import sqlalchemy
from sqlalchemy.orm import sessionmaker
from common import file_helper
def get_sqlite_engine_file_path(file_name):
"""
Obtenez le chemin du fichier pour spécifier le moteur de SQL Alchemy dans SQLite.
Parameters
----------
file_name : str
Le nom du fichier SQL cible qui contient l'extension.
Returns
-------
sqlite_file_path : str
Une chaîne de chemins pour spécifier le moteur de SQLite.
sqlite:///Un dossier pour SQLite est créé sur le bureau à partir de
Mettre en forme.
Notes
-----
Il est créé si le dossier de destination de l'enregistrement n'existe pas.
"""
dir_path = file_helper.get_desktop_data_dir_path()
sqlite_file_path = 'sqlite:///{dir_path}/{file_name}'.format(
dir_path=dir_path,
file_name=file_name,
)
return sqlite_file_path
def create_session(sqlite_file_name, declarative_meta):
"""
Créez une session SQLite.
Parameters
----------
sqlite_file_name : str
Le nom du fichier SQLite cible.
declarative_meta : DeclarativeMeta
Un objet qui stocke les métadonnées pour chaque table dans le SQLite cible.
Returns
-------
session : Session
La session SQLite générée.
"""
sqlite_file_path = get_sqlite_engine_file_path(
file_name=sqlite_file_name)
engine = sqlalchemy.create_engine(sqlite_file_path, echo=True)
declarative_meta.metadata.create_all(bind=engine)
Session = sessionmaker(bind=engine)
session = Session()
return session
Win64\common\tests\test_sqlite_utils.py
"""sqlite_Un module pour tester le module utils.
"""
import os
from nose.tools import assert_equal, assert_true
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer
from common import sqlite_utils, file_helper
def test_get_sqlite_engine_file_path():
sqlite_file_path = sqlite_utils.get_sqlite_engine_file_path(
file_name='test_dbfile.sqlite')
assert_true(
sqlite_file_path.startswith('sqlite:///')
)
is_in = file_helper.DESKTOP_FOLDER_NAME in sqlite_file_path
assert_true(is_in)
assert_true(
sqlite_file_path.endswith('/test_dbfile.sqlite')
)
def test_create_session():
if not os.path.exists(file_helper.get_session_json_file_path()):
return
session_start_time_str = file_helper.get_session_start_time_str()
sqlite_file_name = 'test_%s.sqlite' % session_start_time_str
expected_file_path = sqlite_utils.get_sqlite_engine_file_path(
file_name=sqlite_file_name)
if os.path.exists(expected_file_path):
os.remove(expected_file_path)
declarative_meta = declarative_base()
class TestTable(declarative_meta):
id = Column(Integer, primary_key=True)
__tablename__ = 'test_table'
session = sqlite_utils.create_session(
sqlite_file_name=sqlite_file_name,
declarative_meta=declarative_meta)
test_data = TestTable()
session.add(instance=test_data)
session.commit()
query_result = session.query(TestTable)
for test_data in query_result:
assert_true(isinstance(test_data.id, int))
expected_file_path = expected_file_path.replace('sqlite:///', '')
assert_true(
os.path.exists(expected_file_path))
session.close()
os.remove(expected_file_path)
Bien qu'il soit correct d'insérer initializer.py, lors de son utilisation réelle, il est nécessaire que le processus du module connecté à SQLite soit exécuté après l'initialisation. D'un autre côté, on ne sait pas quel module sera exécuté en premier dans PyActor (dans certains cas, les scripts de niveau supérieur d'autres modules seront exécutés avant l'initialisation).
Par conséquent, pour ce qui doit être fait après l'initialisation, spécifiez la classe avec PyActor et démarrez-la via la méthode begin_play (via begin_play, elle sera exécutée après le traitement de niveau supérieur de chaque module. On dirait, au moins autant que j'ai essayé).
- Un modèle de table provisoire a été ajouté ci-dessous, mais il sera supprimé après vérification de l'opération. Pour le moment, le test est suffisamment léger pour qu'aucune erreur ne se produise.
Content\Scripts\to_python_sqlite_writer.py
"""Gère l'écriture de données depuis UE4 vers SQLite pour les bibliothèques Python
Module pour.
"""
import sys
import importlib
import time
import unittest
import time
import unreal_engine as ue
from nose.tools import assert_equal, assert_true
import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from common import python_test_runner, sqlite_utils, file_helper
importlib.reload(python_test_runner)
importlib.reload(sqlite_utils)
declarative_meta = declarative_base()
class ToPythonSqliteWriter:
class TestTable(declarative_meta):
id = Column(Integer, primary_key=True)
name = Column(String(length=256))
__tablename__ = 'test_table'
def begin_play(self):
"""
Une fonction qui est exécutée lorsque le jeu Play démarre.
Notes
-----
Il est exécuté après le traitement de niveau supérieur de chaque module.
"""
self.session_start_time_str = \
file_helper.get_session_start_time_str()
self.SQLITE_FILE_NAME = 'to_python_from_ue4_%s.sqlite'\
% self.session_start_time_str
self.session = sqlite_utils.create_session(
sqlite_file_name=self.SQLITE_FILE_NAME,
declarative_meta=declarative_meta,
)
python_test_runner.run_begin_play_test(
begin_play_test_func=self.test_begin_play
)
def test_begin_play(self):
assert_equal(
self.session_start_time_str,
file_helper.get_session_start_time_str(),
)
is_in = 'to_python_from_ue4_' in self.SQLITE_FILE_NAME
assert_true(is_in)
is_in = '.sqlite' in self.SQLITE_FILE_NAME
assert_true(is_in)
query_result = self.session.query(self.TestTable)
python_test_runner.run_tests(
ue=ue, target_module=sys.modules[__name__])
De plus, comme le testeur actuellement ajouté ne prend en charge que les tests de niveau supérieur, nous insérerons une fonction appelée run_begin_play_test pour exécuter un test pour la méthode liée à l'événement UE4 spécial de begin_play.
Win64\common\python_test_runner.py
def run_begin_play_test(begin_play_test_func):
"""
Début de la classe spécifiée par PyActor_Test de la méthode de jeu
Exécuter.
Parameters
----------
begin_play_test_func : function
Début de la cible_Testez la méthode de lecture.
"""
begin_play_test_func()
Actuellement, il n'y a presque pas de contenu, mais nous allons insérer un processus pour qu'il ne soit exécuté que pendant le développement plus tard (car nous n'avons pas encore été en mesure de coopérer avec l'UE4 dans cette mesure).
Vérifiez le fichier SQLite généré
Si vous vérifiez que le test réussit et que vous vérifiez le bureau, vous pouvez voir que le fichier a été généré pour le moment.
Vérifions un peu le contenu. Installez DB Browser for SQLite et vérifiez le contenu.
Pour le moment, SQLite via UE4 semble fonctionner correctement.
Autoriser Python à prendre la valeur de savoir s'il s'agit d'un environnement packagé
Du côté Python également, permettez de prendre la valeur du nœud Is Packaged for Distribution afin que les tests etc. ne soient exécutés que pendant le développement. Cependant, comme l'appel de fonction ne peut être effectué que via uobject, il doit passer par la classe et il ne peut pas être traité au niveau supérieur de l'initialiseur. Eh bien, il s'agit simplement de réduire les traitements inutiles, et ce n'est pas quelque chose qui peut être fait, alors continuons sans nous soucier des détails ...
Puisque nous devons appeler la fonction sur le plan UE4 à partir de Python, ajoutez d'abord la fonction cible au plan directeur.
C'est une fonction qui renvoie simplement la valeur de la fonction préparée. Est-il possible d'appeler une fonction directement préparée (verte au lieu de violet) depuis Python sans cette fonction? J'ai essayé, mais il a été joué sans une telle chose, donc je vais le préparer normalement.
Spécifiez également la classe sur le plan.
Nous allons procéder avec le support côté Python. Nous devons parcourir le uobjet de la classe, alors préparez la classe.
Content\Scripts\initializer.py
class Initializer:
def begin_play(self):
"""
Une fonction qui est exécutée lorsque le jeu Play démarre.
"""
self.is_packaged_for_distribution = \
self.uobject.isPackagedForDistribution()[0]
_update_packaged_for_distribution_value(
is_packaged_for_distribution=self.is_packaged_for_distribution)
def _update_packaged_for_distribution_value(is_packaged_for_distribution):
"""
Si l'environnement est conditionné pour la distribution (pour la production)
Mettez à jour la valeur booléenne.
Parameters
----------
is_packaged_for_distribution : bool
Valeur booléenne à définir.
"""
file_path = file_helper.get_session_json_file_path()
if os.path.exists(file_path):
with open(file_path, mode='r') as f:
session_data_dict = json.load(f)
else:
session_data_dict = {}
if is_packaged_for_distribution:
is_packaged_for_distribution_int = 1
else:
is_packaged_for_distribution_int = 0
with open(file_path, mode='w') as f:
session_data_dict[
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION] = \
is_packaged_for_distribution_int
json.dump(session_data_dict, f)
def test__update_packaged_for_distribution_value():
pre_session_json_file_name = const.SESSION_JSON_FILE_NAME
const.SESSION_JSON_FILE_NAME = 'test_game_session.json'
expected_file_path = file_helper.get_session_json_file_path()
_update_packaged_for_distribution_value(
is_packaged_for_distribution=True)
with open(expected_file_path, mode='r') as f:
session_data_dict = json.load(f)
assert_equal(
session_data_dict[
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION],
1
)
_update_packaged_for_distribution_value(
is_packaged_for_distribution=False)
with open(expected_file_path, mode='r') as f:
session_data_dict = json.load(f)
assert_equal(
session_data_dict[
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION],
0
)
os.remove(expected_file_path)
const.SESSION_JSON_FILE_NAME = pre_session_json_file_name
De plus, bien que la valeur soit prise comme self.uobject.isPackagedForDistribution () [0], même s'il n'y a qu'une seule valeur de retour de la fonction blueprint, elle est passée sous forme de taple côté Python, donc c'est fait. Je vais.
Même si je produis sur la console sur UE4, c'est faux, mais je dois m'inquiéter que la branche ne fonctionne pas pendant quelques minutes.
Apparemment, il semble que la sortie de la console soit directement comme False ou True au lieu de l'affichage taple comme (False,). C'est déroutant ... (au moins une virgule ...)
Quand j'ai affiché le type, j'ai remarqué que c'était un tuple.
J'ajouterai également le processus d'acquisition de valeur.
Win64\common\file_helper.py
def get_packaged_for_distribution_bool():
"""
Obtient la valeur booléenne indiquant s'il est dans un état empaqueté pour la distribution.
Notes
-----
Seulement au début du premier démarrage, le moment où la valeur ne peut pas être obtenue normalement avant d'enregistrer la valeur
Existe. Dans ce cas, False sera retourné.
Returns
-------
is_packaged_for_distribution : bool
Vrai et emballé pour la distribution (pour la production), Faux
Pour le developpement.
"""
file_path = get_session_json_file_path()
if not os.path.exists(file_path):
return False
with open(file_path, mode='r') as f:
json_str = f.read()
if json_str == '':
session_data_dict = {}
else:
session_data_dict = json.loads(json_str)
has_key = const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION \
in session_data_dict
if not has_key:
return False
is_packaged_for_distribution = session_data_dict[
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION]
if is_packaged_for_distribution == 1:
return True
return False
Win64\common\tests\test_file_helper.py
def test_get_packaged_for_distribution_bool():
pre_session_json_file_name = file_helper.const.SESSION_JSON_FILE_NAME
file_helper.const.SESSION_JSON_FILE_NAME = 'test_game_session.json'
file_path = file_helper.get_session_json_file_path()
if os.path.exists(file_path):
os.remove(file_path)
#Vérifiez la valeur de retour si le fichier n'existe pas.
is_packaged_for_distribution = \
file_helper.get_packaged_for_distribution_bool()
assert_false(is_packaged_for_distribution)
#Si le fichier existe, mais que des caractères vides sont définis
#Vérifiez la valeur renvoyée.
with open(file_path, 'w') as f:
f.write('')
is_packaged_for_distribution = \
file_helper.get_packaged_for_distribution_bool()
assert_false(is_packaged_for_distribution)
#Vérifiez la valeur de retour lorsque la valeur est définie sur 1.
with open(file_path, 'w') as f:
session_data_dict = {
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION: 1,
}
json.dump(session_data_dict, f)
is_packaged_for_distribution = \
file_helper.get_packaged_for_distribution_bool()
assert_true(
is_packaged_for_distribution
)
#Vérifiez la valeur de retour lorsque la valeur est définie sur 0.
with open(file_path, 'w') as f:
session_data_dict = {
const.SESSION_DATA_KEY_IS_PACKAGED_FOR_DISTRIBUTION: 0,
}
json.dump(session_data_dict, f)
is_packaged_for_distribution = \
file_helper.get_packaged_for_distribution_bool()
assert_false(is_packaged_for_distribution)
os.remove(file_path)
file_helper.const.SESSION_JSON_FILE_NAME = pre_session_json_file_name
Placez des branches dans différentes parties du testeur comme indiqué ci-dessous.
Win64\common\python_test_runner.py
def run_tests(ue, target_module):
...
is_packaged_for_distribution = \
file_helper.get_packaged_for_distribution_bool()
if is_packaged_for_distribution:
return
...
Refléter l'état aléatoire de l'affichage initial
Actuellement, il commence avec les couleurs alignées, alors faites-le pivoter au hasard pour lui donner l'impression d'un cube rubic normal.
Nous avons un processus de rotation immédiat qui ne s'anime pas, nous allons donc l'utiliser pour ajouter des fonctions au plan. De plus, comme le nom de la fonction est réinitialisé dans la bibliothèque Gym d'OpenAI pour le processus de réinitialisation de l'environnement, définissez-le comme réinitialisé en fonction de cela (il est utilisé non seulement au début, mais également lors du déplacement à nouveau).
Tout d'abord, obtenez la valeur du nombre de tours à tourner. Il semble que quelque chose comme le randint de NumPy soit préparé dans le nœud Random Integer, alors utilisez-le. Il semble que la valeur minimale est définie sur 0 et la valeur maximale est définie sur Max -1. De plus, si elle est laissée telle quelle, lorsque 0 sort, la surface sera alignée depuis le début ..., elle doit donc être tournée au moins 200 fois sur le nœud MAX.
Préparez une valeur booléenne en tant que variable locale pour déterminer dans quelle direction tourner dans la boucle. Définissez-le également sur False au début de la boucle.
Tout d'abord, XYZ La valeur de vérité de la direction de rotation est déterminée au hasard comme étant True. Essayez d'utiliser le nœud Switch pour la première fois. Si vous êtes habitué à la programmation, vous pouvez l'utiliser sans aucun problème.
Puis le sens de rotation. Décidez au hasard de la rotation vers la gauche ou vers la droite, ou vers le haut ou vers le bas.
Enfin, calculez la valeur telle que la colonne à faire pivoter. Puisqu'il est nécessaire de calculer une valeur de 1 à 3, la valeur de 0 à 2 est sortie par le noeud Random Integer puis incrémentée de 1.
Après cela, branchez avec Branch selon la valeur déterminée et exécutez la rotation requise, et c'est terminé.
Je vais le déplacer.
La couleur s'est bien détachée. Je ne sais pas comment le faire pivoter pour que toutes les couleurs soient alignées.
Essayez de l'exécuter à nouveau.
C'est différent du précédent. Ça me va. C'est un processus avec beaucoup de boucles, mais dans mon environnement de bureau, cela se termine en un instant, et il n'est pas nécessaire de maintenir le FPS en particulier, et en premier lieu, la personne qui travaille avec un apprentissage amélioré par l'apprentissage est le bureau, et un PC avec des spécifications raisonnablement bonnes La plupart le seront, donc je pense qu'il n'y a pas de problème.
Préparez un processus pour acquérir la valeur booléenne indiquant s'il tourne ou non.
Je suis ennuyé si une autre rotation est effectuée pendant l'animation. Finalement, j'essaierai de contrôler les erreurs du côté Python, mais pour le moment, j'ajouterai une implémentation sur le plan et j'écrirai le code Python en coopération avec cela.
Le nom sera créé avec un plan qui hérite de PyActor nommé BP_Action selon les termes de la bibliothèque Gym.
- Pour des mots sur la bibliothèque Gym, voir Introduction à l'apprentissage amélioré # 1 Termes de base et introduction à Gym et PyTorch.
Il n'y a pas de mal à ajouter un plan, mais au fait, comment mettre les acteurs au niveau ...? Quand j'ai réfléchi, c'était écrit dans le document officiel.
Il semble que vous puissiez utiliser le nœud Get All Actors Of Class, je vais donc l'essayer.
C'est un nœud qui tourne simplement en boucle et imprime le nom à l'écran.
Il s'affiche correctement. Facile.
Avec cela, il semble que nous pouvons préparer une fonction pour prendre la valeur de savoir si l'acteur du cube en rotation existe ou non dans le plan de BP_Action.
Ajoutez une fonction appelée isRotating au plan directeur de la classe de base de BP_CubeBase.
Puisque nous avions préparé une fonction pour obtenir la valeur de vérité de la rotation cible dans chaque sens de rotation auparavant, nous préparerons un tableau de valeurs de vérité avec des variables locales et intégrerons le tableau en l'appelant. Il semble que vous puissiez ajouter un tableau à un tableau avec le nœud APPEND (comportement de type extension en Python).
Lorsque j'ai fini d'ajouter un ensemble de valeurs booléennes au tableau, j'avais l'habitude de préparer une fonction à un autre endroit qui renvoie True si l'une des valeurs booléennes est True dans le tableau en passant le tableau (that). J'ai spécifié 3 séquences, mais ...), donc je vais l'utiliser.
Créez un plan pour BP_Action avec une fonction nommée isAnyCubeRotating.
Utilisez Get All Actors Of Class, que j'ai mentionné il y a quelque temps, pour obtenir un tableau et le boucler.
S'il y a un cube qui tourne dans la boucle, il sera envoyé au nœud de retour vrai, et si la boucle est terminée sans en trouver un en rotation, il sera envoyé au nœud de retour faux.
En outre, dans le modèle BP_Action, spécifiez le module et la classe Python.
Ajoutez un module appelé action.py côté Python et écrivez le processus. Je n'ai pas encore écrit le processus de rotation etc. du côté Python, donc je vais sauter le test etc. une fois (je l'écrirai si le test fonctionnel lié est préparé, mais je comprends bien qu'il n'est pas maintenu et lié à UE4 Parce que non). Essayez également la sortie de la console avec tick (pour l'instant, elle doit toujours renvoyer False).
Content\Scripts\action.py
"""Un module qui décrit certains traitements liés au contrôle du comportement dans l'agent.
"""
import unreal_engine as ue
class Action:
def tick(self, delta_time):
"""
Une fonction qui est exécutée à peu près toutes les images pendant le jeu.
Parameters
----------
delta_time : float
Secondes écoulées depuis le dernier appel de tick.
"""
ue.log(is_any_cube_rotating(action_instance=self))
def is_any_cube_rotating(action_instance):
"""
Obtient la valeur booléenne indiquant si un cube est en train de tourner.
Parameters
----------
action_instance : Action
Une instance de la classe Action avec uobject.
Returns
----------
is_rotating : bool
True est défini si un cube tourne.
"""
is_rotating = action_instance.uobject.isAnyCubeRotating()[0]
return is_rotating
Si vous regardez le journal, vous pouvez voir que False est affiché.
...
LogPython: False
LogPython: False
LogPython: False
LogPython: False
...
Cela semble bien pour le moment. Éteignez la sortie de la console et passez à la suivante.
Mettre NumPy dans
Lorsque j'ai désinstallé la relation hdf5, j'ai également désinstallé NumPy qui était installé en tant que dépendances, mais après tout je voulais l'utiliser, donc je n'inclurai que NumPy.
$ ./python.exe -m pip install --target . numpy
Successfully installed numpy-1.17.3
Faire progresser la mise en œuvre des contrôles liés à l'action.
Tout d'abord, j'ai défini l'attribution des numéros d'action. Assurez-vous de vérifier les doublons et s'ils sont correctement inclus dans la liste.
Content\Scripts\action.py
import numpy as np
...
ACTION_ROTATE_X_LEFT_1 = 1
ACTION_ROTATE_X_LEFT_2 = 2
ACTION_ROTATE_X_LEFT_3 = 3
ACTION_ROTATE_X_RIGHT_1 = 4
ACTION_ROTATE_X_RIGHT_2 = 5
ACTION_ROTATE_X_RIGHT_3 = 6
ACTION_ROTATE_Y_UP_1 = 7
ACTION_ROTATE_Y_UP_2 = 8
ACTION_ROTATE_Y_UP_3 = 9
ACTION_ROTATE_Y_DOWN_1 = 10
ACTION_ROTATE_Y_DOWN_2 = 11
ACTION_ROTATE_Y_DOWN_3 = 12
ACTION_ROTATE_Z_UP_1 = 13
ACTION_ROTATE_Z_UP_2 = 14
ACTION_ROTATE_Z_UP_3 = 15
ACTION_ROTATE_Z_DOWN_1 = 16
ACTION_ROTATE_Z_DOWN_2 = 17
ACTION_ROTATE_Z_DOWN_3 = 18
ACTION_LIST = [
ACTION_ROTATE_X_LEFT_1,
ACTION_ROTATE_X_LEFT_2,
ACTION_ROTATE_X_LEFT_3,
ACTION_ROTATE_X_RIGHT_1,
ACTION_ROTATE_X_RIGHT_2,
ACTION_ROTATE_X_RIGHT_3,
ACTION_ROTATE_Y_UP_1,
ACTION_ROTATE_Y_UP_2,
ACTION_ROTATE_Y_UP_3,
ACTION_ROTATE_Y_DOWN_1,
ACTION_ROTATE_Y_DOWN_2,
ACTION_ROTATE_Y_DOWN_3,
ACTION_ROTATE_Z_UP_1,
ACTION_ROTATE_Z_UP_2,
ACTION_ROTATE_Z_UP_3,
ACTION_ROTATE_Z_DOWN_1,
ACTION_ROTATE_Z_DOWN_2,
ACTION_ROTATE_Z_DOWN_3,
]
...
def test_ACTION_LIST():
assert_equal(
len(ACTION_LIST), len(np.unique(ACTION_LIST))
)
members = inspect.getmembers(sys.modules[__name__])
for obj_name, obj_val in members:
if not obj_name.startswith('ACTION_ROTATE_'):
continue
assert_true(isinstance(obj_val, int))
is_in = obj_val in ACTION_LIST
assert_true(is_in)
python_test_runner.run_tests(
ue=ue,
target_module=sys.modules[__name__])
Ajoutez la fonction de chaque action à BP_Action en fonction du nom de constante défini. J'ai pensé, mais la fonction pour calculer la liste des cubes cibles par rotation était écrite dans le plan de niveau. J'ai l'impression qu'appeler cette fonction depuis BP_Action semble être un problème ... (je suis confus car je ne peux pas y faire référence tant que je ne m'y suis pas habitué ...) Référence: Considérez comment faire référence au plan de niveau
Je ne peux pas m'empêcher de pleurer, donc je vais d'abord ajouter une fonction au plan de la classe de base du cube pour obtenir la valeur booléenne de savoir s'il s'agit du cube cible à chaque rotation (puis du cube dans le niveau). Peut être pris avec le nœud Get All Actors Of Class ...).
Essayez la bibliothèque de fonctions
Avant de continuer, j'ai écrit quelque chose comme un assistant d'assertion dans le plan de niveau, mais cela peut être gênant car il ne peut pas être utilisé dans la classe BP, donc je vais envisager de l'ajuster.
Quand je l'ai recherché, il semble qu'il y ait une bibliothèque de fonctions.
Qu'est-ce qu'une bibliothèque de fonctions? Un plan qui vous permet d'avoir diverses fonctions accessibles de n'importe où en un seul endroit. Contrairement aux plans normaux, il ne peut pas contenir de variables et il n'y a pas de graphe d'événements. Vous ne pouvez pas créer de macros, uniquement des fonctions. Les fonctions qui y sont écrites seront utilisables quel que soit le plan directeur, l'acteur ou le niveau. [UE4] Bonne utilisation de la bibliothèque de fonctions et de la bibliothèque de macros
Comment le faire a été écrit dans l'article suivant: arc:
Créer une bibliothèque de fonctions UE4 (Blueprint Function Library)
Par convention, quel doit être le nom du dossier de la bibliothèque de fonctions ...? Dans les vidéos et les livres, des coutumes telles que BluePrints pour les plans, BP_ au début des noms de fichiers, Matériaux pour les matériaux, etc. ont été introduites, mais comment était la bibliothèque de fonctions en premier lieu? La bibliothèque de fonctions a-t-elle été introduite ... (il n'est pas bon d'oublier immédiatement si vous ne l'avez pas sortie ...)
Pour le moment, ce n'est pas un travail, alors n'hésitez pas à le nommer le dossier Dossiers. Essayez de préfixer le nom de fichier avec LIB_.
Il semble que vous puissiez le créer en ajoutant un nouveau fichier dans le navigateur de contenu et en sélectionnant Blueprints → Blueprint Function Library.
Je l'ai nommé LIB_Testing parce que je veux ajouter des relations de test.
Quand je l'ouvre, ça ressemble à ça. Cela ressemble à un plan avec une structure très simple composée uniquement de fonctions et de variables locales. Déplacez ici la fonction que vous souhaitez déplacer et remplacez-la par celle du niveau BP existant.
Il semble que les fonctions ajoutées à la bibliothèque puissent être appelées à partir du niveau BP ou d'autres classes BP telles quelles sans rien de spécial.
Cela facilite la vérification des valeurs de lumière dans la classe BP.
Ajouter un traitement pour obtenir la valeur booléenne indiquant s'il s'agit ou non de la cible de rotation de la classe de base du cube
Comme mentionné ci-dessus, nous pourrons obtenir la valeur booléenne de savoir s'il s'agit ou non de la cible de rotation à partir de la classe de base de BP_CubeBase, et la rendre appelable depuis BP_Action.
Puisque nous allons créer une fonction qui renvoie une valeur booléenne comme indiqué ci-dessous dans la plage de 1 à 3 dans XYZ, nous ajouterons 9 fonctions.
La partie commune est séparée en différentes fonctions. De plus, le tableau du type de position du cube cible dans la rotation de la cible est une constante et a déjà été préparé auparavant, nous allons donc l'utiliser.
Dans le processus commun, tournez la boucle pour le tableau
Si la valeur de type de la position du cube actuel correspond à la valeur du tableau d'index dans la boucle actuelle, True est renvoyé et s'il n'y a pas de valeur correspondante même après la fin de la boucle, False est renvoyé.
J'omettrai les détails, mais j'écrirai un test pour confirmer dans une certaine mesure le comportement du processus.
Maintenant que nous avons 9 rotations prêtes et que le test n'est pas pris, nous pouvons passer à autre chose. Essayons d'ajouter une fonction de rotation à BP_Action. Tout d'abord, nous partirons du simple type de rotation non animée.
Tout d'abord, prenez l'acteur du cube et tournez la boucle.
Après cela, définissez une branche en fonction de la valeur de vérité de savoir s'il s'agit ou non de la cible de rotation préparée précédemment, et si elle est True, faites-la pivoter.
Je vais également l'essayer du côté Python.
Content\Scripts\action.py
class Action:
total_delta_time = 0
is_rotated = False
def tick(self, delta_time):
"""
Une fonction qui est exécutée à peu près toutes les images pendant le jeu.
Parameters
----------
delta_time : float
Secondes écoulées depuis le dernier appel de tick.
"""
self.total_delta_time += delta_time
if self.total_delta_time > 5 and not self.is_rotated:
self.uobject.rotateXLeftImmediately1()
self.is_rotated = True
Pour le moment, il tournera immédiatement une fois toutes les 5 secondes.
J'ai essayé de le prévisualiser, mais cela semble correct. Nous allons construire un autre traitement de rotation de la même manière, mais avant cela, déplacez la fonction pour tester le résultat de la rotation vers le côté bibliothèque de fonctions afin qu'elle puisse être référencée du côté BP_Action, et remplacez la fonction du côté niveau. Et coupez-le.
Après le déplacement, ajoutez une fonction pour vérifier la valeur après la rotation de la cible à la fin de la fonction ajoutée à BP_Action cette fois, et prévisualisez-la pour vous assurer qu'elle ne soit pas prise dans le contrôle.
Cela semble bien pour le moment, alors ajoutez une série de rotations dans d'autres directions et appelez-la du côté Python pour vérifier l'opération.
Le processus de rotation immédiate via Python semble être correct. La prochaine fois, je travaillerai sur la connexion du processus de rotation d'animation à Python (l'article s'allonge, je vais donc laisser cet article ici).
Points de préoccupation
- Parfois, les mises à jour des scripts Python n'étaient pas reflétées (le redémarrage de UE4 le corrigera). Étant donné que le processus Python reste en cours d'exécution, j'ai été troublé par des cas tels que divers traitements incohérents qui ne fonctionnaient pas bien s'il était laissé tel quel pendant longtemps. Il y a des cas où cela ne peut pas être corrigé même si vous utilisez importlib. N'est-ce pas qu'il faut beaucoup de temps pour démarrer? Je suis un peu inquiet. Je me demande s'il existe un bon moyen de le faire ... (Je pense que c'est correct d'attraper un problème sur le github du plug-in Unreal Engine Python plus tard ...)
Résumé de la page de référence
- nose extends unittest to make testing easier.
- Introduction à Renforcer l'apprentissage # 1 Termes de base et introduction à Gym, PyTorch
- Recherche d'acteurs par plan
- Réfléchissez à la façon de vous référer au plan de niveau
- [UE4] Bonne utilisation de la bibliothèque de fonctions et de la bibliothèque de macros
- Créer une bibliothèque de fonctions générales UE4 (Blueprint Function Library)