public static UnityEngine.Object GetLocalObject(UnityObject id)
{
if (localObjects.ContainsKey(id)) {
return localObjects[id];
} else {
return null;
}
}
public static UnityObject Save(UnityObject unityObject)
{
if (GetLocalObject(unityObject) == null) {
unityObject.path = null;
unityObject.uuid = null;
} else {
unityObject.path = AssetDatabase.GetAssetPath(GetLocalObject(unityObject));
unityObject.uuid = AssetDatabase.AssetPathToGUID(unityObject.path);
}
return unityObject;
}
public static UnityEngine.Object GetAsset(UnityObject unityObject, Type type)
{
if (!assets.ContainsKey(unityObject.uuid)) {
if (string.IsNullOrEmpty(unityObject.path)) {
return null;
}
string resourcePath = Regex.Replace(unityObject.path, @".*Resources\/", "");
resourcePath = GetFullPathWithoutExtension(resourcePath);
assets[unityObject.uuid] = Resources.Load(resourcePath, type);
}
return assets[unityObject.uuid];
}
public static UnityObject Load(UnityObject unityObject, Type type)
{
if (unityObject == null) {
return new UnityObject();
}
if (!string.IsNullOrEmpty(unityObject.uuid) && GetLocalObject(unityObject) == null) {
SetLocalObject(unityObject,AssetDatabase.LoadAssetAtPath(unityObject.path, type));
return unityObject;
} else {
return unityObject;
}
}
private void OnLoadSucc(AssetRequestSource assetRequestSource, UnityObject u)
{
var obj = u.AsGameObject;
var isSourceExist = false;
var comp = GetComponent(assetRequestSource);
var entity = GetEntity(assetRequestSource.EntityKey);
if (comp != null)
{
var assetStatus = comp.Resources[assetRequestSource.ResIndex];
if (assetStatus.LastRequestTime == assetRequestSource.TimeLine)
{
isSourceExist = true;
var actions = GetActions(assetRequestSource.ResIndex);
if (obj == null)
{
actions.OnLoadFailed(entity, assetStatus);
assetStatus.Status = EAssetLoadStatus.Failed;
}
else
{
assetStatus.Object = u;
if (actions.CanInit(entity, assetStatus))
{
actions.Init(entity, assetStatus);
assetStatus.Status = EAssetLoadStatus.Loaded;
}
else
{
assetStatus.Status = EAssetLoadStatus.UnInit;
}
}
}
}
if (!isSourceExist)
{
_loadRequestManager.Recycle(u);
}
}
public void OnLoadSucc(string source, UnityObject unityObj)
{
SingletonManager.Get <SubProgressBlackBoard>().Step();
_loadingCount--;
if (unityObj.AsObject == null)
{
_logger.ErrorFormat("Preload asset {0} failed", unityObj.Address);
}
else
{
_assetManager.Recycle(unityObj);
}
if (_loadingCount <= 0)
{
_sessionState.FullfillExitCondition(typeof(PreLoadSystem));
}
}
static void AddAdditionalLightData()
{
var lights = UnityObject.FindObjectsOfType(typeof(Light)) as Light[];
foreach (var light in lights)
{
// Do not add a component if there already is one.
if (light.GetComponent <HDAdditionalLightData>() == null)
{
light.gameObject.AddComponent <HDAdditionalLightData>();
}
if (light.GetComponent <AdditionalShadowData>() == null)
{
AdditionalShadowData shadowData = light.gameObject.AddComponent <AdditionalShadowData>();
HDAdditionalShadowData.InitDefaultHDAdditionalShadowData(shadowData);
}
}
}
public void UnloadGo(UnityObject go, int sceneIndex)
{
var sceneName = _sceneDescription.Scenes[sceneIndex].SceneName;
if (_unloadingScene.ContainsKey(sceneName))
{
_unloadingScene[sceneName].Enqueue(go);
}
else
{
if (!_toBeDestroyedGo.ContainsKey(sceneName))
{
_toBeDestroyedGo.Add(sceneName, new Queue <UnityObject>());
}
_toBeDestroyedGo[sceneName].Enqueue(go);
RequestForUnload();
}
}
public void OnLoadSucc(BulletEntity bullet, UnityObject unityObj)
{
if (null != bullet && unityObj != null && unityObj.AsGameObject)
{
if (GMVariable.NeedBulletFlyLog)
{
Object res = UnityEditor.AssetDatabase.LoadAssetAtPath <Object>("Assets/Assets/CoreRes/Sound/Model/Sphere.prefab");
var clone = GameObject.Instantiate(res) as GameObject;
unityObj.AsObject = clone;
}
bullet.AddBulletAsset(unityObj);
if (unityObj.AudioMono == null)
{
unityObj.AudioMono = unityObj.AsGameObject.AddComponent <AkGameObj>();
}
GameAudioMedia.PlayEventAudio((int)EAudioUniqueId.BulletFly, unityObj.AudioMono as AkGameObj, true);
}
}
public bool SetGoActivatiton(DistCullingCat cat, bool isActivated, IStreamingResourceHandler handler)
{
bool ret = false;
if (cat == Cat)
{
switch (Status)
{
case StreamingGoStatus.NotLoaded:
if (isActivated)
{
handler.LoadGo(Key.SceneIndex, Key.GoIndex);
Status = StreamingGoStatus.Loading;
}
break;
case StreamingGoStatus.Loading:
if (!isActivated)
{
Status = StreamingGoStatus.NotLoaded;
}
break;
case StreamingGoStatus.Loaded:
if (!isActivated)
{
handler.UnloadGo(Go, Key.SceneIndex);
Status = StreamingGoStatus.NotLoaded;
RemoveHandlers();
Go = null;
ret = true;
}
break;
}
}
return(ret);
}
public void LoadFromPool(UnityObject unityObject)
{
_logger.DebugFormat("LoadFromPool :{0} {1}", i, unityObject.AsGameObject);
mrs.Clear();
trs.Clear();
// recover origin state info
GameObject go = unityObject.AsGameObject;
go.GetComponentsInChildren <MeshRenderer>(true, mrs);
foreach (MeshRenderer mr in mrs)
{
if (mr != null)
{
int id = mr.GetInstanceID();
if (originShadows.ContainsKey(id))
{
mr.shadowCastingMode = originShadows[id];
}
if (originLightProbes.ContainsKey(id))
{
mr.lightProbeUsage = originLightProbes[id];
}
// recover lightmap
// (由于室内物件的烘焙贴图在运行时决定，室外物件不启用烘焙，在资源回收时取消烘焙信息以避免复用时出现物件贴图不正确的情况)
mr.lightmapIndex = -1;
}
}
go.GetComponentsInChildren <Transform>(true, trs);
foreach (Transform tr in trs)
{
if (tr != null)
{
int id = tr.GetInstanceID();
if (originStatus.ContainsKey(id) && tr.gameObject.activeSelf != originStatus[id])
{
tr.gameObject.SetActive(originStatus[id]);
}
}
}
}
public void OnLoadSucc(string source, UnityObject unityObj)
{
var assetInfo = unityObj.Address;
var obj = unityObj.As <TextAsset>();
foreach (var cfg in _configs)
{
if (assetInfo.AssetName.Equals(cfg.Asset))
{
if (null != cfg.OnReload)
{
cfg.OnReload(obj as TextAsset);
}
else
{
CommonReload(obj as TextAsset, cfg.Parser);
}
}
}
}
private static bool checkRigidHands(out GameObject[] rigidHandObjects)
{
if (LeapProjectChecks.CheckIgnoredKey(IGNORE_RIGID_HANDS_CHECK_KEY))
{
rigidHandObjects = null;
return(true);
}
rigidHandObjects = UnityObject.FindObjectsOfType <RigidHand>().Query()
.Select(x => x.gameObject).ToArray();
if (rigidHandObjects.Length != 0 &&
UnityObject.FindObjectOfType <InteractionManager>() != null)
{
return(false);
}
else
{
return(true);
}
}
public void OnLoadSucc(PlayerEntity player, UnityObject unityObj)
{
if (player.isFlagDestroy)
{
return;
}
var transform = unityObj.AsGameObject.transform;
const string anchorName = "Driver_Seat";
var anchor = transform.FindChildRecursively(anchorName);
if (anchor == null)
{
throw new Exception(String.Format("Can not find anchor with name {0} for parachute!", anchorName));
}
player.playerSkyMove.IsParachuteLoading = false;
player.playerSkyMove.Parachute = transform;
player.playerSkyMove.ParachuteAnchor = anchor;
}
public static void Destroy(UnityObject o, float t = 0f)
{
if (Application.isPlaying)
{
UnityObject.Destroy(o, t);
}
#if UNITY_EDITOR && UNITY_EDITORVR
else
{
if (Mathf.Approximately(t, 0f))
{
UnityObject.DestroyImmediate(o);
}
else
{
VRView.StartCoroutine(DestroyInSeconds(o, t));
}
}
#endif
}
public GameObject GetLeftWeaponGameObject(UnityObject weapon)
{
if (null == weapon || null == weapon.AsGameObject)
{
return(null);
}
var weaponObj = weapon.AsGameObject;
for (var i = 0; i < weaponObj.transform.childCount; ++i)
{
var child = weaponObj.transform.GetChild(i);
if (child.gameObject.name.Contains(SubLeftWeaponSuffix))
{
return(child.gameObject);
}
}
Logger.ErrorFormat("weapon {0} do not have leftWeapon", weapon.AsGameObject.name);
return(null);
}
void CheckPersistentCanvas()
{
if (m_RootUIPersistentCanvas == null)
{
var uiManager = UnityObject.FindObjectOfType <DebugUIHandlerPersistentCanvas>();
if (uiManager == null)
{
m_PersistentRoot = UnityObject.Instantiate(Resources.Load <Transform>("DebugUI Persistent Canvas")).gameObject;
m_PersistentRoot.name = "[Debug Canvas - Persistent]";
m_PersistentRoot.transform.localPosition = Vector3.zero;
}
else
{
m_PersistentRoot = uiManager.gameObject;
}
m_RootUIPersistentCanvas = m_PersistentRoot.GetComponent <DebugUIHandlerPersistentCanvas>();
}
}
void Awake()
{
TinyCoro.SpawnNext(DoPreform);
var cameraRotate = new UnityObject(GameObject.Find("CameraRotate"));
cameraRotate.UnityUpdate += u => u.Transform.Rotate(Vector3.up, -2f * Time.deltaTime);
var guiRect = new Rect(0, 0, Screen.width, Screen.height);
cameraRotate.UnityGUI += (u) =>
{
var guiText = string.Format("Generation: {0}\nBest Score: {1} (distance + head height + waist height, in gen: {2})\nv0.4 running for {3}",
Generation,
TopScore,
TopScoreGen,
TimeSpan.FromSeconds(Time.timeSinceLevelLoad));
if(_configLines != null)
guiText += "\n" + string.Join("\n", _configLines);
GUI.Label(guiRect, guiText);
};
}
public void OnLoadSucc(object source, UnityObject unityObj)
{
var player = source as PlayerEntity;
var fxCam = player.cameraObj.EffectCamera;
var assetInfo = unityObj.Address;
if (assetInfo.Equals(AssetConfig.GetCameraPoisonEffect()))
{
var go = unityObj.AsGameObject;
if (null != go)
{
player.cameraFx.Poison = go.GetComponentInChildren <ParticleSystem>().gameObject;
player.cameraFx.Poison.layer = UnityLayerManager.GetLayerIndex(EUnityLayerName.CameraFx);
go.transform.parent = fxCam.transform;
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
}
}
}
public void OnLoadNecessaryObjectSucess(SceneObjectEntity entity, UnityObject unityObj)
{
if (!Vertify(entity, unityObj))
{
CheckLoadingState(entity);
return;
}
entity.multiUnityObject.CacheAssetObject(unityObj);
if (unityObj.AsGameObject)
{
AppearanceUtils.EnableRender(unityObj.AsGameObject);
}
else
{
SceneObjectLoadSystem.Logger.ErrorFormat("asset {0}'s gameobject is null",
unityObj.Address);
}
CheckLoadingState(entity);
}
public static void Destroy()
{
if (SingletonManager.Get <FreeUiManager>().Contexts1 != null && SingletonManager.Get <FreeUiManager>().Contexts1.session != null && SingletonManager.Get <FreeUiManager>().Contexts1.session.clientSessionObjects != null)
{
var assetManager = SingletonManager.Get <FreeUiManager>().Contexts1.session.commonSession.AssetManager;
foreach (string buddle in cache.Keys)
{
foreach (Queue <GameObject> que in cache[buddle].Values)
{
foreach (GameObject obj in que)
{
var unityObj = UnityObject.GetUnityObject(obj);
assetManager.Recycle(unityObj);
}
}
}
}
cache.Clear();
}
private bool Vertify(SceneObjectEntity entity, UnityObject unityObj)
{
if (unityObj == null)
{
SceneObjectLoadSystem.Logger.Error("loaded unityObj is null");
return(false);
}
if (entity == null)
{
SceneObjectLoadSystem.Logger.Error("Scene entity is null");
return(false);
}
if (!entity.hasMultiUnityObject)
{
SceneObjectLoadSystem.Logger.Error("MultiUnityObject component is needed !");
return(false);
}
return(true);
}
private void OnLoadSucc(string source, UnityObject unityObj)
{
var assetInfo = unityObj.Address;
_loadingAsset.Remove(assetInfo);
try
{
OnLoadSuccImpl(unityObj);
}
catch (Exception e)
{
_logger.Error(e);
}
if (_loadingAsset.Count == 0 && _handledCallback != null)
{
_handledCallback();
}
}
void OnFixedUpdate(UnityObject me)
{
_time += Time.fixedDeltaTime;
if(!Finished)
{
_frames++;
if (_frames > FramesPerTest)
Finished = true;
for (var i = 0; i < Steps.Count; ++i )
{
var step = Steps[i];
if (_time >= step.NextAt)
{
step.LastAt = step.NextAt;
step.NextAt += LocoStep.GaitDuration;
}
if (_time >= step.LastAt && _time < step.LastAt + step.Duration)
{
//Todo fix literal edge case
//var dt = Mathf.Min(_time - step.LastAt, Time.fixedDeltaTime);
var dt = Time.fixedDeltaTime;
_monster.Joints[step.Joint].AddRelativeTorque(step.Rotation * step.Force * dt);
}
}
var score = _monster.Joints["Head"].position.y;
if (score > FinalScore)
FinalScore = score;
//var dist = _monster.Joints.Values.Max(j => j.transform.position.z) - _monster.WorldPosition.z;
//if(_frames >= _nextScoreAt)
//{
// _nextScoreAt += 30;
// FinalScore += dist;// +(_monster.Joints["Head"].position.y * 0.4f);
//}
}
}
public void LoadedTerrainData(Object obj, UnityObject asset)
{
--_loadingDataCount;
var terrainName = asset.Address.AssetName;
var data = asset.As <TextAsset>();
if (data == null)
{
if (_cachedTerrain.ContainsKey(terrainName))
{
try
{
if (!_detailManager.TerrainLoaded(_cachedTerrain[terrainName], _cachedDetailDist[terrainName]))
{
logger.ErrorFormat("unmatch parameter in {0}", terrainName);
}
}
catch (Exception e)
{
logger.Error(terrainName + "\n" + e.Message + "\n" + e.StackTrace);
throw e;
}
}
else
{
logger.ErrorFormat("wrong loaded terraindata name: {0}", terrainName);
}
}
else
{
if (_cachedTerrain.ContainsKey(terrainName))
{
if (!_detailManager.TerrainLoaded(data, _cachedTerrain[terrainName], _cachedDetailDist[terrainName]))
{
logger.ErrorFormat("unmatch parameter in {0}", terrainName);
}
}
}
}
private void InitLoadedVehicle(VehicleEntity vehicle, UnityObject unityObj)
{
var go = unityObj.AsGameObject;
AssertUtility.Assert(go != null);
//vehicle.gameObject.Value.GetComponent<Rigidbody>().isConstantColliderPose = true;
_logger.InfoFormat("Client Create Vehicle {0} Enter OnLoadSucc EntityKey {1} Position {2}", unityObj.Address, vehicle.entityKey, go.transform.position);
// UnityEngine.Debug.LogError("Client Load Vehicle Successfully!!!");
if (vehicle.HasDynamicData())
{
var dataComp = vehicle.GetDynamicData();
go.transform.rotation = dataComp.Rotation;
go.transform.position = dataComp.Position.ShiftedVector3();
}
_logger.InfoFormat("Client Create Vehicle {0} Transform Set EntityKey {1} Position {2}", unityObj.Address, vehicle.entityKey, go.transform.position);
vehicle.AddVehicleComponentsPostInit((EVehicleType)vehicle.vehicleAssetInfo.VType, unityObj,
_contexts.player, false);
var vehicleTimer = _contexts.session.clientSessionObjects.VehicleTimer;
vehicle.SetTimer(vehicleTimer);
if (!vehicle.isFlagOffline && !SharedConfig.DynamicPrediction)
{
vehicle.SetKinematic(true);
}
if (SharedConfig.DynamicPrediction)
{
VehicleStateUtility.SetVehicleSyncLatest(vehicle, true);
}
var target = RayCastTargetUtil.AddRayCastTarget(go);
VehicleCastData.Make(target, vehicle.entityKey.Value.EntityId);
}
public void OnLoadSucc(string source, UnityObject unityObj)
{
SingletonManager.Get <SubProgressBlackBoard>().Step();
if (!Luminosity.IO.InputManager.Exists)
{
Logger.ErrorFormat("No Luminosity.IO.InputManager exist");
}
else
{
var cfg = unityObj.As <TextAsset>();
if (null != cfg)
{
var content = cfg.bytes;
Luminosity.IO.InputManager.Load(content);
}
else
{
Logger.Error("Cfg is null or not text asset");
}
}
_sessionState.FullfillExitCondition(typeof(InputManagerConfigInitSystem));
}
public void OnLoadSuccess <T>(T source, UnityObject unityObj)
{
var go = unityObj.AsGameObject;
if (null == go)
{
return;
}
BoneTool.CacheTransform(go);
if (_dataSource._p1Index == _index)
{
AppearanceUtils.DisableRender(_dataSource._propObjP1);
_dataSource._propObjP1 = go;
if (!_dataSource.IsFirstPerson)
{
AppearanceUtils.DisableRender(go);
_dataSource.AddRecycleObject(unityObj);
}
}
else if (_dataSource._p3Index == _index)
{
AppearanceUtils.DisableRender(_dataSource._propObjP3);
_dataSource._propObjP3 = go;
if (_dataSource.IsFirstPerson)
{
AppearanceUtils.DisableRender(go);
_dataSource.AddRecycleObject(unityObj);
}
}
else
{
AppearanceUtils.DisableRender(go);
_dataSource.AddRecycleObject(unityObj);
}
_dataSource.MountPropToHand(_index);
}
public void OnLoadSucc(string source, UnityObject unityObj)
{
#if !UnitTest
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("OnLoadSucc {0}", unityObj.Address);
}
#endif
if (!_loadKeys.ContainsKey(unityObj.Address))
{
_assetManager.Recycle(unityObj);
return;
}
_loadKeys.Remove(unityObj.Address);
var go = unityObj.AsGameObject;
_loadedGo[unityObj.Address] = unityObj;
AppearanceUtils.EnableRender(go);
if (null != _loadedCb)
{
_loadedCb(unityObj.Address, go);
}
}
private bool IsTileAvailable(BaseTile selectedTile, UnityObject unityObject)
{
Vector2Int coordinateInt = new Vector2Int((int)selectedTile.Coordinate.x, (int)selectedTile.Coordinate.y);
int halfZoneSizeX = (int)(unityObject.SizeInTiles().x / 2.0); //round down
int halfZoneSizeY = (int)(unityObject.SizeInTiles().z / 2.0); //round down
//makes an uneven Zone symmetric
int symmetricOffsetX = -1;
if (unityObject.SizeInTiles().x % 2 == 0)
{
symmetricOffsetX = 0;
}
int symmetricOffsetY = -1;
if (unityObject.SizeInTiles().z % 2 == 0)
{
symmetricOffsetY = 0;
}
for (int x = coordinateInt.x - halfZoneSizeX; x < coordinateInt.x + halfZoneSizeX - symmetricOffsetX; x++)
{
for (int y = coordinateInt.y - halfZoneSizeY; y < coordinateInt.y + halfZoneSizeY - symmetricOffsetY; y++)
{
if (!OutsideGrid(x, y))
{
BaseTile tile = GetTileByCoordinates(x, y);
if (tile.State == State.Unavailable || tile.State == State.Off)
{
return(false);
}
}
else
{
return(false);
}
}
}
return(true);
}
public static IEnumerator GetAssetPreview(UnityObject obj, Action <Texture> callback)
{
Texture texture = null;
#if UNITY_EDITOR
texture = AssetPreview.GetAssetPreview(obj);
while (AssetPreview.IsLoadingAssetPreview(obj.GetInstanceID()))
{
texture = AssetPreview.GetAssetPreview(obj);
yield return(null);
}
if (!texture)
{
texture = AssetPreview.GetMiniThumbnail(obj);
}
#else
yield return(null);
#endif
callback(texture);
}
public void OnLoadSuccess <T>(T source, UnityObject obj)
{
if (null == obj)
{
return;
}
var m = obj.AsObject as Material;
if (null == m)
{
return;
}
switch (_shaderType)
{
case ShaderType.DefaultShader:
_defaultShader = m.shader;
break;
case ShaderType.TopSideShader:
_topLayerShader = m.shader;
break;
}
}
protected override void OnLoadSuccImpl(UnityObject unityObj)
{
var asset = unityObj.As <TextAsset>();
if (null != asset)
{
var config = XmlConfigParser <SpeedCurveConfig> .Load(asset.text);
SingletonManager.Get <CharacterStateConfigManager>().AirMoveCurve = config.AirMoveCurve.toCurve();
List <MovementCurveInfo> movementCurve = new List <MovementCurveInfo>();
foreach (var info in config.MovementCurveInfos)
{
movementCurve.Add(info.ToMovementCurveInfo());
}
List <PostureCurveInfo> postureCurve = new List <PostureCurveInfo>();
foreach (var info in config.PostureCurveInfos)
{
postureCurve.Add(info.ToPostureCurveInfo());
}
SingletonManager.Get <CharacterStateConfigManager>().MovementCurve = movementCurve;
SingletonManager.Get <CharacterStateConfigManager>().PostureCurve = postureCurve;
}
}
public void AssignGo(UnityObject unityObj, CullingHandler handler, StreamingGoKey key,
Vector3 position, Vector3 size, IStreamingResourceHandler resHandler)
{
if (_height > 0 && FitInOneChild(size))
{
var index = GetChildIndex(position);
_children[index].AssignGo(unityObj, handler, key, position, size, resHandler);
}
else
{
var streamingGo = _streamingGoMap[key];
if (streamingGo.SetGo(unityObj))
{
while (handler != null)
{
handler.StateChanged(_cullingState[(int)handler.Category] != CullState.Culled);
var sibling = handler.Sibling;
handler.Sibling = null;
streamingGo.AddHandler(handler);
ChangeCullingCount(handler.Category, 1);
handler = sibling;
}
}
else
{
resHandler.UnloadGo(unityObj, key.SceneIndex);
while (handler != null)
{
var sibling = handler.Sibling;
handler.Free();
handler = sibling;
}
}
}
}
public void GoLoaded(int sceneIndex, int goIndex, UnityObject unityObj)
{
if (_sceneOctrees.ContainsKey(sceneIndex))
{
var sceneDesc = _sceneDesc[sceneIndex];
var goDesc = sceneDesc.Objects[goIndex];
var handlerHead = _cullingItemFactory.CreateCullingHandlers(unityObj, goDesc.SceneTag);
_sceneOctrees[sceneIndex].AssignGo(unityObj, handlerHead,
new StreamingGoKey
{
SceneIndex = sceneIndex,
GoIndex = goIndex
},
goDesc.Position, goDesc.Size, _resourceHandler);
unityObj.AsGameObject.transform.SetParent(_goRoot[sceneIndex].transform);
}
else
{
_resourceHandler.UnloadGo(unityObj, sceneIndex);
}
}
public void OnLoadSucc(string source, UnityObject unityObj)
{
var assetInfo = unityObj.Address;
var asset = unityObj.As <TextAsset>();
if (null == asset)
{
Logger.ErrorFormat("Asset {0}:{1} Load Fialed ", assetInfo.BundleName, assetInfo.AssetName);
return;
}
_cfg = asset.text;
if (null == _parser)
{
Logger.ErrorFormat("instance to parse config {0} is null ", typeof(T));
return;
}
Logger.InfoFormat("ParseConfig {0}:{1}", assetInfo.BundleName, assetInfo.AssetName);
ThreadPool.QueueUserWorkItem(ParseConfig, this);
SingletonManager.Get <SubProgressBlackBoard>().Step();
}
public MonoBehaviourMessages(UnityObject unityObject)
{
UnityObject = unityObject;
}
public static void SetLocalObject(UnityObject unityObject, UnityEngine.Object localObject)
{
localObjects[unityObject] = localObject;
}
public void SetUnityObject(UnityObject unityObject)
{
UnityObject = unityObject;
}
public static UnityObject ShowInEditor(string label, UnityObject unityObject, Type type)
{
if (unityObject == null) {
unityObject = new UnityObject();
}
unityObject = Load(unityObject, type);
SetLocalObject(unityObject,EditorGUILayout.ObjectField(label, GetLocalObject(unityObject), type, false));
unityObject = Save(unityObject);
return unityObject;
}
public static void DisplayHierarchy(UnityObject obj)
{
gosToDisplay.Add(obj);
}
public StandardUnit(ConflictResolver resolver, UnityObject unity)
{
Resolver = resolver;
Health = unity.InitialHealth;
UnitName = unity.Name;
}
public void BeforeEach()
{
conflictResolver = Substitute.For<ConflictResolver>();
unity = Substitute.For<UnityObject>();
}
