public override void CustomMethod()
{
if (GameObjectRef != null)
{
GameObjectRef.GetComponent <Mono_Toggle>().FlipSwitch(SwitchState[0]);
}
}
public static int AddGameObject(int type, string assetName, Object asset)
{
if (asset == null)
{
return(0);
}
if (!(asset is GameObject))
{
Debug.LogError(assetName + " is not a GameObject");
return(0);
}
if (ResourceManager.isLog)
{
Debug.Log("gameObject create " + assetName);
}
GameObject obj = (GameObject)GameObject.Instantiate(asset, Vector3.zero, Quaternion.identity);
obj = InitGameObject(type, obj, assetName);
obj.SetActive(false);
int instanceId = obj.GetInstanceID();
GameObjectRef gameObjectRef = GetTempGameObjectRef();
gameObjectRef.assetName = assetName;
gameObjectRef.instanceId = instanceId;
gameObjectRef.obj = obj;
_gameObjectRef.Add(instanceId, gameObjectRef);
return(instanceId);
}
public static int AddGameObject(string assetName, Object asset)
{
if (asset == null)
{
return(0);
}
if (!(asset is GameObject))
{
Debug.LogError(assetName + " is not a GameObject");
return(0);
}
Debug.Log("gameObject create " + assetName);
// TODO 根据具体的需求实例化实体
GameObject obj = (GameObject)GameObject.Instantiate(asset, Vector3.zero, Quaternion.identity);
int instanceId = obj.GetInstanceID();
GameObjectRef gameObjectRef = GetTempGameObjectRef();
gameObjectRef.assetName = assetName;
gameObjectRef.instanceId = instanceId;
gameObjectRef.obj = obj;
_gameObjectRef.Add(instanceId, gameObjectRef);
return(instanceId);
}
public ComponentRef(GameObjectRef.eSourceType sourceType, Component component)
{
GameObject gameObject = component != null ? component.gameObject : null;
_gameObject = new GameObjectRef(sourceType, gameObject);
_componentIndex = 0;
_component = component as T;
_editorCollapsed = false;
if (component != null)
{
Component[] components = gameObject.GetComponents <Component>();
int index = 0;
for (int i = 0; i < components.Length; i++)
{
if (components[i] is T)
{
if (components[i] == component)
{
_componentIndex = index;
break;
}
index++;
}
}
}
}
public ComponentRef(GameObjectRef.eSourceType sourceType)
{
_gameObject = new GameObjectRef(sourceType);
_componentIndex = 0;
_component = null;
_editorCollapsed = false;
}
private static void RenderSceneGameObjectField(ref GameObjectRef gameObjectRef, ref bool dataChanged)
{
if (gameObjectRef.IsValid())
{
Scene scene = gameObjectRef.GetSceneRef().GetScene();
if (scene.IsValid() && scene.isLoaded)
{
EditorGUI.BeginChangeCheck();
GameObject gameObj = (GameObject)EditorGUILayout.ObjectField(kLabel, gameObjectRef.GetGameObject(), typeof(GameObject), true);
if (EditorGUI.EndChangeCheck())
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Scene, gameObj);
dataChanged = true;
}
}
else if (RenderSceneNotLoadedField(gameObjectRef))
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Scene);
dataChanged = true;
}
}
else
{
EditorGUI.BeginChangeCheck();
GameObject gameObj = (GameObject)EditorGUILayout.ObjectField(kLabel, gameObjectRef.GetGameObject(), typeof(GameObject), true);
if (EditorGUI.EndChangeCheck())
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Scene, gameObj);
dataChanged = true;
}
}
}
private void Awake()
{
Instance = this;
this.refs = this.GetComponent <GameObjectRef>();
this.LevelMenuNode.gameObject.SetActive(false);
this.QuizMenuNode.gameObject.SetActive(false);
this.ResetButton.onClick.AddListener(() => { PuzzleComponent.Instance.Reset(); });
this.ResultComponent.OnNext = () =>
{
++this.CurrentQuizID;
this.ResultComponent.gameObject.SetActive(false);
this.ResetButton.gameObject.SetActive(true);
if (!string.IsNullOrEmpty(Config.GetQuiz(this.CurrentLevel, this.CurrentQuizID)))
{
PuzzleComponent.Instance.StartGame(this.CurrentLevel, this.CurrentQuizID);
}
else
{
this.UndoCommandMgr.Undo();
this.UndoCommandMgr.Undo();
}
};
this.InitLevelMenu();
this.UndoCommandMgr = new UndoCommandMgr();
this.startGameCommand = new StartGameCommand(this);
this.selectLevelCommand = new SelectLevelCommand(this);
this.selectQuizCommand = new SelectQuizCommand(this);
}
protected override void InternalUpdate(State[] oldState)
{
if (!Enumerable.SequenceEqual(oldState, PinState))
{
BitArray bitField = new BitArray(new bool[] {
PinState[0] == State.HIGH,
PinState[1] == State.HIGH,
PinState[3] == State.HIGH
});
int[] array = new int[1];
bitField.CopyTo(array, 0);
// float ts = 1.0f / ((((array[0]+0.0f) / 7.0f) * 29.0f) + 1.0f);
float ts = 1.0f / (Mathf.Pow(2, array[0]));
if (mono_Clock == null)
{
mono_Clock = GameObjectRef.GetComponent <Mono_Clock>();
}
mono_Clock.StartClock(ts, this);
}
PinState[4] = On ? State.HIGH : State.LOW;
}
public static object PropertyField(object obj, GUIContent label, ref bool dataChanged, GUIStyle style, params GUILayoutOption[] options)
{
GameObjectRef gameObjectRef = (GameObjectRef)obj;
if (label == null)
{
label = new GUIContent();
}
label.text += " (" + gameObjectRef + ")";
bool editorCollapsed = !EditorGUILayout.Foldout(!gameObjectRef._editorCollapsed, label);
if (editorCollapsed != gameObjectRef._editorCollapsed)
{
gameObjectRef._editorCollapsed = editorCollapsed;
dataChanged = true;
}
if (!editorCollapsed)
{
int origIndent = EditorGUI.indentLevel;
EditorGUI.indentLevel++;
//Show drop down
GameObjectRef.eSourceType sourceType = SerializationEditorGUILayout.ObjectField(gameObjectRef.GetSourceType(), "Source Type", ref dataChanged);
if (sourceType != gameObjectRef.GetSourceType())
{
gameObjectRef = new GameObjectRef(sourceType);
dataChanged = true;
}
switch (sourceType)
{
case GameObjectRef.eSourceType.Scene:
{
RenderSceneGameObjectField(ref gameObjectRef, ref dataChanged);
}
break;
case GameObjectRef.eSourceType.Prefab:
{
RenderPrefabGameObjectField(ref gameObjectRef, ref dataChanged);
}
break;
case GameObjectRef.eSourceType.Loaded:
{
RenderLoadedGameObjectField(ref gameObjectRef, ref dataChanged);
}
break;
}
EditorGUI.indentLevel = origIndent;
}
return(gameObjectRef);
}
public static void set(Arg arg)
{
string @string = arg.GetString(0);
if (string.IsNullOrEmpty(@string))
{
Debug.Log("Invalid gamemode");
}
BaseGameMode baseGameMode = null;
GameObjectRef gameObjectRef = null;
GameModeManifest gameModeManifest = GameModeManifest.Get();
Debug.Log("total gamemodes : " + gameModeManifest.gameModePrefabs.Count);
foreach (GameObjectRef gameModePrefab in gameModeManifest.gameModePrefabs)
{
BaseGameMode component = gameModePrefab.Get().GetComponent <BaseGameMode>();
if (component.shortname == @string)
{
baseGameMode = component;
gameObjectRef = gameModePrefab;
Debug.Log("Found :" + component.shortname + " prefab name is :" + component.PrefabName + ": rpath is " + gameModePrefab.resourcePath + ":");
break;
}
Debug.Log("search name " + @string + "searched against : " + component.shortname);
}
if (baseGameMode == null)
{
Debug.Log("Unknown gamemode : " + @string);
return;
}
BaseGameMode activeGameMode = BaseGameMode.GetActiveGameMode(true);
if ((bool)activeGameMode)
{
if (baseGameMode.shortname == activeGameMode.shortname)
{
Debug.Log("Same gamemode, resetting");
}
if (activeGameMode.permanent)
{
Debug.LogError("This game mode is permanent, you must reset the server to switch game modes.");
return;
}
activeGameMode.ShutdownGame();
activeGameMode.Kill();
BaseGameMode.SetActiveGameMode(null, true);
}
BaseEntity baseEntity = GameManager.server.CreateEntity(gameObjectRef.resourcePath, Vector3.zero, Quaternion.identity);
if ((bool)baseEntity)
{
Debug.Log("Spawning new game mode : " + baseGameMode.shortname);
baseEntity.Spawn();
}
else
{
Debug.Log("Failed to create new game mode :" + baseGameMode.PrefabName);
}
}
private void Awake()
{
Instance = this;
this.PoolNode = new GameObject("ObjectPool");
this.PoolNode.transform.SetParent(this.transform);
this.refs = this.GetComponent <GameObjectRef>();
this.InitPool();
}
public override void CustomMethod()
{
if (mono == null)
{
mono = GameObjectRef.GetComponent <Mono_Led>();
}
mono.ToggleLed(On);
}
public static void ImpactEffect(HitInfo info)
{
if (!info.DoHitEffects)
{
return;
}
string materialName = StringPool.Get(info.HitMaterial);
string strName = EffectDictionary.GetParticle(info.damageTypes.GetMajorityDamageType(), materialName);
string decal = EffectDictionary.GetDecal(info.damageTypes.GetMajorityDamageType(), materialName);
if (TerrainMeta.WaterMap != null && info.HitMaterial != Projectile.WaterMaterialID() && info.HitMaterial != Projectile.FleshMaterialID() && info.HitPositionWorld.y < TerrainMeta.WaterMap.GetHeight(info.HitPositionWorld) && WaterLevel.Test(info.HitPositionWorld, false))
{
return;
}
if (BaseEntityEx.IsValid(info.HitEntity))
{
GameObjectRef impactEffect = info.HitEntity.GetImpactEffect(info);
if (impactEffect.isValid)
{
strName = impactEffect.resourcePath;
}
Run(strName, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal);
if (info.DoDecals)
{
Run(decal, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal);
}
}
else
{
Type overrideType = Type.Generic;
Run(strName, info.HitPositionWorld, info.HitNormalWorld, default(Vector3), overrideType);
Run(decal, info.HitPositionWorld, info.HitNormalWorld, default(Vector3), overrideType);
}
if ((bool)info.WeaponPrefab)
{
BaseMelee baseMelee = info.WeaponPrefab as BaseMelee;
if (baseMelee != null)
{
string strikeEffectPath = baseMelee.GetStrikeEffectPath(materialName);
if (BaseEntityEx.IsValid(info.HitEntity))
{
Run(strikeEffectPath, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal);
}
else
{
Run(strikeEffectPath, info.HitPositionWorld, info.HitNormalWorld);
}
}
}
if (info.damageTypes.Has(DamageType.Explosion))
{
DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/explosion.prefab");
}
if (info.damageTypes.Has(DamageType.Heat))
{
DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/fire.prefab");
}
}
public ComponentRef(GameObjectRef.eSourceType sourceType, Component component, int componentIndex)
{
GameObject gameObject = component != null ? component.gameObject : null;
_gameObject = new GameObjectRef(sourceType, gameObject);
_componentIndex = componentIndex;
_component = component as T;
_editorCollapsed = false;
}
public static void ImpactEffect(HitInfo info)
{
if (!info.DoHitEffects)
{
return;
}
string materialName = StringPool.Get(info.HitMaterial);
if (Object.op_Inequality((Object)TerrainMeta.WaterMap, (Object)null) && (int)info.HitMaterial != (int)Projectile.WaterMaterialID() && ((int)info.HitMaterial != (int)Projectile.FleshMaterialID() && info.HitPositionWorld.y < (double)WaterLevel.GetWaterDepth(info.HitPositionWorld)))
{
return;
}
string strName = EffectDictionary.GetParticle(info.damageTypes.GetMajorityDamageType(), materialName);
string decal = EffectDictionary.GetDecal(info.damageTypes.GetMajorityDamageType(), materialName);
if (info.HitEntity.IsValid())
{
GameObjectRef impactEffect = info.HitEntity.GetImpactEffect(info);
if (impactEffect.isValid)
{
strName = impactEffect.resourcePath;
}
Effect.server.Run(strName, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal, info.Predicted, false);
Effect.server.Run(decal, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal, info.Predicted, false);
}
else
{
Effect.server.Run(strName, info.HitPositionWorld, info.HitNormalWorld, info.Predicted, false);
Effect.server.Run(decal, info.HitPositionWorld, info.HitNormalWorld, info.Predicted, false);
}
if (Object.op_Implicit((Object)info.WeaponPrefab))
{
BaseMelee weaponPrefab = info.WeaponPrefab as BaseMelee;
if (Object.op_Inequality((Object)weaponPrefab, (Object)null))
{
string strikeEffectPath = weaponPrefab.GetStrikeEffectPath(materialName);
if (info.HitEntity.IsValid())
{
Effect.server.Run(strikeEffectPath, info.HitEntity, info.HitBone, info.HitPositionLocal, info.HitNormalLocal, info.Predicted, false);
}
else
{
Effect.server.Run(strikeEffectPath, info.HitPositionWorld, info.HitNormalWorld, info.Predicted, false);
}
}
}
if (info.damageTypes.Has(DamageType.Explosion))
{
Effect.server.DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/explosion.prefab");
}
if (!info.damageTypes.Has(DamageType.Heat))
{
return;
}
Effect.server.DoAdditiveImpactEffect(info, "assets/bundled/prefabs/fx/impacts/additive/fire.prefab");
}
protected override void InternalReset(bool disable)
{
if (mono_Clock == null)
{
mono_Clock = GameObjectRef.GetComponent <Mono_Clock>();
}
mono_Clock.StopClock();
PinState[4] = State.OFF;
On = false;
}
public override void CustomMethod()
{
if (GameObjectRef != null)
{
for (int i = 0; i < SwitchPins / 2; i++)
{
GameObjectRef.GetComponent <Mono_Dip>().FlipSwitch(i, SwitchState[i]);
}
}
}
private void PropertiesView_PreviewDrop(object sender, DragEventArgs e)
{
GameObjectNode gameObjNode = _selectedObject as GameObjectNode;
GameObjectRef gameObj = gameObjNode.mGameObject;
gameObj.AddComponent(DragItem.DragText);
BorderBrush = Brushes.Transparent;
SelectedObject = null;
SelectedObject = gameObjNode;
}
public static StateMachine FromTextAsset(TextAsset asset, GameObject sourceObject = null)
{
StateMachine timelineStateMachine = Serializer.FromTextAsset <StateMachine>(asset);
if (sourceObject != null)
{
GameObjectRef.FixUpGameObjectRefsInObject(timelineStateMachine, sourceObject);
}
return(timelineStateMachine);
}
public override void CustomMethod()
{
if (mono == null)
{
mono = GameObjectRef.GetComponentInChildren <Mono_Segment>();
}
for (int i = 0; i < 8; i++)
{
mono.ToggleLed(i, Ons[i]);
}
}
public static TimelineStateMachine FromTextAsset(TextAsset asset, GameObject sourceObject = null)
{
TimelineStateMachine timelineStateMachine = SerializeConverter.FromTextAsset <TimelineStateMachine>(asset);
if (sourceObject != null)
{
GameObjectRef.FixupGameObjectRefs(sourceObject, timelineStateMachine);
}
return(timelineStateMachine);
}
private static void RenderPrefabGameObjectField(ref GameObjectRef gameObjectRef, ref bool dataChanged)
{
EditorGUI.BeginChangeCheck();
GameObject prefabGameObject = (GameObject)EditorGUILayout.ObjectField(kLabel, gameObjectRef.GetGameObject(), typeof(GameObject), true);
if (EditorGUI.EndChangeCheck())
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Prefab, prefabGameObject);
dataChanged = true;
}
}
private static object FixUpGameObjectRef(object obj, object gameObject)
{
if (obj.GetType() == typeof(GameObjectRef))
{
GameObjectRef gameObjectRef = (GameObjectRef)obj;
gameObjectRef._sourceObject = (GameObject)gameObject;
return(gameObjectRef);
}
return(obj);
}
private void LoadNodeGraph()
{
_nodegraph = _nodeGraphRef.LoadNodeGraph();
if (_nodegraph != null)
{
GameObjectRef.FixUpGameObjectRefsInObject(_nodegraph, this.gameObject);
FixupInputs();
_outputNodes = _nodegraph.GetOutputNodes();
}
}
public void SpawnFuelStorage(GameObjectRef fuelStoragePrefab, Transform fuelStoragePoint)
{
if (fuelStoragePrefab != null && !(fuelStoragePoint == null) && !Rust.Application.isLoadingSave)
{
Vector3 pos = owner.transform.InverseTransformPoint(fuelStoragePoint.position);
Quaternion rot = Quaternion.Inverse(owner.transform.rotation) * fuelStoragePoint.rotation;
BaseEntity baseEntity = GameManager.server.CreateEntity(fuelStoragePrefab.resourcePath, pos, rot);
baseEntity.SetParent(owner);
baseEntity.Spawn();
fuelStorageInstance.Set(baseEntity);
}
}
private static void RecoveryGameObjectRef(GameObjectRef gameObjectRef)
{
if (gameObjectRef == null)
{
return;
}
if (gameObjectRef.obj != null)
{
GameObject.Destroy(gameObjectRef.obj);
ReferenceObject.ReleaseObject(gameObjectRef.assetName);
}
Debug.Log("gameObejct Destory " + gameObjectRef.assetName);
gameObjectRef.Clear();
_freeGameObjectRef.Add(gameObjectRef);
}
private static GameObjectRef GetTempGameObjectRef()
{
GameObjectRef gameObjectRef = null;
if (_freeGameObjectRef.Count > 0)
{
gameObjectRef = _freeGameObjectRef[0];
_freeGameObjectRef.RemoveAt(0);
}
else
{
gameObjectRef = new GameObjectRef();
}
return(gameObjectRef);
}
private static void RenderLoadedGameObjectField(ref GameObjectRef gameObjectRef, ref bool dataChanged)
{
if (gameObjectRef.IsValid())
{
Scene scene = gameObjectRef.GetSceneRef().GetScene();
if (scene.IsValid() && scene.isLoaded)
{
//If loaded and not tried finding editor loader, find it now
GameObjectLoader gameObjectLoader = gameObjectRef.GetEditorGameObjectLoader(scene);
//If have a valid loader...
if (gameObjectLoader != null)
{
if (gameObjectLoader.IsLoaded())
{
EditorGUI.BeginChangeCheck();
GameObject obj = (GameObject)EditorGUILayout.ObjectField(kLabel, gameObjectRef.GetGameObject(), typeof(GameObject), true);
if (EditorGUI.EndChangeCheck())
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Loaded, obj);
dataChanged = true;
}
}
else if (RenderLoadedNotLoadedField(gameObjectLoader))
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Loaded);
dataChanged = true;
}
}
}
else if (RenderSceneNotLoadedField(gameObjectRef))
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Loaded);
dataChanged = true;
}
}
else
{
EditorGUI.BeginChangeCheck();
GameObject obj = (GameObject)EditorGUILayout.ObjectField(kLabel, gameObjectRef.GetGameObject(), typeof(GameObject), true);
if (EditorGUI.EndChangeCheck())
{
gameObjectRef = new GameObjectRef(GameObjectRef.eSourceType.Loaded, obj);
dataChanged = true;
}
}
}
private void PropertiesView_PreviewDragOver(object sender, DragEventArgs e)
{
GameObjectNode gameObjNode = _selectedObject as GameObjectNode;
GameObjectRef gameObj = gameObjNode.mGameObject;
if (DragItem is ScriptNode && !gameObj.GetHasComponent(DragItem.DragText))
{
e.Handled = true;
BorderBrush = Brushes.LightGreen;
}
else
{
e.Effects = DragDropEffects.None;
BorderBrush = Brushes.Red;
}
}
public PubNubUnityBase(PNConfiguration pnConfiguration, GameObject gameObjectRef, IJsonLibrary jsonLibrary)
{
PNConfig = pnConfiguration;
PNLog = new PNLoggingMethod(PNConfig.LogVerbosity);
#if (UNITY_IOS)
Version = string.Format("PubNub-CSharp-UnityIOS/{0}", build);
#elif (UNITY_STANDALONE_WIN)
Version = string.Format("PubNub-CSharp-UnityWin/{0}", build);
#elif (UNITY_STANDALONE_OSX)
Version = string.Format("PubNub-CSharp-UnityOSX/{0}", build);
#elif (UNITY_ANDROID)
Version = string.Format("PubNub-CSharp-UnityAndroid/{0}", build);
#elif (UNITY_STANDALONE_LINUX)
Version = string.Format("PubNub-CSharp-UnityLinux/{0}", build);
#elif (UNITY_WEBPLAYER)
Version = string.Format("PubNub-CSharp-UnityWeb/{0}", build);
#elif (UNITY_WEBGL)
Version = string.Format("PubNub-CSharp-UnityWebGL/{0}", build);
#else
Version = string.Format("PubNub-CSharp-Unity/{0}", build);
#endif
#if (ENABLE_PUBNUB_LOGGING)
this.PNLog.WriteToLog(Version, PNLoggingMethod.LevelInfo);
#endif
if (gameObjectRef == null)
{
#if (ENABLE_PUBNUB_LOGGING)
this.PNLog.WriteToLog("Initilizing new GameObject", PNLoggingMethod.LevelInfo);
#endif
GameObjectRef = new GameObject("PubnubGameObject");
localGobj = true;
}
else
{
#if (ENABLE_PUBNUB_LOGGING)
this.PNLog.WriteToLog("Reusing already initialized GameObject", PNLoggingMethod.LevelInfo);
#endif
GameObjectRef = gameObjectRef;
localGobj = false;
}
publishMessageCounter = new Counter();
QManager = GameObjectRef.AddComponent <QueueManager> ();
latency = GameObjectRef.AddComponent <PNLatencyManager> ();
QManager.NoOfConcurrentRequests = PNConfig.ConcurrentNonSubscribeWorkers;
}
public EventTriggeredEvent(TriggeredEventPrefab triggeredEventPrefab)
{
targetPrefab = triggeredEventPrefab.targetPrefab;
}
